#---------------------------------------------------------------
# Project         : SALSA
# Module          : xradar
# File            : Radar.py
# Version         : $Id$
# Author          : Frederic Lepied
# Created On      : Thu Jul 22 09:36:04 1999
# Purpose         : Python interface to the tkradar TCL package
#---------------------------------------------------------------

__version__ = "$Revision$"

import types
from Tkinter import *
from Tkinter import _cnfmerge, _flatten

RADAR_NO_PART=-1
RADAR_CURRENT_POSITION=-2
RADAR_SPEED_VECTOR=-3
RADAR_LEADER=-4
RADAR_CONNECTION=-5

def havetkradar(window):
    try:
        window.tk.call('load', 'tkradar3.0.so')
        # Call a function from the package to autoload it
        # and verify that all is OK.
        window.tk.call('radar')
    except TclError:
        return 0
    return 1

class Radar(Widget):
    def __init__(self, master=None, cnf={}, **kw):
        Widget.__init__(self, master, 'radar', cnf, kw)
        self.items = {}

    def add(self, itemType, *args, **kw):
        args = _flatten(args)
        if len(args) != 0:
            cnf = args[-1]
        else:
            cnf={}
        if type(cnf) in (DictionaryType, TupleType):
            args = args[:-1]
        else:
            cnf = {}
        return self.tk.getint(apply(
            self.tk.call,
            (self._w, 'add', itemType) 
            + args + self._options(cnf, kw)))
    
    def itemcget(self, tagOrId, option):
        return self._do('itemcget', (tagOrId, '-'+option))

    def itemfieldcget(self, tagOrId, field, option):
        return self._do('itemcget', (tagOrId, field, '-'+option))

    def itemconfigure(self, tagOrId, field=None, **kw):
        if not kw:
            cnf = {}
            for x in self.tk.split(
                field != None and self._do('itemconfigure', (tagOrId, field)) or
                self._do('itemconfigure', (tagOrId,))):
                #print x
                cnf[x[0][1:]] = (x[0][1:],) + x[1:]
            return cnf
        #print self._options({}, kw)
        if field != None:
            self._do('itemconfigure', (tagOrId, str(field),)
                     + self._options({}, kw))
        else:
            self._do('itemconfigure', (tagOrId,)
                     + self._options({}, kw))
    itemconfig = itemconfigure

    def translate(self, dx=None, dy=None, tagOrId=None):
        if dx == None:
            return self._getints(self._do('translate'))
        else:
            if tagOrId == None:
                self._do('translate', (dx, dy))
            else:
                self._do('translate', (tagOrId, dx, dy))

    def scale(self, xFactor=None, yFactor=None, tagOrId=None):
        if yFactor == None:
            return self.tk.getdouble(self._do('scale'))
        else:
            if tagOrId == None:
                self._do('scale', (xFactor, yFactor))
            else:
                self._do('scale', (tagOrId, xFactor, yFactor))

    def addtag(self, *args):
        self._do('addtag', args)

    def addtag_above(self, newtag, tagOrId):
        self.addtag(newtag, 'above', tagOrId)

    def addtag_all(self, newtag):
    	self.addtag(newtag, 'all')

    def addtag_below(self, newtag, tagOrId):
    	self.addtag(newtag, 'below', tagOrId)

    def addtag_closest(self, newtag, x, y, halo=None, start=None):
    	self.addtag(newtag, 'closest', x, y, halo, start)

    def addtag_enclosed(self, newtag, x1, y1, x2, y2):
    	self.addtag(newtag, 'enclosed', x1, y1, x2, y2)

    def addtag_overlapping(self, newtag, x1, y1, x2, y2):
    	self.addtag(newtag, 'overlapping', x1, y1, x2, y2)

    def addtag_withtag(self, newtag, tagOrId):
	self.addtag(newtag, 'withtag', tagOrId)

    def classof(self, tagOrId):
        return self._do('class', (tagOrId,))

    def currentpart(self):
        return self.tk.getint(self._do('currentpart'))
                   
    def dtag(self, *args):
    	self._do('dtag', args)

    def find(self, *args):
    	return self._getints(self._do('find', args)) or ()

    def find_above(self, tagOrId):
    	return self.find('above', tagOrId)

    def find_all(self):
    	return self.find('all')

    def find_below(self, tagOrId):
    	return self.find('below', tagOrId)

    def find_closest(self, x, y, halo=None, start=None):
    	return self.find('closest', x, y, halo, start)

    def find_enclosed(self, x1, y1, x2, y2):
    	return self.find('enclosed', x1, y1, x2, y2)

    def find_overlapping(self, x1, y1, x2, y2):
    	return self.find('overlapping', x1, y1, x2, y2)

    def find_withtag(self, tagOrId):
    	return self.find('withtag', tagOrId)

    def gettags(self, *args):
    	return self.tk.splitlist(self._do('gettags', args))

    def remove(self, *args):
        self._do('remove', args)
    
    def tag_bind(self, tagOrId, sequence=None, func=None, add=None):
        return self._bind((self._w, 'bind', tagOrId),
                          sequence, func, add)

    def worldcoords(self, *args):
        return self._getints(self._do('worldcoords', args))

