premi�re mouture

1 files changed, 303 insertions, 0 deletions

diff --git a/Python/Zinc.py b/Python/Zinc.py
new file mode 100644
index 0000000..7f51cf7
--- /dev/null
+++ b/Python/Zinc.py
@@ -0,0 +1,303 @@
+#---------------------------------------------------------------
+# 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