From 00c5d21ed6ec19cb26a29d5ac84f78422217020e Mon Sep 17 00:00:00 2001 From: lepied Date: Thu, 22 Jul 1999 13:00:52 +0000 Subject: premi�re mouture --- Python/Zinc.py | 303 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 303 insertions(+) create mode 100644 Python/Zinc.py 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 -- cgit v1.1