From 9bdf88f4cd99ef9d28db5f5567592082cbc8c61d Mon Sep 17 00:00:00 2001 From: lecoanet Date: Mon, 15 Sep 2008 09:38:54 +0000 Subject: Added support for xview and yview methods (scrollbar protocol) --- Python/library/Zinc.py | 2225 ++++++++++++++++++++++++------------------------ 1 file changed, 1125 insertions(+), 1100 deletions(-) diff --git a/Python/library/Zinc.py b/Python/library/Zinc.py index f9cb22d..f55aa56 100644 --- a/Python/library/Zinc.py +++ b/Python/library/Zinc.py @@ -35,1062 +35,1087 @@ ZINC_NO_PART = "" # current part dictionnary ZINC_DPART = { 'position' : ZINC_CURRENT_POSITION, - 'speedvector' : ZINC_SPEED_VECTOR , - 'leader' : ZINC_LEADER, - 'connection' : ZINC_CONNECTION} + 'speedvector' : ZINC_SPEED_VECTOR , + 'leader' : ZINC_LEADER, + 'connection' : ZINC_CONNECTION} # notes : 'field' will be return when currentpart is a field def havetkzinc( window ): - '''load Zinc dynamic sharable object library , test if everything is ok + '''load Zinc dynamic sharable object library , test if everything is ok if ok :return zinc version if nok : return 0 ''' - global _LIBLOADED - global _VERSION - if ( _LIBLOADED == 1 ) : - return _VERSION - try: - if os.environ.has_key( 'auto_path' ): - ldir = os.environ['auto_path'].split( ':' ) - ldir.reverse() - for adir in ldir : - window.tk.call( 'eval', - "set auto_path " - + "[linsert $auto_path 0 %s]" % ( adir ) ) - window.tk.call( 'eval', 'package require Tkzinc' ) - # Call a function from the package to autoload it - # and verify that all is OK. - sversion = window.tk.call( 'zinc' ) + " Zinc.py %s" % __version__ - except TclError: - traceback.print_exc() - return 0 - _LIBLOADED = 1 - _VERSION = sversion - return sversion + global _LIBLOADED + global _VERSION + if ( _LIBLOADED == 1 ) : + return _VERSION + try: + if os.environ.has_key( 'auto_path' ): + ldir = os.environ['auto_path'].split( ':' ) + ldir.reverse() + for adir in ldir : + window.tk.call( 'eval', + "set auto_path " + + "[linsert $auto_path 0 %s]" % ( adir ) ) + window.tk.call( 'eval', 'package require Tkzinc' ) + # Call a function from the package to autoload it + # and verify that all is OK. + sversion = window.tk.call( 'zinc' ) + " Zinc.py %s" % __version__ + except TclError: + traceback.print_exc() + return 0 + _LIBLOADED = 1 + _VERSION = sversion + return sversion class ZincException: - def __call__( self ): - raise self + def __call__( self ): + raise self - def __init__( self, message ): - self.message = message - - def __str__( self ): - return self.message + def __init__( self, message ): + self.message = message + + def __str__( self ): + return self.message class Zinc( Widget ): - def __str__( self ): - return( "Zinc instance" ) - def __init__( self, master = None, cnf = None, **kw ): - if kw.has_key( 'backward_compatibility' ): - self.currentpart = self.__oldcurrentpart - self.configure = self.__oldconfigure - self.scale = self.__oldscale - self.translate = self.__oldtranslate - del kw['backward_compatibility'] - #Pour éviter des effets de bord - #si on met comme valeur par défaut de cnf - #à {} - if cnf is None : - cnf = {} - if master : - self.version = havetkzinc( master ) - else: - master = Frame() - master.pack() - self.version = havetkzinc( master ) - Widget.__init__( self, master, 'zinc', cnf, kw ) - self.items = {} - #BootStrap Root - classe = eval( 'Group' ) - obj = None - kw['id'] = 1 - obj = new.instance( classe, kw ) - self.items[1] = obj - - def mainloop( self ): - """ - Run the events mainloop - """ - self.tk.mainloop() - - def add( self, itemType, *args, **kw ): - """ - listTypes = zinc.add() - id = zinc.add(type, group) - id = zinc.add(type, group, initargs, **options) - type=[arc|curve|rectangle|triangles|tabular|track|waypoint|group|icon|map|reticle|text|window] - """ - args = list( args ) - args = args+list( self._options( kw ) ) - try: - return self.tk.getint( - self.tk.call( self._w, 'add', itemType, *args ) ) - except TclError, excpt : - ZincException( "%s\nType %s\nArgs : %s"%( excpt, itemType, args ) )() - - def addtag( self, *args ): - """ - zinc.addtag(tag, searchSpec) - This command add the given tag to all items matching - the search specification. - If the tag is already present on some item, - nothing is done for that item. - The command has no effect if no item satisfy - the given criteria. The command returns an empty string. - """ - self.tk.call( self._w, 'addtag', *args ) - - def addtag_above( self, newtag, tagOrId ): - """ - zinc.addtag_above(tag, tagOrId) - """ - self.addtag( newtag, 'above', tagOrId ) - - def addtag_all( self, newtag ): - """ - A ne plus utiliser - Utiliser addtag_withtag - """ - self.addtag( newtag, 'all' ) - - def addtag_ancestors( self, newtag, tagOrId, *ltagOrId ): - """ - zinc.addtag_ancestors(tag, tagOrId, *listTagOrId) - """ - self.addtag( newtag, 'ancestors', tagOrId, *ltagOrId ) - - def addtag_atpriority( self, newtag, pri, tagOrId = 1 ): - """ - zinc.addtag_atpriority(tag, priority, tagOrId = 1) - """ - - self.addtag( newtag, 'atpriority', pri, tagOrId ) - - def addtag_below( self, newtag, tagOrId ): - """ - zinc.addtag_below(tag, tagOrId) - """ - self.addtag( newtag, 'below', tagOrId ) - - def addtag_closest( self, newtag, x, y, halo = None, startItem = 1, recursive = 0 ): - """ - zinc.addtag_closest(tag, x, y, halo = None, startItem = 1, recursive = 0) - """ - self.addtag( newtag, 'closest', x, y, halo, startItem, recursive ) - - def addtag_enclosed( self, newtag, x1, y1, x2, y2, inGroup = 1, recursive = 0 ): - """ - zinc.addtag_enclosed(tag, x1, y1, x2, y2, inGroup = 1, recursive = 0) - """ - self.addtag( newtag, 'enclosed', x1, y1, x2, y2, inGroup, recursive ) - - def addtag_overlapping( self, newtag, x1, y1, x2, y2, inGroup = 1, recursive = 0 ): - """ - zinc.addtag_overlapping(tag, x1, y1, x2, y2, inGroup = 1, recursive = 0) - """ - self.addtag( newtag, 'overlapping', x1, y1, x2, y2, inGroup, recursive ) - - def addtag_withtag( self, newtag, tagOrId ): - """ - zinc.addtag_withtag(tag, tagOrId) - """ - self.addtag( newtag, 'withtag', tagOrId ) - - def addtag_withtype( self, newtag, type, tagOrId = 1 ): - """ - zinc.addtag_withtype(tag, type, tagOrId = 1) - """ - self.addtag( newtag, 'withtype', type, tagOrId ) - - def anchorxy( self, *args ): - """ - (x, y) = zinc.anchorxy(tagOrId, anchor) - """ - return self.tk.call( self._w, 'anchorxy', *args ) - - def bbox( self, *args ): - """ - (xo, yo, xc, yc) = zinc.bbox(tagOrId, ?fieldIndex?) - """ - return self.tk.call( self._w, 'bbox', *args ) - - def becomes( self ): - """ - zinc.becomes() - """ - self.tk.call( self._w, 'becomes' ) - - def bind_tag( self, tagOrId, sequence = None, func = None, add = None ): - ''' - return a funcid which can be usefull for unbinding - listBindings = zinc.bind_tag(tagOrId) - listbindings = zinc.bind_tag(tagOrId, sequence) - zinc.bind_tag(tagOrId, sequence, '') - zinc.bind_tag(tagOrId, sequence, command) - ''' - return self._bind( ( self._w, 'bind', tagOrId ), - sequence, func, add ) - - def cget( self, option ): - """ - val = zinc.cget(option) - """ - return self.tk.call( self._w, 'cget', '-' + option ) - - def chggroup( self, *args ): - """ - zinc.chggroup(tagOrId, group, ?adjustTransform?) - """ - self.tk.call( self._w, 'chggroup', *args ) - - def clone( self, *args, **kw): - """ - id = zinc.clone(tagOrId, **attributs) - """ - args = list( args ) + list( self._options( kw ) ) - return self.tk.call( self._w, 'clone', *args) - - def __oldconfigure( self, **kw ): - return Widget.configure( self, **kw ) - - def configure( self, **kw ): - """ - listOptions = zinc.configurez() - listOptions = zinc.configurez(option) - zinc.configurez(**options) - """ - res = Widget.configure( self, **kw ) - dico = {} - if res: - for i, j in res.items(): - dico[i] = j[3:] - return dico - - def contour( self, *args ): - """ - contourNum = zinc.contour(tagOrId) - contourNum = zinc.contour(tagOrId, operatorAndFlag, coordListOrTagOrId) - """ - return self.tk.call( self._w, 'contour', *args ) - - def coords( self, *args ): - """ - zinc.coords(tagOrId, contourIndex) - zinc.coords(tagOrId, contourIndex, coordList) - zinc.coords(tagOrId, contourIndex, coordIndex) - zinc.coords(tagOrId, contourIndex, coordIndex, coordList) - zinc.coords(tagOrId, 'remove', contourIndex, coordIndex) - zinc.coords(tagOrId, 'add', contourIndex, coordList) - zinc.coords(tagOrId, 'add', contourIndex, coordIndex, coordList) - zinc.coords(tagOrId) - zinc.coords(tagOrId, coordList) - zinc.coords(tagOrId, 'remove', coordIndex) - zinc.coords(tagOrId, 'add', coordList) - """ - return self.tk.call( self._w, 'coords', *args ) - - def __buggyoldcurrentpart( self ): - ''' - return a string (result from zinc current part function) and an - integer representing either the number of the field either - the number of the item part either ZINC_NO_PART - ''' - scurrentp = self.tk.call( self._w, 'currentpart' ) - if scurrentp == "": - rvalue = ZINC_NO_PART - else: - try: - rvalue = locale.atoi( scurrentp ) - except: - try: - rvalue = ZINC_DPART[scurrentp] - except: - rvalue = ZINC_NO_PART - else: - # string to integer succeeded - scurrentp = "field" - return( scurrentp, rvalue ) - - def __oldcurrentpart( self ): - '''return a string and an integer ; + def __str__( self ): + return( "Zinc instance" ) + def __init__( self, master = None, cnf = None, **kw ): + if kw.has_key( 'backward_compatibility' ): + self.currentpart = self.__oldcurrentpart + self.configure = self.__oldconfigure + self.scale = self.__oldscale + self.translate = self.__oldtranslate + del kw['backward_compatibility'] + #Pour éviter des effets de bord + #si on met comme valeur par défaut de cnf + #à {} + if cnf is None : + cnf = {} + if master : + self.version = havetkzinc( master ) + else: + master = Frame() + master.pack() + self.version = havetkzinc( master ) + Widget.__init__( self, master, 'zinc', cnf, kw ) + self.items = {} + #BootStrap Root + classe = eval( 'Group' ) + obj = None + kw['id'] = 1 + obj = new.instance( classe, kw ) + self.items[1] = obj + + def mainloop( self ): + """ + Run the events mainloop + """ + self.tk.mainloop() + + def add( self, itemType, *args, **kw ): + """ + listTypes = zinc.add() + id = zinc.add(type, group) + id = zinc.add(type, group, initargs, **options) + type=[arc|curve|rectangle|triangles|tabular|track|waypoint|group|icon|map|reticle|text|window] + """ + args = list( args ) + args = args+list( self._options( kw ) ) + try: + return self.tk.getint( + self.tk.call( self._w, 'add', itemType, *args ) ) + except TclError, excpt : + ZincException( "%s\nType %s\nArgs : %s"%( excpt, itemType, args ) )() + + def addtag( self, *args ): + """ + zinc.addtag(tag, searchSpec) + This command add the given tag to all items matching + the search specification. + If the tag is already present on some item, + nothing is done for that item. + The command has no effect if no item satisfy + the given criteria. The command returns an empty string. + """ + self.tk.call( self._w, 'addtag', *args ) + + def addtag_above( self, newtag, tagOrId ): + """ + zinc.addtag_above(tag, tagOrId) + """ + self.addtag( newtag, 'above', tagOrId ) + + def addtag_all( self, newtag ): + """ + A ne plus utiliser + Utiliser addtag_withtag + """ + self.addtag( newtag, 'all' ) + + def addtag_ancestors( self, newtag, tagOrId, *ltagOrId ): + """ + zinc.addtag_ancestors(tag, tagOrId, *listTagOrId) + """ + self.addtag( newtag, 'ancestors', tagOrId, *ltagOrId ) + + def addtag_atpriority( self, newtag, pri, tagOrId = 1 ): + """ + zinc.addtag_atpriority(tag, priority, tagOrId = 1) + """ + + self.addtag( newtag, 'atpriority', pri, tagOrId ) + + def addtag_below( self, newtag, tagOrId ): + """ + zinc.addtag_below(tag, tagOrId) + """ + self.addtag( newtag, 'below', tagOrId ) + + def addtag_closest( self, newtag, x, y, halo = None, startItem = 1, recursive = 0 ): + """ + zinc.addtag_closest(tag, x, y, halo = None, startItem = 1, recursive = 0) + """ + self.addtag( newtag, 'closest', x, y, halo, startItem, recursive ) + + def addtag_enclosed( self, newtag, x1, y1, x2, y2, inGroup = 1, recursive = 0 ): + """ + zinc.addtag_enclosed(tag, x1, y1, x2, y2, inGroup = 1, recursive = 0) + """ + self.addtag( newtag, 'enclosed', x1, y1, x2, y2, inGroup, recursive ) + + def addtag_overlapping( self, newtag, x1, y1, x2, y2, inGroup = 1, recursive = 0 ): + """ + zinc.addtag_overlapping(tag, x1, y1, x2, y2, inGroup = 1, recursive = 0) + """ + self.addtag( newtag, 'overlapping', x1, y1, x2, y2, inGroup, recursive ) + + def addtag_withtag( self, newtag, tagOrId ): + """ + zinc.addtag_withtag(tag, tagOrId) + """ + self.addtag( newtag, 'withtag', tagOrId ) + + def addtag_withtype( self, newtag, type, tagOrId = 1 ): + """ + zinc.addtag_withtype(tag, type, tagOrId = 1) + """ + self.addtag( newtag, 'withtype', type, tagOrId ) + + def anchorxy( self, *args ): + """ + (x, y) = zinc.anchorxy(tagOrId, anchor) + """ + return self.tk.call( self._w, 'anchorxy', *args ) + + def bbox( self, *args ): + """ + (xo, yo, xc, yc) = zinc.bbox(tagOrId, ?fieldIndex?) + """ + return self.tk.call( self._w, 'bbox', *args ) + + def becomes( self ): + """ + zinc.becomes() + """ + self.tk.call( self._w, 'becomes' ) + + def bind_tag( self, tagOrId, sequence = None, func = None, add = None ): + ''' + return a funcid which can be usefull for unbinding + listBindings = zinc.bind_tag(tagOrId) + listbindings = zinc.bind_tag(tagOrId, sequence) + zinc.bind_tag(tagOrId, sequence, '') + zinc.bind_tag(tagOrId, sequence, command) + ''' + return self._bind( ( self._w, 'bind', tagOrId ), + sequence, func, add ) + + def cget( self, option ): + """ + val = zinc.cget(option) + """ + return self.tk.call( self._w, 'cget', '-' + option ) + + def chggroup( self, *args ): + """ + zinc.chggroup(tagOrId, group, ?adjustTransform?) + """ + self.tk.call( self._w, 'chggroup', *args ) + + def clone( self, *args, **kw): + """ + id = zinc.clone(tagOrId, **attributs) + """ + args = list( args ) + list( self._options( kw ) ) + return self.tk.call( self._w, 'clone', *args) + + def __oldconfigure( self, **kw ): + return Widget.configure( self, **kw ) + + def configure( self, **kw ): + """ + listOptions = zinc.configurez() + listOptions = zinc.configurez(option) + zinc.configurez(**options) + """ + res = Widget.configure( self, **kw ) + dico = {} + if res: + for i, j in res.items(): + dico[i] = j[3:] + return dico + + def contour( self, *args ): + """ + contourNum = zinc.contour(tagOrId) + contourNum = zinc.contour(tagOrId, operatorAndFlag, coordListOrTagOrId) + """ + return self.tk.call( self._w, 'contour', *args ) + + def coords( self, *args ): + """ + zinc.coords(tagOrId, contourIndex) + zinc.coords(tagOrId, contourIndex, coordList) + zinc.coords(tagOrId, contourIndex, coordIndex) + zinc.coords(tagOrId, contourIndex, coordIndex, coordList) + zinc.coords(tagOrId, 'remove', contourIndex, coordIndex) + zinc.coords(tagOrId, 'add', contourIndex, coordList) + zinc.coords(tagOrId, 'add', contourIndex, coordIndex, coordList) + zinc.coords(tagOrId) + zinc.coords(tagOrId, coordList) + zinc.coords(tagOrId, 'remove', coordIndex) + zinc.coords(tagOrId, 'add', coordList) + """ + return self.tk.call( self._w, 'coords', *args ) + + def __buggyoldcurrentpart( self ): + ''' + return a string (result from zinc current part function) and an + integer representing either the number of the field either + the number of the item part either ZINC_NO_PART + ''' + scurrentp = self.tk.call( self._w, 'currentpart' ) + if scurrentp == "": + rvalue = ZINC_NO_PART + else: + try: + rvalue = locale.atoi( scurrentp ) + except: + try: + rvalue = ZINC_DPART[scurrentp] + except: + rvalue = ZINC_NO_PART + else: + # string to integer succeeded + scurrentp = "field" + return( scurrentp, rvalue ) + + def __oldcurrentpart( self ): + '''return a string and an integer ; the string is among "field", "position", "speedvector", "leader", "connection", "", the number is the number of the part , or the field number in case of "field"; ex: no part return '', ZINC_NO_PART ''' - scurrentp = self.tk.call( self._w, 'currentpart' ) - print "Zinc::__oldcurrentpart scurrentp = [%s]" % scurrentp - # warning : read this first : - # return a string among 'position', 'speedvector', 'leader', 'connection' ,'' - # or an int representing the number of a field label - # - # print "Zinc::currentpart cp=%s ,type(cp)=%s" % (scurrentp,type(scurrentp)) - if scurrentp == "": - rvalue = ZINC_NO_PART - elif type( scurrentp ) == type( 1 ): - # meaning a field - # the subtil thing is here ! warning ! - rvalue = scurrentp - scurrentp = "field" - else: - # scurrentp is a string different from "" - try: - rvalue = ZINC_DPART[scurrentp] - except: - print "Zinc::currentpart unknown item part" - rvalue = ZINC_NO_PART - - return scurrentp, rvalue - - def currentpart( self ): - ''' - num = zinc.currentpart() - ''' - return str( self.tk.call( self._w, 'currentpart' ) ) - - - def cursor( self, *args ): - """ - zinc.cursor(tagOrId, index) - """ - self.tk.call( self._w, 'cursor', *args ) - - def dchars( self, *args ): - """ - zinc.dchars( tagOrId, first ) - zinc.dchars( tagOrId, first,last ) - """ - self.tk.call( self._w, 'dchars', *args ) - - def dtag( self, *args ): - """ - zinc.dtag(tagOrId) - zinc.dtag(tagOrId, tagToDelete) - """ - self.tk.call( self._w, 'dtag', *args ) - - def find( self, *args ): - return self._getints( - self.tk.call( self._w, 'find', *args ) ) or () - - def find_above( self, tagOrId ): - """ - listItems=zinc.find_above(tagOrId)} - """ - return self.find( 'above', tagOrId ) - - def find_all( self ): - return self.find( 'all' ) - - def find_ancestors( self, newtag, tagOrId, *tagOrId2 ): - """ - listItems=zinc.find_ancestor(tag, tagOrId, ?tagOrId2?) - """ - return self.find( newtag, 'ancestors', tagOrId, *tagOrId2 ) - - def find_atpriority( self, pri, *tagOrId ): - """ - listItems=zinc.find_atpriority(pri, ?tagOrId?) - """ - return self.find( 'atpriority', pri, *tagOrId ) - - def find_below( self, tagOrId ): - """ - listItems=zinc.find_below(tagOrId) - """ - return self.find( 'below', tagOrId ) - - def find_closest( self, x, y, *options ): - """ - listItems=zinc.find_closest(x, y, ?halo?, ?startItem?, ?recursive?) - """ - return self.find( 'closest', x, y, *options ) - - def find_enclosed( self, x1, y1, x2, y2 ): - """ - listItems=zinc.find_enclosed(x1, y1, x2, y2, inGroup=1, recursive=0) - """ - return self.find( 'enclosed', x1, y1, x2, y2 ) - - def find_overlapping( self, x1, y1, x2, y2, *options ): - """ - listItems=zinc.find_overlapping( x1, y1, x2, y2, ?inGroup?, ?recursive?) - """ - return self.find( 'overlapping', x1, y1, x2, y2, *options ) - - def find_withtag( self, tagOrId ): - """ - listItems=zinc.find_withtag( tagOrId) - """ - return self.find( 'withtag', tagOrId ) - - def find_withtype( self, type, *tagOrId ): - """ - listItems=zinc.find_withtype( type, ?tagOrId?) - """ - return self.find( 'withtype', type, *tagOrId ) - - - def fit( self, *args ): - """ - listControls=zinc.fit(coordList,error) - """ - return self.tk.call( self._w, 'fit', *args ) - - def focus( self, *args ): - """ - zinc.focus(tagOrId, ?itemPart?) - """ - self.tk.call( self._w, 'focus', *args ) - - def gdelete( self, *args ): - """ - zinc.gdelete(gradientName) - """ - self.tk.call( self._w, 'gdelete', *args ) - - def gettags( self, *args ): - """ - listTags=zinc.gettags(tagorid) - """ - return self.tk.splitlist( self.tk.call( self._w, 'gettags', *args ) ) - - def gname( self, *args ): - """ - zinc.gname(gradientDesc, gradientName) - bExist=zinc.gname(gradientName) - """ - return self.tk.call( self._w, 'gname', *args ) - - def group( self, *args ): - """ - group=zinc.group(tagOrId) - """ - return self.tk.call( self._w, 'group', *args ) - - def hasanchors( self, *args ): - """ - bool=zinc.hasanchors(tagOrId) - """ - return self.tk.call( self._w, 'hasanchors', *args ) - - def hasfields( self, *args ): - """ - bool=zinc.hasfields(tagOrId) - """ - return self.tk.call( self._w, 'hasfield', *args ) - - def hastag( self, *args ): - """ - bool=zinc.hastag(tagOrId, tag) - """ - return self.tk.call( self._w, 'hastag', *args ) - - def index( self, *args ): - """ - num = zinc.index(tagOrId, index) - """ - return self.tk.call( self._w, 'tagOrId', *args ) - - def insert( self, *args ): - """ - zinc.insert(tagOrId, before, string) - """ - self.tk.call( self._w, 'insert', *args ) - - def itemcget( self, tagOrId, option ): - """ - val=zinc.itemcget(tagOrId, attr) - """ - return self.tk.call( self._w, 'itemcget', tagOrId, '-'+option ) - - def itemfieldget( self, tagOrId, field, option ): - """ - val=zinc.itemcget(tagOrId, field, attr) - """ - return self.tk.call( self._w, 'itemcget', tagOrId, field, '-'+option ) - - def itemconfigure( self, tagOrId, field=None, **kw ): - ''' - either get the dictionnary of possible attributes (if kw is None) - either allow to set Items attributes or Field attributes - - listAttribs=zinc.itemconfigure(tagOrId) - listAttribs=zinc.itemconfigure(tagOrId, attrib) - zinc.itemconfigure(tagOrId, **attributs) - listAttribs=zinc.itemconfigure(tagOrId, fieldIs, attrib) - zinc.itemconfigure(TagOrId,fieldId,**attributs) - ''' - if not kw: - cnf = {} - for var_x in self.tk.split( - field != None and self.tk.call( self._w, 'itemconfigure', - ( tagOrId, field ) ) or - self.tk.call( self._w, 'itemconfigure', ( tagOrId, ) ) ): - cnf[var_x[0][1:]] = ( var_x[0][1:], ) + var_x[1:] - return cnf - if field != None: - args = ( tagOrId, str( field ), )+ self._options( {}, kw ) - self.tk.call( self._w, 'itemconfigure', *args ) - else: - args = ( tagOrId, ) + self._options( {}, kw ) - self.tk.call( self._w, 'itemconfigure', *args ) - - # _dp voir si cette instruction est a execute ici - # permet de creer un synonyme de itemconfigure - itemconfig = itemconfigure - - def loweritem( self, *args ): - """ - zinc.loweritem(tagOrId) - zinc.loweritem(tagOrId, belowThis) - Reorder all the items given by tagOrId so that - they will be under the item given by belowThis. - If tagOrId name more than one item, - their relative order will be preserved. - If tagOrId doesn't name an item, an error is raised. - If belowThis name more than one item, the bottom most them is used. - If belowThis doesn't name an item, an error is raised. - If belowThis is omitted the items are put - at the bottom most position of their respective groups. - The command ignore all items named by tagOrId - that are not in the same group than belowThis or, - if not specified, in the same group than the first item - named by tagOrId. The command returns an empty string. - As a side affect of this command, the -priority attribute - of all the reordered items is ajusted to match the priority - of the belowThis item (or the priority of the bottom most item) - """ - self.tk.call( self._w, 'lower', *args ) - - def monitor( self, *args ): - """ - bool = zinc.monitor() - zinc.monitor(bool) - """ - return self.tk.call( self._w, 'monitor', *args ) - - def numparts( self, *args ): - """ - num = zinc.numparts(tagOrId) - """ - return self.tk.call( self._w, 'numparts', *args ) - - def postcript( self, *args ): - """ - Not Yet Implemented - zinc.postscript() - """ - return self.tk.call( self._w, 'postscript', *args ) - - def raiseitem( self, *args ): - """ - Correspond à l'appel raise de la documentation - le mot raise est reservé en python - zinc.raiseitem(tagOrId) - zinc.raiseitem(tagOrId, aboveThis) - """ - self.tk.call( self._w, 'raise', *args ) - - def remove( self, *args ): - """ - zinc.remove(tagOrId, ?tagOrId,...?) - """ - self.tk.call( self._w, 'remove', *args ) - - def rotate( self, *args ): - """ - zinc.rotate(tagOrId, angle) - zinc.rotate(tagOrId, angle, centerX, centerY) - """ - self.tk.call( self._w, 'rotate', *args ) - - def __oldscale( self, xFactor=None, yFactor=None, tagOrId=None ): - if yFactor == None: - return self.tk.getdouble( self.tk.call( 'scale' ) ) - else: - if tagOrId == None: - self.tk.call( self._w, 'scale', xFactor, yFactor ) - else: - self.tk.call( self._w, 'scale', tagOrId, xFactor, yFactor ) - - def scale( self, *args ): - """ - zinc.scale(tagOrIdOrTName, xFactor, yFactor) - zinc.scale(tagOrIdOrTName, xFactor, yFactor, centerX, centerY) - Add a scale factor to the items or the transform described - by tagOrId. - If tagOrId describes a named transform then this transform - is used to do the operation. If tagOrId describes more than - one item then all the items are affected by the operation. - If tagOrId describes neither a named transform nor an item, - an error is raised. - A separate factor is specified for X and Y. - The optional parameters describe the center of scaling, - which defaults to the origin. - """ - if not len( args ): - return self.tk.getdouble( self.tk.call( self._w, 'scale' ) ) - else: - self.tk.call( self._w, 'scale', *args ) - - def select( self, *args ): - """ - zinc.select('adjust', tagOrId, index) - Adjust the end of the selection in tagOrId - that is nearest to the character given by index so - that it is at index. - The other end of the selection is made the anchor - for future select to commands. - If the selection is not currently in tagOrId, - this command behaves as the select to command. - The command returns an empty string. - zinc.select('clear') - Clear the selection if it is in the widget. - If the selection is not in the widget, - the command has no effect. Return an empty string. - zinc.select('from', tagOrId, index) - Set the selection anchor point for the widget - to be just before the character given by index - in the item described by tagOrId. - The command has no effect on the selection, - it sets one end of the selection so that future - select to can actually set the selection. - The command returns an empty string. - (item,part) = zinc.select('item') - Returns a list of two elements. - The first is the id of the selected item - if the selection is in an item on this widget; - Otherwise the first element is an empty string. - The second element is the part of the item - (track, waypoint or tabular item only) or the empty string. - zinc.select('to', tagOrId, index) - Set the selection to be the characters that lies - between the selection anchor and index in the item described - by tagOrId. The selection includes the character given - by index and includes the character given by the anchor point - if index is greater or equal to the anchor point. - The anchor point is set by the most recent select adjust - or select from command issued for this widget. - If the selection anchor point for the widget is not currently - in tagOrId, it is set to the character given by index. - The command returns an empty string. - Manipulates the selection as requested by option. - tagOrId describes the target item. - This item must support text indexing and selection. I - f more than one item is referred to by tagOrId, - the first in display list order that support both text - indexing and selection will be used. - Some forms of the command include an index parameter, - this parameter describes a textual position within the - item and should be a valid index as described in - Text indices. - """ - return self.tk.call( self._w, 'select', *args ) - - def skew( self, *args ): - """ - zinc.skew(tagOrIdOrTName,xSkewAngle, ySkewAngle) - Add a skew (or shear) transform to the to the items - or the transform described by tagOrIdOrTName. - If tagOrId describes a named transform then this transform - is used to do the operation. - If tagOrId describes more than one item then all the - items are affected by the operation. - If tagOrId describes neither a named transform nor an item, - an error is raised. The angles are given in radian. - """ - return self.tk.call( self._w, 'skew', *args ) - - def smooth( self, *args ): - """ - zinc.smooth(coordList) - This command computes a sequence of segments - that will smooth the polygon described by the vertices - in coordList and returns a list of lists describing points - of the generated segments. These segments are approximating - a Bezier curve. coordList should be either a flat list - of an even number of coordinates in x, y order, or a list - of lists of point coordinates X, Y. - The returned list can be used to create or change the contour - of a curve item. - """ - return self.tk.call( self._w, 'smooth', *args ) - - def tapply( self, *args ): - """ - Not Yet Implemented - zinc.tapply() - """ - return self.tk.call( self._w, 'tapply', *args ) - - def tcompose( self, *args ): - """ - zinc.tcompose(tagOrIdOrTName, tName) - zinc.tcompose(tagOrIdOrTName, tName, invert) - """ - return self.tk.call( self._w, 'tapply', *args ) - - def tdelete( self, *args ): - """ - zinc.tdelete(tName) - Destroy a named transform. - If the given name is not found among the named transforms, - an error is raised. - """ - self.tk.call( self._w, 'tdelete', *args ) - - def transform( self, *args ): - """ - listCoords=zinc.transform(tagOrIdTo, coordList) - listCoords=zinc.transform(tagOrIdFrom, tagOrIdTo, coordList) - This command returns a list of coordinates obtained by transforming the coordinates given in coordList - from the coordinate space of the transform or item described by tagOrIdFrom to the coordinate space - of the transform or item described by tagOrIdTo. - If tagOrIdFrom is omitted it defaults to the window coordinate space. - If either tagOrIdFrom or tagOrIdTo describes more than one item, - the topmost in display list order is used. If either tagOrIdFrom or tagOrIdTo - doesn't describe either a transform or an item, an error is raised. - The coordList should either be a flat list containing an even number of coordinates - each point having two coordinates, or a list of lists each sublist of the form [ X Y ?pointtype? ]. - The returned coordinates list will be isomorphic to the list given as argument. - - It is possible to convert from window coordinate space to the coordinate space of any item. - This is done by omitting ?tagOrIdFrom? and specifying in tagOrIdTo, the id of the item. - It can also be done by using the predefined tag 'device' as first argument. - - It is also possible to convert from the coordinate space of an item to the window coordinate - space by using the predefined tag 'device' as second argument. - - """ - return self._getdoubles( self.tk.call( self._w, 'transform', *args ) ) + scurrentp = self.tk.call( self._w, 'currentpart' ) + print "Zinc::__oldcurrentpart scurrentp = [%s]" % scurrentp + # warning : read this first : + # return a string among 'position', 'speedvector', 'leader', 'connection' ,'' + # or an int representing the number of a field label + # + # print "Zinc::currentpart cp=%s ,type(cp)=%s" % (scurrentp,type(scurrentp)) + if scurrentp == "": + rvalue = ZINC_NO_PART + elif type( scurrentp ) == type( 1 ): + # meaning a field + # the subtil thing is here ! warning ! + rvalue = scurrentp + scurrentp = "field" + else: + # scurrentp is a string different from "" + try: + rvalue = ZINC_DPART[scurrentp] + except: + print "Zinc::currentpart unknown item part" + rvalue = ZINC_NO_PART + + return scurrentp, rvalue + + def currentpart( self ): + ''' + num = zinc.currentpart() + ''' + return str( self.tk.call( self._w, 'currentpart' ) ) + + + def cursor( self, *args ): + """ + zinc.cursor(tagOrId, index) + """ + self.tk.call( self._w, 'cursor', *args ) + + def dchars( self, *args ): + """ + zinc.dchars( tagOrId, first ) + zinc.dchars( tagOrId, first,last ) + """ + self.tk.call( self._w, 'dchars', *args ) + + def dtag( self, *args ): + """ + zinc.dtag(tagOrId) + zinc.dtag(tagOrId, tagToDelete) + """ + self.tk.call( self._w, 'dtag', *args ) + + def find( self, *args ): + return self._getints( + self.tk.call( self._w, 'find', *args ) ) or () + + def find_above( self, tagOrId ): + """ + listItems=zinc.find_above(tagOrId)} + """ + return self.find( 'above', tagOrId ) + + def find_all( self ): + return self.find( 'all' ) + + def find_ancestors( self, newtag, tagOrId, *tagOrId2 ): + """ + listItems=zinc.find_ancestor(tag, tagOrId, ?tagOrId2?) + """ + return self.find( newtag, 'ancestors', tagOrId, *tagOrId2 ) + + def find_atpriority( self, pri, *tagOrId ): + """ + listItems=zinc.find_atpriority(pri, ?tagOrId?) + """ + return self.find( 'atpriority', pri, *tagOrId ) + + def find_below( self, tagOrId ): + """ + listItems=zinc.find_below(tagOrId) + """ + return self.find( 'below', tagOrId ) + + def find_closest( self, x, y, *options ): + """ + listItems=zinc.find_closest(x, y, ?halo?, ?startItem?, ?recursive?) + """ + return self.find( 'closest', x, y, *options ) + + def find_enclosed( self, x1, y1, x2, y2 ): + """ + listItems=zinc.find_enclosed(x1, y1, x2, y2, inGroup=1, recursive=0) + """ + return self.find( 'enclosed', x1, y1, x2, y2 ) + + def find_overlapping( self, x1, y1, x2, y2, *options ): + """ + listItems=zinc.find_overlapping( x1, y1, x2, y2, ?inGroup?, ?recursive?) + """ + return self.find( 'overlapping', x1, y1, x2, y2, *options ) + + def find_withtag( self, tagOrId ): + """ + listItems=zinc.find_withtag( tagOrId) + """ + return self.find( 'withtag', tagOrId ) + + def find_withtype( self, type, *tagOrId ): + """ + listItems=zinc.find_withtype( type, ?tagOrId?) + """ + return self.find( 'withtype', type, *tagOrId ) + + + def fit( self, *args ): + """ + listControls=zinc.fit(coordList,error) + """ + return self.tk.call( self._w, 'fit', *args ) + + def focus( self, *args ): + """ + zinc.focus(tagOrId, ?itemPart?) + """ + self.tk.call( self._w, 'focus', *args ) + + def gdelete( self, *args ): + """ + zinc.gdelete(gradientName) + """ + self.tk.call( self._w, 'gdelete', *args ) + + def gettags( self, *args ): + """ + listTags=zinc.gettags(tagorid) + """ + return self.tk.splitlist( self.tk.call( self._w, 'gettags', *args ) ) + + def gname( self, *args ): + """ + zinc.gname(gradientDesc, gradientName) + bExist=zinc.gname(gradientName) + """ + return self.tk.call( self._w, 'gname', *args ) + + def group( self, *args ): + """ + group=zinc.group(tagOrId) + """ + return self.tk.call( self._w, 'group', *args ) + + def hasanchors( self, *args ): + """ + bool=zinc.hasanchors(tagOrId) + """ + return self.tk.call( self._w, 'hasanchors', *args ) + + def hasfields( self, *args ): + """ + bool=zinc.hasfields(tagOrId) + """ + return self.tk.call( self._w, 'hasfield', *args ) + + def hastag( self, *args ): + """ + bool=zinc.hastag(tagOrId, tag) + """ + return self.tk.call( self._w, 'hastag', *args ) + + def index( self, *args ): + """ + num = zinc.index(tagOrId, index) + """ + return self.tk.call( self._w, 'tagOrId', *args ) + + def insert( self, *args ): + """ + zinc.insert(tagOrId, before, string) + """ + self.tk.call( self._w, 'insert', *args ) + + def itemcget( self, tagOrId, option ): + """ + val=zinc.itemcget(tagOrId, attr) + """ + return self.tk.call( self._w, 'itemcget', tagOrId, '-'+option ) + + def itemfieldget( self, tagOrId, field, option ): + """ + val=zinc.itemcget(tagOrId, field, attr) + """ + return self.tk.call( self._w, 'itemcget', tagOrId, field, '-'+option ) + + def itemconfigure( self, tagOrId, field=None, **kw ): + ''' + either get the dictionnary of possible attributes (if kw is None) + either allow to set Items attributes or Field attributes + + listAttribs=zinc.itemconfigure(tagOrId) + listAttribs=zinc.itemconfigure(tagOrId, attrib) + zinc.itemconfigure(tagOrId, **attributs) + listAttribs=zinc.itemconfigure(tagOrId, fieldIs, attrib) + zinc.itemconfigure(TagOrId,fieldId,**attributs) + ''' + if not kw: + cnf = {} + for var_x in self.tk.split( + field != None and self.tk.call( self._w, 'itemconfigure', + ( tagOrId, field ) ) or + self.tk.call( self._w, 'itemconfigure', ( tagOrId, ) ) ): + cnf[var_x[0][1:]] = ( var_x[0][1:], ) + var_x[1:] + return cnf + if field != None: + args = ( tagOrId, str( field ), )+ self._options( {}, kw ) + self.tk.call( self._w, 'itemconfigure', *args ) + else: + args = ( tagOrId, ) + self._options( {}, kw ) + self.tk.call( self._w, 'itemconfigure', *args ) + + # _dp voir si cette instruction est a execute ici + # permet de creer un synonyme de itemconfigure + itemconfig = itemconfigure + + def loweritem( self, *args ): + """ + zinc.loweritem(tagOrId) + zinc.loweritem(tagOrId, belowThis) + Reorder all the items given by tagOrId so that + they will be under the item given by belowThis. + If tagOrId name more than one item, + their relative order will be preserved. + If tagOrId doesn't name an item, an error is raised. + If belowThis name more than one item, the bottom most them is used. + If belowThis doesn't name an item, an error is raised. + If belowThis is omitted the items are put + at the bottom most position of their respective groups. + The command ignore all items named by tagOrId + that are not in the same group than belowThis or, + if not specified, in the same group than the first item + named by tagOrId. The command returns an empty string. + As a side affect of this command, the -priority attribute + of all the reordered items is ajusted to match the priority + of the belowThis item (or the priority of the bottom most item) + """ + self.tk.call( self._w, 'lower', *args ) + + def monitor( self, *args ): + """ + bool = zinc.monitor() + zinc.monitor(bool) + """ + return self.tk.call( self._w, 'monitor', *args ) + + def numparts( self, *args ): + """ + num = zinc.numparts(tagOrId) + """ + return self.tk.call( self._w, 'numparts', *args ) + + def postcript( self, *args ): + """ + Not Yet Implemented + zinc.postscript() + """ + return self.tk.call( self._w, 'postscript', *args ) + + def raiseitem( self, *args ): + """ + Correspond à l'appel raise de la documentation + le mot raise est reservé en python + zinc.raiseitem(tagOrId) + zinc.raiseitem(tagOrId, aboveThis) + """ + self.tk.call( self._w, 'raise', *args ) + + def remove( self, *args ): + """ + zinc.remove(tagOrId, ?tagOrId,...?) + """ + self.tk.call( self._w, 'remove', *args ) + + def rotate( self, *args ): + """ + zinc.rotate(tagOrId, angle) + zinc.rotate(tagOrId, angle, centerX, centerY) + """ + self.tk.call( self._w, 'rotate', *args ) + + def __oldscale( self, xFactor=None, yFactor=None, tagOrId=None ): + if yFactor == None: + return self.tk.getdouble( self.tk.call( 'scale' ) ) + else: + if tagOrId == None: + self.tk.call( self._w, 'scale', xFactor, yFactor ) + else: + self.tk.call( self._w, 'scale', tagOrId, xFactor, yFactor ) + + def scale( self, *args ): + """ + zinc.scale(tagOrIdOrTName, xFactor, yFactor) + zinc.scale(tagOrIdOrTName, xFactor, yFactor, centerX, centerY) + Add a scale factor to the items or the transform described + by tagOrId. + If tagOrId describes a named transform then this transform + is used to do the operation. If tagOrId describes more than + one item then all the items are affected by the operation. + If tagOrId describes neither a named transform nor an item, + an error is raised. + A separate factor is specified for X and Y. + The optional parameters describe the center of scaling, + which defaults to the origin. + """ + if not len( args ): + return self.tk.getdouble( self.tk.call( self._w, 'scale' ) ) + else: + self.tk.call( self._w, 'scale', *args ) + + def select( self, *args ): + """ + zinc.select('adjust', tagOrId, index) + Adjust the end of the selection in tagOrId + that is nearest to the character given by index so + that it is at index. + The other end of the selection is made the anchor + for future select to commands. + If the selection is not currently in tagOrId, + this command behaves as the select to command. + The command returns an empty string. + zinc.select('clear') + Clear the selection if it is in the widget. + If the selection is not in the widget, + the command has no effect. Return an empty string. + zinc.select('from', tagOrId, index) + Set the selection anchor point for the widget + to be just before the character given by index + in the item described by tagOrId. + The command has no effect on the selection, + it sets one end of the selection so that future + select to can actually set the selection. + The command returns an empty string. + (item,part) = zinc.select('item') + Returns a list of two elements. + The first is the id of the selected item + if the selection is in an item on this widget; + Otherwise the first element is an empty string. + The second element is the part of the item + (track, waypoint or tabular item only) or the empty string. + zinc.select('to', tagOrId, index) + Set the selection to be the characters that lies + between the selection anchor and index in the item described + by tagOrId. The selection includes the character given + by index and includes the character given by the anchor point + if index is greater or equal to the anchor point. + The anchor point is set by the most recent select adjust + or select from command issued for this widget. + If the selection anchor point for the widget is not currently + in tagOrId, it is set to the character given by index. + The command returns an empty string. + Manipulates the selection as requested by option. + tagOrId describes the target item. + This item must support text indexing and selection. I + f more than one item is referred to by tagOrId, + the first in display list order that support both text + indexing and selection will be used. + Some forms of the command include an index parameter, + this parameter describes a textual position within the + item and should be a valid index as described in + Text indices. + """ + return self.tk.call( self._w, 'select', *args ) + + def skew( self, *args ): + """ + zinc.skew(tagOrIdOrTName,xSkewAngle, ySkewAngle) + Add a skew (or shear) transform to the to the items + or the transform described by tagOrIdOrTName. + If tagOrId describes a named transform then this transform + is used to do the operation. + If tagOrId describes more than one item then all the + items are affected by the operation. + If tagOrId describes neither a named transform nor an item, + an error is raised. The angles are given in radian. + """ + return self.tk.call( self._w, 'skew', *args ) + + def smooth( self, *args ): + """ + zinc.smooth(coordList) + This command computes a sequence of segments + that will smooth the polygon described by the vertices + in coordList and returns a list of lists describing points + of the generated segments. These segments are approximating + a Bezier curve. coordList should be either a flat list + of an even number of coordinates in x, y order, or a list + of lists of point coordinates X, Y. + The returned list can be used to create or change the contour + of a curve item. + """ + return self.tk.call( self._w, 'smooth', *args ) + + def tapply( self, *args ): + """ + Not Yet Implemented + zinc.tapply() + """ + return self.tk.call( self._w, 'tapply', *args ) + + def tcompose( self, *args ): + """ + zinc.tcompose(tagOrIdOrTName, tName) + zinc.tcompose(tagOrIdOrTName, tName, invert) + """ + return self.tk.call( self._w, 'tapply', *args ) + + def tdelete( self, *args ): + """ + zinc.tdelete(tName) + Destroy a named transform. + If the given name is not found among the named transforms, + an error is raised. + """ + self.tk.call( self._w, 'tdelete', *args ) + + def transform( self, *args ): + """ + listCoords=zinc.transform(tagOrIdTo, coordList) + listCoords=zinc.transform(tagOrIdFrom, tagOrIdTo, coordList) + This command returns a list of coordinates obtained by transforming the coordinates given in coordList + from the coordinate space of the transform or item described by tagOrIdFrom to the coordinate space + of the transform or item described by tagOrIdTo. + If tagOrIdFrom is omitted it defaults to the window coordinate space. + If either tagOrIdFrom or tagOrIdTo describes more than one item, + the topmost in display list order is used. If either tagOrIdFrom or tagOrIdTo + doesn't describe either a transform or an item, an error is raised. + The coordList should either be a flat list containing an even number of coordinates + each point having two coordinates, or a list of lists each sublist of the form [ X Y ?pointtype? ]. + The returned coordinates list will be isomorphic to the list given as argument. + + It is possible to convert from window coordinate space to the coordinate space of any item. + This is done by omitting ?tagOrIdFrom? and specifying in tagOrIdTo, the id of the item. + It can also be done by using the predefined tag 'device' as first argument. + + It is also possible to convert from the coordinate space of an item to the window coordinate + space by using the predefined tag 'device' as second argument. + + """ + return self._getdoubles( self.tk.call( self._w, 'transform', *args ) ) #ANCIENNE IMPLEMENTATION - def __oldtranslate( self, dx=None, dy=None, tagOrId=None ): - if dx == None: - return self._getints( self.tk.call( 'translate' ) ) - else: - if tagOrId == None: - self.tk.call( self._w, 'translate', dx, dy ) - else: - self.tk.call( self._w, 'translate', tagOrId, dx, dy ) - - def translate( self, *args ): - """ - zinc.translate(tagOrIdOrTName, xAmount, yAmount) - zinc.translate(tagOrIdOrTName, xAmount, yAmount, absolute) - Add a translation to the items or the transform described by tagOrIdOrTName. - If tagOrIdOrTName describes a named transform then this transform is used - to do the operation. - If tagOrIdOrTName describes more than one item then all the items are affected - by the opration. - If tagOrIdOrTName describes neither a named transform nor an item, - an error is raised. A separate value is specified for X and Y. - If the optionnal ?absolute? parameter is true, - it will set an absolute translation to the tagOrIdOrTName - """ - if ( len( args ) == 1 ): - return self._getints( self.tk.call( self._w, 'translate' ) ) - else: - self.tk.call( self._w, 'translate', *args ) - - def treset( self, *args ): - """ - zinc.treset(tagOrIdOrTName) - Set the named transform or the transform for the items described by tagOrIdOrTName - to identity. If tagOrIdOrTName describes neither a named transform nor an item, - an error is raised. - """ - self.tk.call( self._w, 'treset', *args ) - - def trestore( self, *args ): - """ - zinc.trestore(tagOrId, tName) - Set the transform for the items described by tagOrId to the transform named by tName. - If tagOrId doesn't describe any item or if the transform named tName doesn't exist, - an error is raised. - """ - self.tk.call( self._w, 'trestore', *args ) - - def tsave( self, *args ): - """ - zinc.tsave(tName) - zinc.tsave(tagOrIdOrTName, tName) - zinc.tsave(tagOrIdOrTName, tName, invert) - Create (or reset) a transform associated with the name tName - with initial value the transform associated with the item tagOrIdOrTName. - If tagOrIdOrTName describes more than one item, the topmost in display list order is used. - If tagOrIdOrTName doesn't describe any item or named transformation, an error is raised. - If tName already exists, the transform is set to the new value. - This command is the only way to create a named transform. - If tagOrIdOrTName is not specified, the command returns a boolean telling - if the name is already in use. - The invert boolean, if specified, cause the transform to be inverted prior to be saved. - - It is possible to create a new named transformation from the identity - by using the predefined tag 'identity': $zinc->tsave('identity', 'myTransfo'); - """ - return self.tk.call( self._w, 'tsave', *args ) - - def tget( self, *args ): - """ - zinc.tget(tagOrId) - zinc.tget(tagOrIdOrTName, selector) - selector:={'all'|'translation'|'scale'|'rotation'|'skew'} - With only one argument, get the six elements of the 3x4 matrix - used in affine transformation for tagOrIdOrTName. - The result is compatible with the tset method. - With optional second parameter 'all' returns the transform - decomposed in translation, scale, rotation, skew - and return the list in this order, - With 'translation', 'scale', 'rotation', 'skew' optional - second parameter, returns the corresponding values. - """ - return self.tk.call( self._w, 'tget', *args ) - - def tset( self, *args ): - """ - zinc.tset(tagOrIdOrName, m00, m01, m10, m11, m20, m21) - Set the six elements of the 3x4 matrix used in affine transformation for tagOrIdOrTName. - BEWARE that depending on mij values, - it is possible to define a not inversible matrix which will end up in core dump. - This method must BE USED CAUTIOUSLY. - """ - return self.tk.call( self._w, 'tset', *args ) - - def type( self, tagOrId ): - """ - name=zinc.type(tagOrId) - If more than one item is named by tagOrId, - then the type of the topmost item in display list order is returned. - If no items are named by tagOrId, an error is raised. - """ - return self.tk.call( self._w, 'type', tagOrId ) - - def vertexat( self, *args ): - """ - (contour,vertex,edgevertex)=zinc.vertexat(tagOrId,x,y) - """ - return self.tk.call( self._w, 'vertexat', *args ) + def __oldtranslate( self, dx=None, dy=None, tagOrId=None ): + if dx == None: + return self._getints( self.tk.call( 'translate' ) ) + else: + if tagOrId == None: + self.tk.call( self._w, 'translate', dx, dy ) + else: + self.tk.call( self._w, 'translate', tagOrId, dx, dy ) + + def translate( self, *args ): + """ + zinc.translate(tagOrIdOrTName, xAmount, yAmount) + zinc.translate(tagOrIdOrTName, xAmount, yAmount, absolute) + Add a translation to the items or the transform described by tagOrIdOrTName. + If tagOrIdOrTName describes a named transform then this transform is used + to do the operation. + If tagOrIdOrTName describes more than one item then all the items are affected + by the opration. + If tagOrIdOrTName describes neither a named transform nor an item, + an error is raised. A separate value is specified for X and Y. + If the optionnal ?absolute? parameter is true, + it will set an absolute translation to the tagOrIdOrTName + """ + if ( len( args ) == 1 ): + return self._getints( self.tk.call( self._w, 'translate' ) ) + else: + self.tk.call( self._w, 'translate', *args ) + + def treset( self, *args ): + """ + zinc.treset(tagOrIdOrTName) + Set the named transform or the transform for the items described by tagOrIdOrTName + to identity. If tagOrIdOrTName describes neither a named transform nor an item, + an error is raised. + """ + self.tk.call( self._w, 'treset', *args ) + + def trestore( self, *args ): + """ + zinc.trestore(tagOrId, tName) + Set the transform for the items described by tagOrId to the transform named by tName. + If tagOrId doesn't describe any item or if the transform named tName doesn't exist, + an error is raised. + """ + self.tk.call( self._w, 'trestore', *args ) + + def tsave( self, *args ): + """ + zinc.tsave(tName) + zinc.tsave(tagOrIdOrTName, tName) + zinc.tsave(tagOrIdOrTName, tName, invert) + Create (or reset) a transform associated with the name tName + with initial value the transform associated with the item tagOrIdOrTName. + If tagOrIdOrTName describes more than one item, the topmost in display list order is used. + If tagOrIdOrTName doesn't describe any item or named transformation, an error is raised. + If tName already exists, the transform is set to the new value. + This command is the only way to create a named transform. + If tagOrIdOrTName is not specified, the command returns a boolean telling + if the name is already in use. + The invert boolean, if specified, cause the transform to be inverted prior to be saved. + + It is possible to create a new named transformation from the identity + by using the predefined tag 'identity': $zinc->tsave('identity', 'myTransfo'); + """ + return self.tk.call( self._w, 'tsave', *args ) + + def tget( self, *args ): + """ + zinc.tget(tagOrId) + zinc.tget(tagOrIdOrTName, selector) + selector:={'all'|'translation'|'scale'|'rotation'|'skew'} + With only one argument, get the six elements of the 3x4 matrix + used in affine transformation for tagOrIdOrTName. + The result is compatible with the tset method. + With optional second parameter 'all' returns the transform + decomposed in translation, scale, rotation, skew + and return the list in this order, + With 'translation', 'scale', 'rotation', 'skew' optional + second parameter, returns the corresponding values. + """ + return self.tk.call( self._w, 'tget', *args ) + + def tset( self, *args ): + """ + zinc.tset(tagOrIdOrName, m00, m01, m10, m11, m20, m21) + Set the six elements of the 3x4 matrix used in affine transformation for tagOrIdOrTName. + BEWARE that depending on mij values, + it is possible to define a not inversible matrix which will end up in core dump. + This method must BE USED CAUTIOUSLY. + """ + return self.tk.call( self._w, 'tset', *args ) + + def type( self, tagOrId ): + """ + name=zinc.type(tagOrId) + If more than one item is named by tagOrId, + then the type of the topmost item in display list order is returned. + If no items are named by tagOrId, an error is raised. + """ + return self.tk.call( self._w, 'type', tagOrId ) + + def vertexat( self, *args ): + """ + (contour,vertex,edgevertex)=zinc.vertexat(tagOrId,x,y) + """ + return self.tk.call( self._w, 'vertexat', *args ) + + def xview(self, *args): + """Query and change horizontal position of the view.""" + if not args: + return self._getdoubles(self.tk.call(self._w, 'xview')) + self.tk.call((self._w, 'xview') + args) + def xview_moveto(self, fraction): + """Adjusts the view in the window so that FRACTION of the + total width of the canvas is off-screen to the left.""" + self.tk.call(self._w, 'xview', 'moveto', fraction) + def xview_scroll(self, number, what): + """Shift the x-view according to NUMBER which is measured in "units" or "pages" (WHAT).""" + self.tk.call(self._w, 'xview', 'scroll', number, what) + def yview(self, *args): + """Query and change vertical position of the view.""" + if not args: + return self._getdoubles(self.tk.call(self._w, 'yview')) + self.tk.call((self._w, 'yview') + args) + def yview_moveto(self, fraction): + """Adjusts the view in the window so that FRACTION of the + total height of the canvas is off-screen to the top.""" + self.tk.call(self._w, 'yview', 'moveto', fraction) + def yview_scroll(self, number, what): + """Shift the y-view according to NUMBER which is measured in "units" or "pages" (WHAT).""" + self.tk.call(self._w, 'yview', 'scroll', number, what) class ZincItem: - def __init__( self, zinc, itemType, group = 1, *args, **kw ): - self.zinc = zinc - texture = None - fillpatern = None - scale = None - translate = None - if kw.has_key( 'texture' ): - texture = kw['texture'] - del kw['texture'] - - if kw.has_key( 'fillpatern' ): - fillpastern = kw['fillpatern'] - del kw['fillpatern'] - - if kw.has_key( 'scale' ): - scale = kw['scale'] - del kw['scale'] - - if kw.has_key( 'rotate' ): - rotate = kw['rotate'] - del kw['rotate'] - - if kw.has_key( 'translate' ): - translate = kw['translate'] - del kw['translate'] - - if kw.has_key( 'cloneid' ): - cloneid = kw['cloneid'] - del kw['cloneid'] - else: - cloneid = 0 - group = str( group ) - # sys.stdout.flush() - if cloneid == 0 : - self.id = zinc.add( itemType, group, *args, **kw ) - else : - self.id = self.zinc.clone(cloneid, *args, **kw) - - zinc.items[self.id] = self - texture = None - if fillpatern: - self.itemconfigure( fillpatern ) - if scale: - self.scale( scale ) - if translate: - self.translate( translate ) - - - def __str__( self ): - return str( self.id ) - - def __repr__( self ): - return str( self.id ) - - def bbox( self, *args ): - return self.zinc.bbox( self.id, *args ) - - def clone( self, *args, **kw): - '''id = zincitem.clone(*args,**kw) ''' - # print "ZincItem::clone" + def __init__( self, zinc, itemType, group = 1, *args, **kw ): + self.zinc = zinc + texture = None + fillpatern = None + scale = None + translate = None + if kw.has_key( 'texture' ): + texture = kw['texture'] + del kw['texture'] + + if kw.has_key( 'fillpatern' ): + fillpastern = kw['fillpatern'] + del kw['fillpatern'] + + if kw.has_key( 'scale' ): + scale = kw['scale'] + del kw['scale'] + + if kw.has_key( 'rotate' ): + rotate = kw['rotate'] + del kw['rotate'] + + if kw.has_key( 'translate' ): + translate = kw['translate'] + del kw['translate'] + + if kw.has_key( 'cloneid' ): + cloneid = kw['cloneid'] + del kw['cloneid'] + else: + cloneid = 0 + group = str( group ) + # sys.stdout.flush() + if cloneid == 0 : + self.id = zinc.add( itemType, group, *args, **kw ) + else : + self.id = self.zinc.clone(cloneid, *args, **kw) + + zinc.items[self.id] = self + texture = None + if fillpatern: + self.itemconfigure( fillpatern ) + if scale: + self.scale( scale ) + if translate: + self.translate( translate ) + + + def __str__( self ): + return str( self.id ) + + def __repr__( self ): + return str( self.id ) + + def bbox( self, *args ): + return self.zinc.bbox( self.id, *args ) + + def clone( self, *args, **kw): + '''id = zincitem.clone(*args,**kw) ''' + # print "ZincItem::clone" # on cherche tagOrId - # nidcloned = self.find_above(tagOrId) - sclonedtype = self.type() - sclonedgroupid = self.zinc.group(self.id) + # nidcloned = self.find_above(tagOrId) + sclonedtype = self.type() + sclonedgroupid = self.zinc.group(self.id) - # ajout cle 'cloneid' (voir ZincItem::__init__) - kw['cloneid'] = self.id + # ajout cle 'cloneid' (voir ZincItem::__init__) + kw['cloneid'] = self.id # on cree un nouveau ZincItem meme type, - return(ZincItem(self.zinc, sclonedtype, sclonedgroupid, **kw )) - - def delete( self ): - del self.zinc.items[self.id] - try: - self.zinc.remove( self.id ) - except: - pass - def __getitem__( self, key ): - '''allow to get attribute by self["key"] ''' - if ( key == "coords" ): - return self.zinc.coords( self.id ) - return self.zinc.itemcget( self.id, key ) - - def __setitem__( self, key, value ): - '''allow to set item attrbutes, eg. for a track position attributes - just writing : - a = ZincItem(myzinc, ...) - a["position"] = (x,y) - Notes : when setting multiple attributes - using itemconfigure is more efficient ''' - if ( key is "coords" ): - self.zinc.coords( self.id, value ) - else: - self.zinc.itemconfigure( self.id, **{key:value} ) - - def getGroup( self ): - groupid = self.zinc.group( self.id ) - return self.zinc.items[groupid] - - def keys( self ): - if not hasattr( self, '_keys' ): - self._keys = {} - config = self.zinc.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 bind( self, sequence=None, command=None, add=None ): - '''return a funcid which can be used to unbind + return(ZincItem(self.zinc, sclonedtype, sclonedgroupid, **kw )) + + def delete( self ): + del self.zinc.items[self.id] + try: + self.zinc.remove( self.id ) + except: + pass + def __getitem__( self, key ): + '''allow to get attribute by self["key"] ''' + if ( key == "coords" ): + return self.zinc.coords( self.id ) + return self.zinc.itemcget( self.id, key ) + + def __setitem__( self, key, value ): + '''allow to set item attrbutes, eg. for a track position attributes + just writing : + a = ZincItem(myzinc, ...) + a["position"] = (x,y) + Notes : when setting multiple attributes + using itemconfigure is more efficient ''' + if ( key is "coords" ): + self.zinc.coords( self.id, value ) + else: + self.zinc.itemconfigure( self.id, **{key:value} ) + + def getGroup( self ): + groupid = self.zinc.group( self.id ) + return self.zinc.items[groupid] + + def keys( self ): + if not hasattr( self, '_keys' ): + self._keys = {} + config = self.zinc.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 bind( self, sequence=None, command=None, add=None ): + '''return a funcid which can be used to unbind notes: unbinding can be done by bind("","") or using native tkinter unbind method ''' - return( self.zinc.bind_tag( self.id, sequence, command, add ) ) - - def cget( self, attr ): - return self.zinc.itemcget( self.id, attr ) - - def coords( self, *args, **kw ): - return self.zinc.coords( self.id, *args, **kw ) - - def fieldcget( self, field, attr ): - return self.zinc.itemfieldcget( self.id, field, attr ) - - def itemconfigure( self, field=None, **kw ): - self.zinc.itemconfigure( self.id, field, **kw ) - - def rotate( self, *args ): - return self.zinc.rotate( self.id, *args ) - - def scale( self, *args ): - return self.zinc.scale( self.id, *args ) - - def transforms( self, *args ): - """ - zincitem.transform(tozincitem, coordList) - This command returns a list of coordinates obtained by transforming the coordinates given in coordList - from the coordinate space of item to the coordinate space - of the tozincitem item. - The coordList should either be a flat list containing an even number of coordinates - each point having two coordinates, or a list of lists each sublist of the form [ X Y ?pointtype? ]. - The returned coordinates list will be isomorphic to the list given as argument. - """ - return self.zinc.transforms( self.id, *args ) - - def translate( self, *args ): - """ - zincitem.translate( xAmount, yAmount) - zincitem.translate( xAmount, yAmount, absolute) - Add a translation to the item. - A separate value is specified for X and Y. - If the optionnal ?absolute? parameter is true, - it will set an absolute translation to the item - """ - self.zinc.translate( self.id, *args ) - - def tset( self, *args ): - """ - zincitemtset(m00, m01, m10, m11, m20, m21) - Set the six elements of the 3x4 matrix used in affine transformation. - BEWARE that depending on mij values, - it is possible to define a not inversible matrix which will end up in core dump. - This method must BE USED CAUTIOUSLY. - """ - self.zinc.tset( self.id, *args ) - - def type( self ): - """ - name=zincitemtype() - This command returns the type of the item. - """ - return self.zinc.type( self.id ) - - def tsave( self, *args ): - """ - zincitemtsave( tName) - zincitemtsave( tName, invert) - Create a transform associated with the name tName - with initial value the transform associated with the item. - If tName already exists, the transform is set to the new value. - This command is the only way to create a named transform. - The invert boolean, if specified, cause the transform to be inverted prior to be saved. - """ - return self.zinc.tsave( self.id, *args ) - - def treset( self, *args ): - """ - zincitemtreset() - Set the named transform or the transform for the item - to identity. If there are no named transform, - an error is raised. - """ - self.zinc.treset( self.id, *args ) - - def trestore( self, *args ): - """ - zincitemtrestore( tName) - Set the transform for the item to the transform named by tName. - If the transform named tName doesn't exist, an error is raised. - """ - self.zinc.trestore( self.id, *args ) - - def tget( self, *args ): - """ - zincitemtget() - zincitemtget(selector) - selector:={'all'|'translation'|'scale'|'rotation'|'skew'} - With only one argument, get the six elements of the 3x4 matrix - used in affine transformation. - The result is compatible with the tset method. - With optional second parameter 'all' returns the transform - decomposed in translation, scale, rotation, skew - and return the list in this order, - With 'translation', 'scale', 'rotation', 'skew' optional - second parameter, returns the corresponding values. - """ - return self.zinc.tget( self.id, *args ) + return( self.zinc.bind_tag( self.id, sequence, command, add ) ) + + def cget( self, attr ): + return self.zinc.itemcget( self.id, attr ) + + def coords( self, *args, **kw ): + return self.zinc.coords( self.id, *args, **kw ) + + def fieldcget( self, field, attr ): + return self.zinc.itemfieldcget( self.id, field, attr ) + + def itemconfigure( self, field=None, **kw ): + self.zinc.itemconfigure( self.id, field, **kw ) + + def rotate( self, *args ): + return self.zinc.rotate( self.id, *args ) + + def scale( self, *args ): + return self.zinc.scale( self.id, *args ) + + def transforms( self, *args ): + """ + zincitem.transform(tozincitem, coordList) + This command returns a list of coordinates obtained by transforming the coordinates given in coordList + from the coordinate space of item to the coordinate space + of the tozincitem item. + The coordList should either be a flat list containing an even number of coordinates + each point having two coordinates, or a list of lists each sublist of the form [ X Y ?pointtype? ]. + The returned coordinates list will be isomorphic to the list given as argument. + """ + return self.zinc.transforms( self.id, *args ) + + def translate( self, *args ): + """ + zincitem.translate( xAmount, yAmount) + zincitem.translate( xAmount, yAmount, absolute) + Add a translation to the item. + A separate value is specified for X and Y. + If the optionnal ?absolute? parameter is true, + it will set an absolute translation to the item + """ + self.zinc.translate( self.id, *args ) + + def tset( self, *args ): + """ + zincitemtset(m00, m01, m10, m11, m20, m21) + Set the six elements of the 3x4 matrix used in affine transformation. + BEWARE that depending on mij values, + it is possible to define a not inversible matrix which will end up in core dump. + This method must BE USED CAUTIOUSLY. + """ + self.zinc.tset( self.id, *args ) + + def type( self ): + """ + name=zincitemtype() + This command returns the type of the item. + """ + return self.zinc.type( self.id ) + + def tsave( self, *args ): + """ + zincitemtsave( tName) + zincitemtsave( tName, invert) + Create a transform associated with the name tName + with initial value the transform associated with the item. + If tName already exists, the transform is set to the new value. + This command is the only way to create a named transform. + The invert boolean, if specified, cause the transform to be inverted prior to be saved. + """ + return self.zinc.tsave( self.id, *args ) + + def treset( self, *args ): + """ + zincitemtreset() + Set the named transform or the transform for the item + to identity. If there are no named transform, + an error is raised. + """ + self.zinc.treset( self.id, *args ) + + def trestore( self, *args ): + """ + zincitemtrestore( tName) + Set the transform for the item to the transform named by tName. + If the transform named tName doesn't exist, an error is raised. + """ + self.zinc.trestore( self.id, *args ) + + def tget( self, *args ): + """ + zincitemtget() + zincitemtget(selector) + selector:={'all'|'translation'|'scale'|'rotation'|'skew'} + With only one argument, get the six elements of the 3x4 matrix + used in affine transformation. + The result is compatible with the tset method. + With optional second parameter 'all' returns the transform + decomposed in translation, scale, rotation, skew + and return the list in this order, + With 'translation', 'scale', 'rotation', 'skew' optional + second parameter, returns the corresponding values. + """ + return self.zinc.tget( self.id, *args ) class Arc( ZincItem ): @@ -1119,7 +1144,7 @@ class Group( ZincItem ): else: return ZincItem.getGroup( self ) - #TODO: Extension. Renvoie les références aux ZincItems contenus dans le Groupe + #TODO: Extension. Renvoie les références aux ZincItems contenus dans le Groupe def getNode( self ): """ """ @@ -1138,7 +1163,7 @@ class Map( ZincItem ): These type do not expect type specific arguments. """ ZincItem.__init__( self, zinc, 'map', *args, **kw ) - + class Curve( ZincItem ): def __init__( self, zinc, *args, **kw ): """ @@ -1173,7 +1198,7 @@ class Curve( ZincItem ): ZincItem.__init__( self, zinc, 'curve', *args, **kw ) for contour in contours: self.zinc.contour( self.id, *contour ) - + class Rectangle( ZincItem ): def __init__( self, zinc, *args, **kw ): @@ -1204,11 +1229,11 @@ class Text( ZincItem ): class Track( ZincItem ): def __init__( self, zinc, *args, **kw ): ZincItem.__init__( self, zinc, 'track', *args, **kw ) - + class WayPoint( ZincItem ): - def __init__( self, zinc, *args, **kw ): - ZincItem.__init__( self, zinc, 'waypoint', *args, **kw ) - + def __init__( self, zinc, *args, **kw ): + ZincItem.__init__( self, zinc, 'waypoint', *args, **kw ) + # Class to hold mapinfos used by the Map Item class class Mapinfo: @@ -1225,7 +1250,7 @@ class Mapinfo: self.name = `id( self )` self.interp = interp.tk apply( self.interp.call, ( 'mapinfo', self.name, 'create' ) ) - + def __repr__( self ): return self.name @@ -1255,7 +1280,7 @@ class Mapinfo: new_name = str( obj ) self.interp.call( 'mapinfo', self.name, 'duplicate', new_name ) return obj - + def add_text( self, text_style, line_style, x, y, text ): """ Add a new graphical element to the mapinfo object text. @@ -1270,7 +1295,7 @@ class Mapinfo: @param Y: Coord on Y axe @type text: string @param : a string describing the text. - + """ self.interp.call( 'mapinfo', self.name, 'add', 'text', text_style, line_style, x, y, text ) @@ -1332,16 +1357,16 @@ class Mapinfo: """ self.interp.call( 'mapinfo', self.name, 'add', 'symbol', x, y, index ) - + def count( self, type ): """ @type type: {text|arc|line|symbol} @param type: Return an integer value that is the number of elements matching type in the mapinfo. - type may be one the legal element types + type may be one the legal element types """ return self.interp.call( 'mapinfo', self.name, 'count', type ) - + def get( self, type, index ): """ Return the parameters of the element at index with type type in the mapinfo. @@ -1360,7 +1385,7 @@ class Mapinfo: Indices are zero based and elements are listed by type. """ return self.interp.call( 'mapinfo', self.name, 'replace', - type, index, args ) + type, index, args ) def remove( self, type, index ): """ @@ -1378,7 +1403,7 @@ class Mapinfo: """ """ self.interp.call( 'mapinfo', self.name, 'translate', xAmount, yAmount ) - + class Videomap ( Mapinfo ): """ create a mapinfo from a proprietary @@ -1410,29 +1435,29 @@ class Videomap ( Mapinfo ): return self.tk.call( 'videomap', 'ids', filename ) class Colors: - """ - Classe abstraite utilitaire permettant de gérer sous forme d'objet - les couleurs aux formats Zinc - """ - def __init__( self ): - self.lColors = [] - - #TODO: - def getColorsIter( self ): - """ - Renvoie un itérateur sur les couleurs - """ - return self.lColors.__iter__() - - def addColor( self, color, alpha = 100, - colorposition = 0, mid_span_position = 50 ): - self.lColors.append( ( color, alpha, colorposition, mid_span_position ) ) - - def __repr__( self ): - res = "" - for i in self.lColors: - res = "%s%s;%s %s %s|" % ( res, i[0], i[1], i[2], i[3] ) - return res[:-1] + """ + Classe abstraite utilitaire permettant de gérer sous forme d'objet + les couleurs aux formats Zinc + """ + def __init__( self ): + self.lColors = [] + + #TODO: + def getColorsIter( self ): + """ + Renvoie un itérateur sur les couleurs + """ + return self.lColors.__iter__() + + def addColor( self, color, alpha = 100, + colorposition = 0, mid_span_position = 50 ): + self.lColors.append( ( color, alpha, colorposition, mid_span_position ) ) + + def __repr__( self ): + res = "" + for i in self.lColors: + res = "%s%s;%s %s %s|" % ( res, i[0], i[1], i[2], i[3] ) + return res[:-1] class AxialGradientColor( Colors ): def __init__( self, *params ): @@ -1484,8 +1509,8 @@ class RadialGradientColor( Colors ): class PathGradientColor( Colors ): def __init__( self, *params ): """ - =path x y | gradient_step1 | ... | gradient_stepn - The x y parameters define the center of the gradient. + =path x y | gradient_step1 | ... | gradient_stepn + The x y parameters define the center of the gradient. """ Colors.__init__( self ) count = 0 @@ -1493,8 +1518,8 @@ class PathGradientColor( Colors ): for i in params: self.params = "%s %s" % ( self.params, str( i ) ) count += 1 - if ( count != 2 ): - raise Exception( "Bad Format of params %s" % count ) + if ( count != 2 ): + raise Exception( "Bad Format of params %s" % count ) def __repr__( self ): res = "=path %s " % self.params @@ -1541,32 +1566,32 @@ class ConicalGradientColor( Colors ): # ---- self-test ---------------------------------------------------------- if __name__ == '__main__': - from Tkinter import * - import Zinc - def createItem( zinc, group, ev ): - print >> sys.stdout, "CreateIHM" - sys.stdout.flush() - Zinc.Rectangle( zinc, group, - ( 100, 100, 150, 150 ), - linewidth = "10", linecolor = '#FFFF00', - relief = "roundgroove", filled = 1, - fillcolor = "red", tags = ( "hello", "test" ) ) - sys.stdout.write( "hello_clic" + str( ev ) ) - - z = Zinc.Zinc( master = None, render = 1, height = 200, width = 400 ) - g1 = Zinc.Group( z, 1 ) - r = Zinc.Rectangle( z, g1, ( 0, 0, 400, 200 ), - linewidth = "10", - linecolor = '#FFFF00', - relief = "roundgroove", - filled = 1, - fillcolor = "#FFFFFF", - tags = ( "hello", "test" ) ) - t = Zinc.Text( z, g1, position = ( 40, 100 ), text = z.version ) -# z.bind_tag("hello","<1>",lambda ev,z=z,g=g1 : createItem(z,g,ev)) - z.configure( backcolor = 'black' ) - z.pack() - z.mainloop() + from Tkinter import * + import Zinc + def createItem( zinc, group, ev ): + print >> sys.stdout, "CreateIHM" + sys.stdout.flush() + Zinc.Rectangle( zinc, group, + ( 100, 100, 150, 150 ), + linewidth = "10", linecolor = '#FFFF00', + relief = "roundgroove", filled = 1, + fillcolor = "red", tags = ( "hello", "test" ) ) + sys.stdout.write( "hello_clic" + str( ev ) ) + + z = Zinc.Zinc( master = None, render = 1, height = 200, width = 400 ) + g1 = Zinc.Group( z, 1 ) + r = Zinc.Rectangle( z, g1, ( 0, 0, 400, 200 ), + linewidth = "10", + linecolor = '#FFFF00', + relief = "roundgroove", + filled = 1, + fillcolor = "#FFFFFF", + tags = ( "hello", "test" ) ) + t = Zinc.Text( z, g1, position = ( 40, 100 ), text = z.version ) +# z.bind_tag("hello","<1>",lambda ev,z=z,g=g1 : createItem(z,g,ev)) + z.configure( backcolor = 'black' ) + z.pack() + z.mainloop() # Zinc.py ends here -- cgit v1.1