Suppressed the Zinc.py.in template as it is no longer needed

1 files changed, 0 insertions, 1549 deletions

diff --git a/Python/library/Zinc.py.in b/Python/library/Zinc.py.in
deleted file mode 100644
index a4866ea..0000000
--- a/Python/library/Zinc.py.in
+++ /dev/null
@@ -1,1549 +0,0 @@
-#!/usr/bin/python
-# -*- coding: iso-8859-1 -*-
-#
-# Zinc.py -- Python interface to the tkzinc widget.
-#
-# Authors         : Frederic Lepied, Patrick Lecoanet
-# Created Date    : Thu Jul 22 09:36:04 1999
-#
-# $Id$
-#
-#
-# Copyright (c) 1999 CENA --
-#
-# See the file "Copyright" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-#
-
-__version__  = "$Revision$"
-__revision__ = "$Revision$"
-
-from Tkinter import *
-import new
-import os
-import locale, types
-import traceback
-
-ZINC_CURRENT_POSITION = -2
-ZINC_SPEED_VECTOR     = -3
-ZINC_LEADER           = -4
-ZINC_CONNECTION       = -5
-_LIBLOADED            = 0
-_VERSION              = ""
-ZINC_NO_PART          = ""
-
-# current part dictionnary
-ZINC_DPART = { 'position'      : ZINC_CURRENT_POSITION, 
-			   '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
-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
-
-class ZincException:
-	def __call__( self ):
-		raise self
-
-	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.cgetz(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 ):
-		"""
-		id = zinc.clone(tagOrId, **attributs)
-		"""
-		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 itemfieldcget( 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 )
-
-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']
-			
-		group = str( group )
-                sys.stdout.flush()
-		self.id = zinc.add( itemType, group, *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 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("<seq>","") 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 )
-
-
-class Arc( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        The arc type expects a list of four floating point numbers xo yo xc yc,
-        giving the coordinates of the origin and the corner of the enclosing rectangle.
-        The origin should be the top left vertex of the enclosing rectangle and the corner
-        the bottom right vertex of the rectangle.
-        """
-        ZincItem.__init__( self, zinc, 'arc', *args, **kw )    
-
-class Group( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        These type do not expect type specific arguments.
-        """
-        ZincItem.__init__( self, zinc, 'group', *args, **kw )    
-
-    def getGroup( self ):
-        """Retourne l'objet de type Group
-        auquel est attache l'item"""
-        ###Gestion du boostrap
-        if self.id == 1:
-            return self.zinc.items[1]
-        else:
-            return ZincItem.getGroup( self )
-
-	#TODO: Extension. Renvoie les références aux ZincItems contenus dans le Groupe
-    def getNode( self ):
-        """
-        """
-        pass
-            
-class Icon( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        These type do not expect type specific arguments.
-        """
-        ZincItem.__init__( self, zinc, 'icon', *args, **kw )    
-
-class Map( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        These type do not expect type specific arguments.
-        """
-        ZincItem.__init__( self, zinc, 'map', *args, **kw )
-	
-class Curve( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        The curve type expects either a flat list or a list of lists.
-        In the first case, the flat list must be a list of floating point numbers
-        x0 y0 x1 y1 ... xn yn, giving the coordinates of the curve vertices.
-        The number of values should be even (or the last value will be discarded)
-        but the list can be empty to build an empty invisible curve.
-        In the second case,thelist must contain lists of 2 or 3 elements:
-        xi, yi and and an optionnal point type. Currently,
-        the only available point type is 'c' for a cubic bezier control point.
-        For example, the following list is an example of 2 beziers segments
-        with a straight segment in-between:
-        ( [x0, y0], [x1, y1, 'c'], [x2, y2, 'c'], [x3, y3], [x4, y4, 'c'], [x5, y5] )
-        
-        As there is only on control point, [x4, y4, 'c'] ,
-        for the second cubic bezier,
-        the omitted second control point will be defaulted to the same point.
-        a named tuple contours can give to define new contours in curve.
-        contours=(<contour1>,...)
-        <contour>=(<point1>,...)
-        A curve can be defined later with the contour or coords commands.
-        As a side effect of the curve behavior,
-        a one vertex curve is essentially the same as an empty curve,
-        it only waste some more memory.
-        
-        """
-        contours = []
-        if kw.has_key( 'contours' ):
-            contours = kw['contours']
-            del kw['contours']
-        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 ):
-        """
-        The rectangle type expects a list of four floating point numbers xo yo xc yc,
-        giving the coordinates of the origin and the corner of the rectangle.
-        """
-        ZincItem.__init__( self, zinc, 'rectangle', *args, **kw )    
-
-class Reticle( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        These type do not expect type specific arguments.
-        """
-        ZincItem.__init__( self, zinc, 'reticle', *args, **kw )    
-
-class Tabular( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        ZincItem.__init__( self, zinc, 'tabular', *args, **kw )    
-
-class Text( ZincItem ):
-    def __init__( self, zinc, *args, **kw ):
-        """
-        These type do not expect type specific arguments.
-        """
-        ZincItem.__init__( self, zinc, 'text', *args, **kw )    
-
-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 )
-	
-
-# Class to hold mapinfos used by the Map Item class 
-class Mapinfo:
-    def __init__( self, interp, name = None ):
-        """
-        @type name: string
-        @param name: Name of mapinfo. Must be used carrefully !
-        Create a new empty map description.
-        The new mapinfo object named name or internal id if name is omitted
-        """
-        if name :
-            self.name = name
-        else:
-            self.name = `id( self )`
-        self.interp = interp.tk
-        apply( self.interp.call, ( 'mapinfo', self.name, 'create' ) )
-		
-    def __repr__( self ):
-        return self.name
-
-    def __del__( self ):
-        self.delete()
-
-    def delete( self ):
-        """
-        Delete the mapinfo object.
-        All maps that refer to the deleted mapinfo are updated to reflect the change.
-        """
-        self.interp.call( 'mapinfo', self.name, 'delete' )
-
-
-    def duplicate( self, *args ):
-        """
-        B{Optional}
-        @type name: Name of the new mapinfo
-        @param name: Must be use carrefully !!
-        Create a new mapinfo that is a exact copy of this mapinfo Object.
-        """
-        classe = Mapinfo
-        obj = new.instance( classe )
-        if len( args ):
-            new_name = args[0]
-        else:
-            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. 
-        This element describes a line of text.
-        @type text_style: {normal|underlined}
-        @param text_style: text style 
-        @type line_style: string
-        @param line_style: a line style (simple, dashed,  dotted, mixed, marked) to be used for the underline
-        @type X: int
-        @param X: Coord on X axe
-        @type Y: int
-        @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 )
-
-    def add_line( self, line_style, width, x1, y1, x2, y2 ):
-        """
-        Add a new graphical element to the mapinfo object line.
-        This element describes a line segment.
-        @type line_style: {simple|dashed|dotted|mixed|marked}
-        @param line_style: a line style
-        @type width: int
-        @param width: the line width in pixels
-        @type x1: int
-        @param x1: coords on X axe
-        @type x2: int
-        @param x2: coords on Y axe
-        @type x3: int
-        @param x3:  end vertices on X axe
-        @type x4: int
-        @param x4: end vertices on Y axe
-        four integer values setting the X and Y coordinates of the two end vertices.
-        """
-        self.interp.call( 'mapinfo', self.name, 'add', 'line', line_style, 
-                         width, x1, y1, x2, y2 )
-
-    def add_arc( self, line_style, width, cx, cy, radius, start, extent ):
-        """
-        Add a new graphical element to the mapinfo object arc.
-        
-        @type line_style: {simple|dashed|dotted|mixed|marked}
-        @param line_style: a line style
-        @type width: int 
-        @param width: the line width in pixels
-        @type cx: int
-        @param cx: X of arc center
-        @type cy: int 
-        @param cy: Y of arc center
-        @type radius: int 
-        @param radius: the arc radius
-        @type start: int
-        @param start: the start angle (in degree)
-        @type extent: int
-        @param extent: the angular extent of the arc (in degree).
-        
-        """
-        self.interp.call( 'mapinfo', self.name, 'add', 'arc', line_style, 
-                         width, cx, cy, radius, start, extent )
-        
-    def add_symbol( self, x, y, index ):
-        """
-        Add a new graphical element to the mapinfo object symbol.
-        @type x: int
-        @param x: position on X
-        @type y: int
-        @param y: position on Y
-        
-        @type index: int
-        @param : an integer setting the symbol index in the -symbols list of the map item
-        
-        """
-        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		
-        """
-        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.
-        The returned value is a list.
-        The exact number of parameters in the list and their meaning depend on type and is accurately described in mapinfo add.
-        type may be one the legal element types as described in the mapinfo add command.
-        Indices are zero based and elements are listed by type.
-        """
-        return self.interp.call( 'mapinfo', self.name, 'remove', type, index )
-
-    def replace( self, type, index, *args ):
-        """
-        Replace all parameters for the element at index with type type in the mapinfo.
-        The exact number and content for args depend on  type and is accurately described in mapinfo add.
-        type may be one the legal element types as described in the mapinfo add command.
-        Indices are zero based and elements are listed by type.
-        """
-        return self.interp.call( 'mapinfo', self.name, 'replace', 
-								 type, index, args )
-
-    def remove( self, type, index ):
-        """
-        Remove the element at index with type type in the mapinfo.
-        type may be one the legal element types as described in the mapinfo add command. Indices are zero based and elements are listed by type.
-        """
-        return self.interp.call( 'mapinfo', self.name, 'remove', type, index )
-    
-    def scale( self, factor ):
-        """
-        """
-        self.interp.call( 'mapinfo', self.name, 'scale', factor )
-        
-    def translate( self, xAmount, yAmount ):
-        """
-        """
-        self.interp.call( 'mapinfo', self.name, 'translate', xAmount, yAmount )
-		
-class Videomap ( Mapinfo ):
-    """
-    create a mapinfo from a proprietary
-    file format for simple maps, in use in french Air Traffic Control Centres. The format is the
-    binary cautra4 (with x and y in 1/8nm units) 
-    """
-    def __init__( self, tk, *args ):
-        """
-        @type  filename: 
-        @param filename:
-        @type  mapinfoname: 
-        @param mapinfoname: 
-        Load the videomap sub-map located at position index in the file named  fileName into a mapinfo object named mapInfoName. It is possible, if needed, to use the videomap ids command to help translate a sub-map id into a sub-map file index.
-        """
-        self.tk = tk.tk
-        args    = args + ( self, )
-        self.tk.call( 'videomap', 'load', *args )
-        
-
-    def ids( self, filename ):
-        """
-        @type  filename: string
-        @param filename: filename where to search syb-map
-        B{Class Method}
-        Return all sub-map ids that are described in the videomap file described by  fileName.
-        The ids are listed in file order. This command makes possible to iterate through a videomap file
-        one sub-map at a time, to know how much sub-maps are there and to sort them according to their ids.
-        """
-        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]
-    
-class AxialGradientColor( Colors ):
-    def __init__( self, *params ):
-        """
-        params : degre or  x1, y1, x2, y2 which define angle and extension of the axe
-        =axial degre | gradient_step1 | ... | gradient_stepn or
-        =axial x1 y1 x2 y2 | gradient_step1 | ... | gradient_stepn
-        """
-        Colors.__init__( self )
-        count = 0
-        self.params = ""
-        for i in params:
-            self.params = "%s %s" % ( self.params, str( i ) )
-            count += 1
-        if ( count != 1 ) and ( count != 4 ):
-            raise Exception( "Bad Format of params %s" % count )
-        
-    def __repr__( self ):
-        res = "=axial %s" % self.params
-        if not ( len( self.lColors ) ):
-            raise Exception( "Bad Format, must have  one color less" )
-        res = "%s | %s" % ( res, Colors.__repr__( self ) )
-        return res
-                
-class RadialGradientColor( Colors ):
-    def __init__( self, *params ):
-        """
-        =radial x y | gradient_step1 | ... | gradient_stepn  or
-        =radial x1 y1 x2 y2 | gradient_step1 | ... | gradient_stepn
-        The x y parameters define the center of the radial.
-        The x1 y1 x2 y2 parameters define both the center and the extension of the radial.
-        """
-        Colors.__init__( self )
-        count = 0
-        self.params = ""
-        for i in params:
-            self.params = "%s %s" % ( self.params, str( i ) )
-            count += 1
-        if ( ( count!= 2 ) and ( count != 4 ) ):
-            raise Exception( "Bad Format of params %s"%count )
-        
-    def __repr__( self ):
-        res = "=radial %s " % self.params
-        if not ( len( self.lColors ) ):
-            raise Exception( "Bad Format, must have  one color less" )
-        res = "%s | %s" % ( res, Colors.__repr__( self ) )
-        return res
-
-class PathGradientColor( Colors ):
-    def __init__( self, *params ):
-        """
-		=path x y | gradient_step1 | ... | gradient_stepn
-		The x y parameters define the center of the gradient. 
-        """
-        Colors.__init__( self )
-        count       = 0
-        self.params = ""
-        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 )
-        
-    def __repr__( self ):
-        res = "=path %s " % self.params
-        if not ( len( self.lColors ) ):
-            raise Exception( "Bad Format, must have  one color less" )
-        res = "%s | %s" % ( res, Colors.__repr__( self ) )
-        return res
-
-class ConicalGradientColor( Colors ):
-    def __init__( self, *params ):
-        """
-        =conical degre | gradient_step1 | ... | gradient_stepn or
-        =conical degre x y | gradient_step1 | ... | gradient_stepn or
-        =conical x1 y1 x2 y2 | gradient_step1 | ... | gradient_stepn
-        
-        The degre parameter defines the angle of the cone in the usual trigonometric sense.
-        The optional x y parameters define the center of the cone.
-        By default, it is the center of the bounding-box.
-        The x1 y1 x2 y2 parameters define the center and the angle of the cone.
-
-        All x and y coordinates are expressed in percentage of the bounding box,
-        relatively to the center of the bounding box.
-        So 0 0 means the center while -50 -50 means the lower left corner of the bounding box. 
-
-        If none of the above gradient type specification is given,
-        the gradient will be drawn as an axial gradient with a null angle. 
-        """
-        Colors.__init__( self )
-        count = 0
-        self.params = ""
-        for i in params:
-            self.params = "%s %s" % ( self.params, str( i ) )
-            count += 1
-        if ( count != 1 ) and ( count != 3 ) and ( count != 4 ):
-            raise Exception( "Bad Format of params %s" % count )
-        
-    def __repr__( self ):
-        res = "=conical %s " % self.params
-        if not ( len( self.lColors ) ):
-            raise Exception( "Bad Format, must have  one color less" )
-        res = "%s | %s" % ( res, Colors.__repr__( self ) )
-        return res
-                
-        
-# ---- 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()
-
-# Zinc.py ends here