path: root/Python/library/Zinc.py

#!/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: Zinc.py 1908 2008-09-15 09:38:54Z lecoanet $
#
#
# 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: 1908 $"
__revision__ = "$Revision: 1908 $"

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.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 ) )

#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 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"
        # on cherche tagOrId
    # nidcloned = self.find_above(tagOrId)
    sclonedtype = self.type()
    sclonedgroupid = self.zinc.group(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
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