#     def addtag(self):
#         pass
#     
#     def bind(self):
#         pass
# 
# 
#     def cget(self):
#         pass
# 
#     def configure(self):
#         pass
# 
#     def dtag(self):
#         pass
# 
#     def find(self):
#         pass
# 
#     def gettags(self):
#         pass
# 
#     def hasfields(self):
#         pass
# 
#     def hastag(self):
#         pass
# 
#     def remove(self):
#         pass

class RadarItem:
    def __init__(self, radar, itemType, *args, **kw):
        self.radar = radar
        self.id = apply(radar.add, (itemType,) + args, kw)
        radar.items[self.id] = self
        
    def __str__(self):
        return str(self.id)

    def __repr__(self):
        return str(self.id)

    def delete(self):
        del self.radar.items[self.id]
        self.radar.delete(self.id)

    def __getitem__(self, key):
        return self.radar.itemcget(self.id, key)

    def __setitem__(self, key, value):
        self.radar.itemconfig(self.id, {key: value})

    def keys(self):
        if not hasattr(self, '_keys'):
            self._keys = {}
            config=self.radar.itemconfig(self.id)
            for x in config.keys():
                self._keys[x] = config[x][1]
        return self._keys

    def has_key(self, key):
        return key in self.keys()

    def config(self, field=None, **kw):
        return apply(self.radar.itemconfig, (self.id, field), kw)

    def cget(self, attr):
        return self.radar.itemcget(self.id, attr)
           
    def fieldcget(self, field, attr):
        return self.radar.itemfieldcget(self.id, field, attr)

    def bind(self, sequence=None, command=None, add=None):
        self.radar.tag_bind(self.id, sequence, command, add)
        
class Track(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'track') + args, kw)
    
class WayPoint(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'waypoint') + args, kw)
    
class Macro(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'macro') + args, kw)
    
class Map(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'map') + args, kw)
    
class MiniStrip(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'ministrip') + args, kw)    

class Rectangle(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'rectangle') + args, kw)    

class Arc(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'arc') + args, kw)    

class Multipoint(RadarItem):
    def __init__(self, radar, *args, **kw):
        apply(RadarItem.__init__, (self, radar, 'multipoint') + args, kw)    

# Class to hold mapinfos used by the Map Item class 
class Mapinfo:
    def __init__(self, interp, *args):
        self.interp=interp.tk
        apply(self.interp.call, ('mapinfo', self, 'create'))
        
    def __repr__(self):
        return `id(self)`

    def add_text(self, text_style, line_style, x, y, text):
        self.interp.call('mapinfo', self, 'add', 'text', text_style, line_style, x, y, text)

    def add_line(self, line_style, width, x1, y1, x2, y2):
        self.interp.call('mapinfo', self, 'add', 'line', line_style, width, x1, y1, x2, y2)

    def add_arc(self, line_style, width, cx, cy, radius, start, extent):
        self.interp.call('mapinfo', self, 'add', 'arc', line_style, width, cx, cy, radius, start, extent)

    def scale(self, factor):
        self.interp.call('mapinfo', self, 'scale', factor)
        
    def translate(self, xAmount, yAmount):
        self.interp.call('mapinfo', self, 'translate', xAmount, yAmount)
        
class Videomap (Mapinfo):
    def __init__(self, tk, *args):
        self.tk=tk.tk
        print args
        apply(self.tk.call, ('videomap', 'load') + args + (self,))

# Radar.py ends here