Daniel Etienne pre release for Bullseye

1 files changed, 2351 insertions, 0 deletions

diff --git a/Python/build/lib.linux-x86_64-2.7/Zinc/graphics.py b/Python/build/lib.linux-x86_64-2.7/Zinc/graphics.py
new file mode 100755
index 0000000..5277e5c
--- /dev/null
+++ b/Python/build/lib.linux-x86_64-2.7/Zinc/graphics.py
@@ -0,0 +1,2351 @@
+# -*- coding: iso-8859-1 -*-
+"""
+#-------------------------------------------------------------------------------
+#
+#      Graphics.py
+#      some graphic design functions
+#
+#-------------------------------------------------------------------------------
+#  Functions to create complexe graphic component :
+#  ------------------------------------------------
+#      build_zinc_item          (realize a zinc item from description hash table
+#                              management of enhanced graphics functions)
+#
+#      repeat_zinc_item         (duplication of given zinc item)
+#
+#  Function to compute complexe geometrical forms :
+#  (text header of functions explain options for each form,
+#  function return curve coords using control points of cubic curve)
+#  -----------------------------------------------------------------
+#     rounded_rectangle_coords (return curve coords of rounded rectangle)
+#     hippodrome_coords       (return curve coords of circus form)
+#     ellipse_coords          (return curve coords of ellipse form)
+#     polygon_coords          (return curve coords of regular polygon)
+#     roundedcurve_coords     (return curve coords of rounded curve)
+#     polyline_coords         (return curve coords of polyline)
+#     shiftpath_coords        (return curve coords of shifting path)
+#     tabbox_coords           (return curve coords of tabbox's pages)
+#     pathline_coords         (return triangles coords of pathline)
+#
+#  Function to compute 2D 1/2 relief and shadow :
+#  function build zinc items (triangles and curve) to simulate this
+#  -----------------------------------------------------------------
+#     graphicitem_relief    (return triangle items simulate relief of given item)
+#     polyline_relief_params (return triangle coords
+#                           and lighting triangles color list)
+#     graphicitem_shadow    (return triangles and curve items
+#                           simulate shadow of given item))
+#     polyline_shadow_params (return triangle and curve coords
+#                           and shadow triangles color list))
+#
+#
+#-------------------------------------------------------------------------------
+#      Authors: Jean-Luc Vinot <vinot@cena.fr>
+#      PM2PY: Guillaume Vidon <vidon@ath.cena.fr> 
+#
+# $Id: graphics.py 1697 2005-06-13 00:25:58Z vidon $ 
+#-------------------------------------------------------------------------------
+"""
+VERSION = "1.0"
+__revision__ = "0.1"
+
+import logging
+import types
+import re
+from geometry import *
+from pictorial import *
+from math import pi, radians, atan2, sqrt, sin, cos
+
+graphiclogger = logging.getLogger('Graphics')
+debug = graphiclogger.debug
+error = graphiclogger.error
+exception = graphiclogger.exception
+log = lambda msg : graphiclogger.log(logging.DEBUG, msg)
+
+# constante facteur point directeur (conique -> quadratique)
+const_ptd_factor = .5523
+
+def transdic(**dict):
+    newdic={}
+    for key, val in dict.items():
+        if (type(val) is types.ListType):
+            newdic[key] = tuple(val)
+        else:
+            newdic[key] = val
+    return newdic
+    
+def is_flat_list(apts):
+    if reduce(lambda x, y : x and (type(y) in ( types.FloatType, types.IntType)),
+              apts):
+        if len(apts) % 2:
+            raise ValueError("Not a valid Coords list")
+        else :
+            return True
+    else :
+        return False
+
+def is_point(apoint):
+    if (type(apoint) in ( types.TupleType, types.ListType)):
+        if len(apoint) == 2 :
+            if reduce(lambda x, y : x and (type(y) in ( types.FloatType, types.IntType)),
+                      apts):
+                return True
+            else :
+                return False
+        elif reduce(lambda x, y : x and (type(y) in ( types.FloatType, types.IntType)),
+                    apts[:-1])\
+                    and type(apts[-1]) in ('c', 'n'):
+            return True
+        else :
+            return False
+    else :
+        return False
+                
+# def is_tuple_list(apts):
+#     if reduce(lambda x, y : x \
+#               and is_point(x)),
+#               apts):
+                  
+    
+def lpts2coords(lpts):
+    coords = []
+    if (type(lpts) in ( types.TupleType, types.ListType )):
+        for point in lpts :
+            coords.append(tuple(point))
+    return tuple(coords)
+            
+def coords2lpts(coords):
+    lpts = []
+    if (type(coords) in ( types.TupleType, types.ListType )):
+        for point in coords :
+            lpts.append(list(point))
+    else :
+        raise ValueError("Invalid Coords %s "%coords)
+    return lpts
+
+def build_zinc_item(widget, pgroup = 1, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::build_zinc_item
+    # Création d'un objet Zinc de représentation
+    #---------------------------------------------------------------------------
+    # types d'items valides :
+    # les items natifs zinc : group, rectangle, arc, curve, text, icon
+    # les items ci-après permettent de spécifier des curves 'particulières' :
+    # -roundedrectangle : rectangle à coin arrondi
+    #       -hippodrome : hippodrome
+    #          -ellipse : ellipse un centre 2 rayons
+    #         -polygone : polygone régulier à n cotés (convexe ou en étoile)
+    #     -roundedcurve : curve multicontours à coins arrondis (rayon unique)
+    #         -polyline : curve multicontours à coins arrondis (le rayon pouvant
+    #                     être défini 
+    #                     spécifiquement pour chaque sommet)
+    #         -pathline : création d'une ligne 'épaisse' avec l'item Zinc 
+    #                     triangles décalage par rapport à un chemin donné 
+    #                     (largeur et sens de décalage)
+    #                     dégradé de couleurs de la ligne (linéaire, transversal
+    #                     ou double)
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # widget : <widget> identifiant du widget Zinc
+    # parentgroup : <tagOrId> identifiant du group parent
+    #
+    # options :
+    #   -itemtype : type de l'item à construire (type zinc ou metatype)
+    #     -coords : <coords|coordsList> coordonnées de l'item
+    # -metacoords : <hastable> calcul de coordonnées par type 
+    #               d'item différent de itemtype
+    #   -contours : <contourList> paramètres multi-contours
+    #     -params : <hastable> arguments spécifiques de l'item à passer
+    #               au widget
+    #    -addtags : [list of specific tags] to add to params -tags
+    #    -texture : <imagefile> ajout d'une texture à l'item
+    #    -pattern : <imagefile> ajout d'un pattern à l'item
+    #     -relief : <hastable> création d'un relief à l'item invoque la fonction
+    #               graphicitem_relief()
+    #     -shadow : <hastable> création d'une ombre portée à l'item invoque
+    #               la fonction graphicitem_shadow()
+    #      -scale : <scale_factor|[xscale_factor,yscale_factor]> application
+    #               d'une transformation zinc->scale à l'item
+    #  -translate : <[delta_x,delta_y]> application d'un transformation zinc->translate
+    #               à l'item.
+    #     -rotate : <angle> application d'une transformation zinc->rotate
+    #               (en degré) à l'item
+    #       -name : <str> nom de l'item
+    #               spécifiques item group :
+    #       -clip : <coordList|hashtable> paramètres de clipping d'un item group
+    #               (coords ou item)
+    #      -items : <hashtable> appel récursif de la fonction permettant
+    #               d'inclure des items au groupe
+    #---------------------------------------------------------------------------
+    #
+    #---------------------------------------------------------------------------
+    """
+
+    if options.has_key('parentgroup'):
+        parentgroup = options['parentgroup']
+    else :
+        parentgroup = pgroup
+    try:
+        itemtype = options['itemtype']
+    except KeyError:
+        raise ValueError("Must have itemtype option")
+    try:
+        coords = options['coords']
+    except KeyError:
+        try:
+            coords = options['metacoords']
+        except KeyError :
+            raise ValueError("Must have coords or metacoords option")
+        
+    if options.has_key('params'):
+        params = options['params']
+    else:
+        params = {}
+
+    #return unless($widget and $itemtype
+    #and ($coords or $options{'-metacoords'}))
+
+    try:
+        name = options['name']
+    except KeyError:
+        name = None
+
+    item = None
+    metatype = None
+    items = []
+    reliefs = []
+    shadows = []
+    tags = []
+
+    #--------------------
+    # GEOMETRIE DES ITEMS
+
+    # gestion des types d'items particuliers et à raccords circulaires
+    if (itemtype in ( 'roundedrectangle',
+                      'hippodrome',
+                      'polygone',
+                      'ellipse',
+                      'roundedcurve',
+                      'polyline',
+                      'curveline')):
+
+        # par défaut la curve sera fermée -closed = 1
+        if not params.has_key('closed'):
+            params['closed'] = 1
+        metatype = itemtype
+        itemtype = 'curve'
+
+        # possibilité de définir les coordonnées initiales par metatype
+        if (options.has_key('metacoords')) :
+            options['coords'] = meta_coords( **options['metacoords'])
+
+    # création d'une pathline à partir d'item zinc triangles
+    elif (itemtype == 'pathline') :
+        itemtype = 'triangles'
+        if (options.has_key('metacoords')) :
+            coords = meta_coords( **options['metacoords'])
+          
+        if (options.has_key('graduate')) :
+            numcolors = len(coords)
+            lcolors = path_graduate(widget,
+                                    numcolors,
+                                    options['graduate'])
+            params['colors'] = tuple(lcolors)
+
+        if options.has_key('coords'):
+            coords = pathline_coords(**options)
+        else:
+            coords = pathline_coords(coords, **options)
+
+        # création d'une boite à onglet
+    elif (itemtype == 'tabbox') :
+        return build_tabboxitem(widget, parentgroup, **options)
+
+    # calcul des coordonnées finales de la curve
+    if (metatype is not None):
+        coords = meta_coords(type = metatype, **options)
+
+
+    # gestion du multi-contours (accessible pour tous les types
+    # d'items géometriques)
+    if (options.has_key('contours') and (metatype is not None)) :
+        lcontours = options['contours']
+        contours=[]
+        numcontours = len(contours)
+        for contour in lcontours:
+            # radius et corners peuvent être défini
+            # spécifiquement pour chaque contour
+            (atype, way, addcoords,) = contour[:3]
+            if len(contour) >= 4:
+                radius = contour[3]
+            else :
+                radius = None
+            if len(contour) >= 5:
+                corners = contour[4]
+            else:
+                corners = None
+            if len(contour) >= 6:
+                corners_radius = contour[5]
+            else :
+                corners_radius = None
+            if (radius is None):
+                if options.has_key('radius'):
+                    radius = options['radius']
+                else :
+                    raise ValueError("radius option requiered")
+
+            newcoords = meta_coords(type = metatype,
+                                    coords = addcoords,
+                                    radius = radius,
+                                    corners = corners,
+                                    corners_radius = corners_radius
+                                    )
+            contours.append((atype, way, newcoords))
+
+        options['contours'] = contours
+
+    #----------------------
+    # REALISATION DES ITEMS
+
+    # ITEM GROUP
+    # gestion des coordonnées et du clipping
+    if (itemtype == 'group') :
+        item = widget.add(itemtype,
+                          parentgroup,
+                          **params)
+        widget.addtag_withtag(name, item)
+        if coords:
+            widget.coords(item, tuple(coords))
+
+        # clipping du groupe par item ou par géometrie
+        if (options.has_key('clip')) :
+            clipbuilder = options['clip']
+            clip = None
+
+            # création d'un item de clipping
+            if (type(clipbuilder) is types.DictType
+                and clipbuilder.has_key('itemtype')):
+                clip = build_zinc_item(widget, item, **clipbuilder)
+
+            elif (type(clipbuilder) in (types.TupleType, types.ListType)
+                  or widget.type(clipbuilder)) :
+                clip = clipbuilder
+
+            if (clip):
+                widget.itemconfigure(item, clip = clip)
+
+        # créations si besoin des items contenus dans le groupe
+        if (options.has_key('items')
+            and type(options['items']) is types.DictType) :
+            for (itemname, itemstyle) in options['items'].items() :
+                if not itemstyle.has_key('name'):
+                    itemstyle['name'] = itemname
+                build_zinc_item(widget, item, **itemstyle)
+
+
+    # ITEM TEXT ou ICON
+    elif (itemtype in ('text', 'icon')) :
+        imagefile = None
+        if (itemtype == 'icon') :
+            imagefile = params['image']
+            image = get_image(widget, imagefile)
+            if (image) :
+                params['image'] = image
+            else:
+                params['image'] = ""
+    
+
+        item = widget.add(itemtype,
+                          parentgroup,
+                          position = coords,
+                          **params
+                          )
+        if imagefile:
+            params['image'] = imagefile 
+
+
+    # ITEMS GEOMETRIQUES -> CURVE
+    else :
+        nparams=params
+        item = widget.add(itemtype,
+                          parentgroup,
+                          lpts2coords(coords),
+                          **params
+                          )
+
+        if (itemtype == 'curve' and options.has_key('contours')) :
+            for contour in options['contours'] :
+                contour = list(contour)
+                contour[2] = tuple(contour[2])
+                widget.contour(item, *contour)
+                             
+        # gestion du mode norender
+        if (options.has_key('texture')) :
+            texture = get_texture(widget, options['texture'])
+            if texture:
+                widget.itemconfigure(item, tile = texture)
+
+        if (options.has_key('pattern')) :
+            bitmap = get_pattern(**options['pattern'])
+            if bitmap:
+                widget.itemconfigure(item, fillpattern = bitmap)
+
+    # gestion des tags spécifiques
+    if (options.has_key('addtags')) :
+        tags = options['addtags']
+
+        params_tags = params['tags']
+        if params_tags:
+            tags.extend(params_tags) 
+
+        widget.itemconfigure(item, tags = tags)
+
+    #-------------------------------
+    # TRANSFORMATIONS ZINC DE L'ITEM
+
+    # transformation scale de l'item si nécessaire
+    if (options.has_key('scale')) :
+        scale = options['scale']
+        if (type(scale) is not types.TupleType) :
+            scale = (scale, scale) 
+        widget.scale(item, scale)
+  
+
+    # transformation rotate de l'item si nécessaire
+    if (options.has_key('rotate')):
+        widget.rotate(item, radians(options['rotate'])) 
+
+    # transformation translate de l'item si nécessaire
+    if (options.has_key('translate')):
+        widget.translate(item, options['translate'])
+
+
+    # répétition de l'item
+    if (options.has_key('repeat')) :
+        items.extend((item,
+                      repeat_zinc_item(widget, item, **options['repeat'])))
+
+    #-----------------------
+    # RELIEF ET OMBRE PORTEE
+
+    # gestion du relief
+    if (options.has_key('relief')) :
+        if (len(items)) :
+            target = items
+        else:
+            target = item
+        reliefs.extend(graphicitem_relief(widget,
+                                          target, **options['relief']))
+
+    # gestion de l'ombre portée
+    if (options.has_key('shadow')) :
+        if (len(items)) :
+            target = items
+        else:
+            target = item
+        shadows.extend(graphicitem_shadow(widget,
+                                         target, **options['shadow']))
+  
+
+    if len(reliefs):
+        items.extend(reliefs)
+    if len(shadows):
+        items.extend(shadows)
+
+    if len(items):
+        return items
+    else:
+        return item
+
+def repeat_zinc_item(widget,
+                     item,
+                     num = 2,
+                     dxy = (0,0),
+                     angle = None,
+                     params = None,
+                     copytag = None) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::repeat_zinc_item
+    # Duplication (clonage) d'un objet Zinc de représentation
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # widget : <widget> identifiant du widget zinc
+    #   item : <tagOrId> identifiant de l'item source
+    # options :
+    #     -num : <n> nombre d'item total (par defaut 2)
+    #     -dxy : <[delta_x, delta_y]> translation entre 2 duplications (par defaut [0,0])
+    #   -angle : <angle> rotation entre 2 duplications
+    # -copytag : <sting> ajout d'un tag indexé pour chaque copie
+    #  -params : <hashtable> {clef => [value list]}> valeur de paramètre
+    #            de chaque copie
+    #---------------------------------------------------------------------------
+    """
+    clones = []
+    delta_x, delta_y = dxy
+    # duplication d'une liste d'items -> appel récursif
+    if (type(item) in (types.TupleType, types.ListType)) :
+        for part in item :
+            clones.append(repeat_zinc_item(widget,
+                                           part,
+                                           dxy,
+                                           angle,
+                                           params,
+                                           copytag))
+
+        return clones
+
+    tags = []
+
+    if (copytag) :
+        tags = widget.itemcget(item, 'tags')
+        widget.itemconfigure(item, tags = tags + ("%s0"%copytag,))
+
+    for i in xrange(1, num) :
+        clone = None
+
+        if (copytag) :
+            clone = widget.clone(item, tags = tags + ("%s%s"%(copytag, i),))
+        else :
+            clone = widget.clone(item)
+
+        clones.append(clone)
+        widget.translate(clone, delta_x*i, delta_y*i)
+        if angle :
+            widget.rotate(clone, radians(angle*i))
+
+        if (params is not None ) :
+            widget.itemconfigure(clone, **params )
+    return clones
+
+
+#MUST BE TESTED
+def meta_coords( type,
+                 coords,
+                 **options ):
+    """
+    #---------------------------------------------------------------------------
+    # FONCTIONS GEOMETRIQUES
+    #---------------------------------------------------------------------------
+    
+    #---------------------------------------------------------------------------
+    # Graphics::meta_coords
+    # retourne une liste de coordonnées en utilisant la fonction du type
+    # d'item spécifié
+    #---------------------------------------------------------------------------
+    # paramètres : (passés par %options)
+    #   -type : <string> type de primitive utilisée
+    # -coords : <coordsList> coordonnées nécessitée par la fonction [type]_coords
+    #
+    # les autres options spécialisées au type seront passés
+    # à la fonction [type]coords
+    #---------------------------------------------------------------------------
+    """
+    pts = None
+
+    if (type == 'roundedrectangle'):
+        log('Coords for roundedrectangle')
+        pts = rounded_rectangle_coords(coords, **options)
+
+    elif (type == 'hippodrome') :
+        log('Coords for hippodrome')
+        pts = hippodrome_coords(coords, **options)
+
+    elif (type == 'ellipse') :
+        log('Coords for ellipse')
+        pts = ellipse_coords(coords, **options)
+
+    elif (type == 'roundedcurve') :
+        log('Coords for roundedcurve')
+        pts = roundedcurve_coords(coords, **options)
+
+    elif (type == 'polygone') :
+        log('Coords for polygone')
+        pts = polygon_coords(coords, **options)
+
+    elif (type == 'polyline') :
+        log('Coords for polyline')
+        pts = polyline_coords(coords, **options)
+    
+    elif (type == 'curveline') :
+        log('Coords for curveline')
+        pts = curveline_coords(coords, **options)
+
+    return pts
+
+
+def zincitem_2_curvecoords( widget, item,
+                            linear = 0,
+                            realcoords = 0,
+                            adjust = 1,
+                            ):
+    """
+    #--------------------------------------------------------------------------
+    # Graphics::zincitem_2_curvecoords
+    # retourne une liste des coordonnées 'Curve' d'un l'item Zinc
+    # rectangle, arc ou curve
+    #--------------------------------------------------------------------------
+    # paramètres :
+    # widget : <widget> identifiant du widget zinc
+    #   item : <tagOrId> identifiant de l'item source
+    # options :
+    #     -linear : <boolean> réduction à des segments non curviligne
+    #               (par défaut 0)
+    # -realcoords : <boolean> coordonnées à transformer dans le groupe père
+    #               (par défaut 0)
+    #     -adjust : <boolean> ajustement de la courbe de bezier (par défaut 1)
+    #--------------------------------------------------------------------------
+    """
+    itemtype = widget.type(item)
+
+    if not itemtype :
+        raise ValueError("Not a Valid Item %s" % item)
+
+    itemcoords = widget.coords(item)
+    coords = None
+    multi = []
+
+    if (itemtype == 'rectangle') :
+        coords = rounded_rectangle_coords(itemcoords, radius = 0)
+
+    elif (itemtype == 'arc') :
+        coords = ellipse_coords(itemcoords)
+        if linear :
+            coords = curve2polyline_coords(coords, adjust) 
+
+    elif (itemtype == 'curve') :
+        numcontours = widget.contour(item)
+
+        if (numcontours < 2) :
+            if linear:
+                coords = curve2polyline_coords(itemcoords, adjust)
+        else :
+            if (linear) :
+                multi = curveitem2polyline_coords(widget, item)
+
+            else :
+                for contour in xrange(0, numcontours):
+                    points = widget.coords(item, contour)
+                    multi.extend(points)
+            coords = multi
+
+    if (realcoords) :
+        parentgroup = widget.group(item)
+        if (len(multi)) :
+            newcoords = []
+            for points in multi :
+                transcoords = widget.transform(item, parentgroup, points)
+                newcoords.extend(transcoords)
+            coords = newcoords
+        else :
+            transcoords =  widget.transform(item, parentgroup, coords)
+            coords = transcoords
+
+    return coords
+
+def rounded_rectangle_coords( coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::rounded_rectangle_coords
+    # calcul des coords du rectangle à coins arrondis
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> coordonnées bbox (haut-gauche et bas-droite)
+    #          du rectangle
+    # options :
+    #  -radius : <dimension> rayon de raccord d'angle
+    # -corners : <booleanList> liste des raccords de sommets
+    #            [0 (aucun raccord)|1] par défaut [1,1,1,1]
+    #---------------------------------------------------------------------------
+    """
+    (x_0, y_0, x_n, y_n) = (coords[0][0], coords[0][1],
+                        coords[1][0], coords[1][1])
+
+    if (options.has_key('radius')):
+        radius = options['radius']
+    else:
+        radius = None
+  
+    if (options.has_key('corners')):
+        corners = options['corners']
+    else:
+        corners = [1, 1, 1, 1]
+
+    # attention aux formes 'négatives'
+    if (x_n < x_0) :
+        (x_0, x_n) = (x_n, x_0)
+      
+    if (y_n < y_0) :
+        (y_0, y_n) = (y_n, y_0)
+
+    height = min(x_n -x_0, y_n - y_0)
+    #radius non defini dans les parametres
+    if (radius is None) :
+        radius = int(height/10)
+        radius = max(radius, 3)
+      
+    #radius defini mais trop petit
+    if ( radius < 2) :
+        return ((x_0, y_0), (x_0, y_n), (x_n, y_n), (x_n, y_0))
+
+    # correction de radius si necessaire
+    max_rad = height
+    #CODE BIZARRE
+    #Comment corners ne peut être non défini
+    #a ce niveau ?
+    #  max_rad /= 2 if (!defined corners)
+    if (corners is None):
+        max_rad /= 2
+    radius = min(max_rad, radius)
+
+    # points remarquables
+    ptd_delta = radius * const_ptd_factor
+    (x_2, x_3) = (x_0 + radius, x_n - radius)
+    (x_1, x_4) = (x_2 - ptd_delta, x_3 + ptd_delta)
+    (y_2, y_3) = (y_0 + radius, y_n - radius)
+    (y_1, y_4) = (y_2 - ptd_delta, y_3 + ptd_delta)
+
+    # liste des 4 points sommet du rectangle : angles sans raccord circulaire
+    angle_pts = ((x_0, y_0), (x_0, y_n), (x_n, y_n), (x_n, y_0))
+
+    # liste des 4 segments quadratique : raccord d'angle = radius
+    roundeds = [[(x_2, y_0), (x_1, y_0, 'c'), (x_0, y_1, 'c'), (x_0, y_2),],
+                [(x_0, y_3), (x_0, y_4, 'c'), (x_1, y_n, 'c'), (x_2, y_n),],
+                [(x_3, y_n), (x_4, y_n, 'c'), (x_n, y_4, 'c'), (x_n, y_3),],
+                [(x_n, y_2), (x_n, y_1, 'c'), (x_4, y_0, 'c'), (x_3, y_0),]]
+
+    pts = []
+    previous = None
+    for i  in xrange(0, 4):
+        #BUGS ??
+        if (corners[i]):
+            if (previous is not None) :
+                # on teste si non duplication de point
+                (nx, ny) = roundeds[i][0]
+                if (previous[0] == nx and previous[1] == ny) :
+                    pts.pop()
+            pts.extend(roundeds[i])
+            previous = roundeds[i][3]
+        else :
+            pts.append(angle_pts[i])
+
+    return pts
+
+def ellipse_coords(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::ellipse_coords
+    # calcul des coords d'une ellipse
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> coordonnées bbox du rectangle exinscrit
+    # options :
+    # -corners : <booleanList> liste des raccords de sommets
+    # [0 (aucun raccord)|1] par défaut [1,1,1,1]
+    #---------------------------------------------------------------------------
+    """
+    (x_0, y_0, x_n, y_n) = (coords[0][0], coords[0][1],
+                        coords[1][0], coords[1][1])
+
+    if options.has_key('corners') :
+        corners = options.has_key('corners')
+    else:
+        corners = [1, 1, 1, 1]
+
+    # attention aux formes 'négatives'
+    if (x_n < x_0) :
+        xs = x_0
+        (x_0, x_n) = (x_n, xs)
+    if (y_n < y_0) :
+        ys = y_0
+        (y_0, y_n) = (y_n, ys)
+
+    # points remarquables
+    delta_x = (x_n - x_0)/2 * const_ptd_factor
+    delta_y = (y_n - y_0)/2 * const_ptd_factor
+    (x_2, y_2) = ((x_0+x_n)/2, (y_0+y_n)/2)
+    (x_1, x_3) = (x_2 - delta_x, x_2 + delta_x)
+    (y_1, y_3) = (y_2 - delta_y, y_2 + delta_y)
+
+    # liste des 4 points sommet de l'ellipse : angles sans raccord circulaire
+    angle_pts = ((x_0, y_0), (x_0, y_n), (x_n, y_n), (x_n, y_0))
+
+    # liste des 4 segments quadratique : raccord d'angle = arc d'ellipse
+    roundeds = (((x_2, y_0), (x_1, y_0, 'c'), (x_0, y_1, 'c'), (x_0, y_2), ),
+                ((x_0, y_2), (x_0, y_3, 'c'), (x_1, y_n, 'c'), (x_2, y_n), ),
+                ((x_2, y_n), (x_3, y_n, 'c'), (x_n, y_3, 'c'), (x_n, y_2), ),
+                ((x_n, y_2), (x_n, y_1, 'c'), (x_3, y_0, 'c'), (x_2, y_0), ))
+
+    pts = []
+    previous = None
+    for i in xrange(0, 4):
+        if (corners[i]) :
+            if (previous) :
+                # on teste si non duplication de point
+                (nx, ny) = roundeds[i][0]
+                if (previous[0] == nx and previous[1] == ny) :
+                    pts.pop()
+            
+            
+            pts.extend(roundeds[i])
+            previous = roundeds[i][3]
+
+        else :
+            pts.append(angle_pts[i])
+
+    return pts
+
+
+def hippodrome_coords(coords, **options) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::hippodrome_coords
+    # calcul des coords d'un hippodrome
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> coordonnées bbox du rectangle exinscrit
+    # options :
+    # -orientation : orientation forcée de l'hippodrome [horizontal|vertical]
+    #     -corners : liste des raccords de sommets [0|1] par défaut [1,1,1,1]
+    #       -trunc : troncatures [left|right|top|bottom|both]
+    #---------------------------------------------------------------------------
+    """
+    (x_0, y_0, x_n, y_n) = (coords[0][0],
+                            coords[0][1],
+                            coords[1][0],
+                            coords[1][1])
+
+    if (options.has_key('orientation')) :
+        orientation = options['orientation']
+    else:
+        orientation = 'none'
+
+    # orientation forcée de l'hippodrome
+    # (sinon hippodrome sur le plus petit coté)
+    if (orientation == 'horizontal') :
+        height = abs(y_n - y_0)
+    elif (orientation == 'vertical') :
+        height = abs(x_n - x_0)
+    else:
+        height = min(abs(x_n - x_0), abs(y_n - y_0))
+    radius = height/2
+    corners = (1, 1, 1, 1)
+
+    if  (options.has_key('corners')) :
+        corners = options['corners']
+
+    elif (options.has_key('trunc')) :
+        trunc = options['trunc']
+        if (trunc == 'both') :
+            return ((x_0, y_0), (x_0, y_n), (x_n, y_n), (x_n, y_0))
+        else :
+            if (trunc == 'left'):
+                corners = (0, 0, 1, 1)
+            elif (trunc == 'right'):
+                corners = (1, 1, 0, 0)
+            elif (trunc == 'top'):
+                corners = (0, 1, 1, 0)
+            elif (trunc == 'bottom') :
+                corners = (1, 0, 0, 1)
+            else :
+                corners = (1, 1, 1, 1)
+
+    # l'hippodrome est un cas particulier de roundedRectangle
+    # on retourne en passant la 'configuration' à la fonction
+    # générique rounded_rectangle_coords
+    return rounded_rectangle_coords(coords,
+                                  radius = radius,
+                                  corners = corners)
+
+def polygon_coords(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::polygon_coords
+    # calcul des coords d'un polygone régulier
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coords> point centre du polygone
+    # options :
+    #      -numsides : <integer> nombre de cotés
+    #        -radius : <dimension> rayon de définition du polygone
+    #                  (distance centre-sommets)
+    #  -inner_radius : <dimension> rayon interne (polygone type étoile)
+    #       -corners : <booleanList> liste des raccords de sommets [0|1]
+    #                  par défaut [1,1,1,1]
+    # -corner_radius : <dimension> rayon de raccord des cotés
+    #    -startangle : <angle> angle de départ en degré du polygone
+    #---------------------------------------------------------------------------
+    """
+    if options.has_key('numsides'):
+        numsides = options['numsides']
+    else :
+        numsides = 0
+    if options.has_key('radius'):
+        radius = options['radius']
+    else:
+        radius = None
+    if (numsides < 3 or not radius) :
+        raise ValueError("Vous devez au moins spécifier "
+                         +"un nombre de cotés >= 3 et un rayon...\n")
+
+    if (coords is None):
+        coords = (0, 0)
+    if (options.has_key('startangle')) :
+        startangle = options['startangle']
+    else:
+        startangle = 0
+    anglestep = 360/numsides
+    if options.has_key('inner_radius'):
+        inner_radius = options['inner_radius']
+    else:
+        inner_radius = None
+    pts = []
+
+    # points du polygone
+    for i in xrange(0, numsides):
+        (xp, yp) = rad_point(coords, radius, startangle + (anglestep*i))
+        pts.append((xp, yp))
+
+        # polygones 'étoiles'
+        if (inner_radius) :
+            (xp, yp) = rad_point(coords, inner_radius,
+                                 startangle + (anglestep*(i+ 0.5)))
+            pts.append((xp, yp))
+    
+    pts.reverse()
+
+    if (options.has_key('corner_radius')) :
+        if options.has_key('corners'):
+            corners = options['corners']
+        else:
+            corners = None
+        return roundedcurve_coords(pts,
+                                   radius = options['corner_radius'],
+                                   corners = corners)
+    else :
+        return pts
+
+
+def rounded_angle(widget, parentgroup, coords, radius) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::rounded_angle
+    # THIS FUNCTION IS NO MORE USED, NEITHER EXPORTED
+    # curve d'angle avec raccord circulaire
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # widget : identifiant du widget Zinc
+    # parentgroup : <tagOrId> identifiant de l'item group parent
+    # coords : <coordsList> les 3 points de l'angle
+    # radius : <dimension> rayon de raccord
+    #---------------------------------------------------------------------------
+    """
+    (pt0, pt1, pt2) = coords
+
+    (corner_pts, center_pts) = rounded_angle_coords(coords, radius)
+    (cx_0, cy_0) = center_pts
+
+    if (parentgroup is None) :
+        parentgroup = 1 
+
+    pts = [pt0]
+    pts.extend(corner_pts)
+    pts.append(pt2)
+    
+    widget.add('curve',
+               parentgroup,
+               lpts2coords(pts),
+               closed = 0,
+               linewidth = 1,
+               priority = 20,
+               )
+
+
+def rounded_angle_coords (coords, radius) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::rounded_angle_coords
+    # calcul des coords d'un raccord d'angle circulaire
+    #---------------------------------------------------------------------------
+    # le raccord circulaire de 2 droites sécantes est traditionnellement
+    # réalisé par un
+    # arc (conique) du cercle inscrit de rayon radius tangent à ces 2 droites
+    #
+    # Quadratique :
+    # une approche de cette courbe peut être réalisée simplement par le calcul
+    # de 4 points
+    # spécifiques qui définiront - quelle que soit la valeur de l'angle formé
+    # par les 2
+    # droites - le segment de raccord :
+    # - les 2 points de tangence au cercle inscrit seront les points de début
+    #   et de fin
+    # du segment de raccord
+    # - les 2 points de controle seront situés chacun sur le vecteur
+    #   reliant le point de
+    # tangence au sommet de l'angle (point secant des 2 droites)
+    # leur position sur ce vecteur peut être simplifiée comme suit :
+    # - à un facteur de 0.5523 de la distance au sommet pour
+    #   un angle >= 90° et <= 270°
+    # - à une 'réduction' de ce point vers le point de tangence
+    #   pour les angles limites
+    # de 90° vers 0° et de 270° vers 360°
+    # ce facteur sera légérement modulé pour recouvrir plus précisement
+    # l'arc correspondant
+    #---------------------------------------------------------------------------
+    # coords : <coordsList> les 3 points de l'angle
+    # radius : <dimension> rayon de raccord
+    #---------------------------------------------------------------------------
+    """
+    (pt0, pt1, pt2) = coords
+
+    # valeur d'angle et angle formé par la bisectrice
+    (angle, bisecangle)  = vertex_angle(pt0, pt1, pt2)
+
+    # distance au centre du cercle inscrit : rayon/sinus demi-angle
+    asin = sin(radians(angle/2))
+    
+    if (asin) :
+        delta = abs(radius / asin)
+    else:
+        delta = radius
+
+    # point centre du cercle inscrit de rayon $radius
+    if (angle < 180) :
+        refangle = bisecangle + 90
+    else :
+        refangle = bisecangle - 90
+        
+    (cx_0, cy_0) = rad_point(pt1, delta, refangle)
+
+    # points de tangeance : pts perpendiculaires du centre aux 2 droites
+    (px_1, py_1) = perpendicular_point((cx_0, cy_0), (pt0, pt1))
+    (px_2, py_2) = perpendicular_point((cx_0, cy_0), (pt1, pt2))
+
+    # point de controle de la quadratique
+    # facteur de positionnement sur le vecteur pt.tangence, sommet
+    ptd_factor =  const_ptd_factor
+    if (angle < 90 or angle > 270) :
+        if (angle < 90) :
+            diffangle = angle
+        else:
+            diffangle =  360 - angle
+        if (diffangle > 15) :
+            ptd_factor -= (((90 - diffangle)/90) * (ptd_factor/4)) 
+        ptd_factor = (diffangle/90) * (ptd_factor
+                                       + ((1 - ptd_factor)
+                                          * (90 - diffangle)/90))
+    else :
+        diffangle = abs(180 - angle)
+        if (diffangle > 15) :
+            ptd_factor += (((90 - diffangle)/90) * (ptd_factor/3))
+
+    # delta xy aux pts de tangence
+    (d1x, d1y) = ((pt1[0] - px_1) * ptd_factor, (pt1[1] - py_1) *  ptd_factor)
+    (d2x, d2y) = ((pt1[0] - px_2) * ptd_factor, (pt1[1] - py_2) *  ptd_factor)
+
+    # les 4 points de l'arc 'quadratique'
+    corner_pts = [(px_1, py_1), (px_1+d1x, py_1+d1y, 'c'),
+                  (px_2+d2x, py_2+d2y, 'c'), (px_2, py_2)]
+
+    
+    # retourne le segment de quadratique et le centre du cercle inscrit
+    return (corner_pts, (cx_0, cy_0))
+
+
+def roundedcurve_coords(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::roundedcurve_coords
+    # retourne les coordonnées d'une curve à coins arrondis
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> liste de coordonnées des points de la curve
+    # options :
+    #  -radius : <dimension> rayon de raccord d'angle
+    #  -corners : <booleanList> liste des raccords de sommets [0|1]
+    # par défaut [1,1,1,1]
+    #---------------------------------------------------------------------------
+    """
+    numfaces = len(coords)
+    curve_pts = []
+
+    if (options.has_key('radius')) :
+        radius = options['radius']
+    else:
+        radius = 0
+    corners = None
+    if options.has_key('corners') :
+        corners = options['corners']
+
+    for index in xrange(numfaces):
+        if (corners is not None) :
+            if (index+1 > len(corners)) or not corners[index] :
+                curve_pts.append(coords[index])
+                continue
+
+        if (index) :
+            prev = index - 1
+        else :
+            prev = numfaces - 1
+        if (index > numfaces - 2) :
+            next = 0
+        else :
+            next = index + 1
+        anglecoords = (coords[prev], coords[index], coords[next])
+            
+        quad_pts = rounded_angle_coords(anglecoords, radius)[0]
+        curve_pts.extend(quad_pts)
+    return curve_pts
+
+
+def polyline_coords(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::polyline_coords
+    # retourne les coordonnées d'une polyline
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> liste de coordonnées des sommets de la polyline
+    # options :
+    #  -radius : <dimension> rayon global de raccord d'angle
+    # -corners : <booleanList> liste des raccords de sommets [0|1]
+    #            par défaut [1,1,1,1],
+    # -corners_radius : <dimensionList> liste des rayons de raccords de sommets
+    #---------------------------------------------------------------------------
+    """
+    numfaces = len(coords)
+    curve_pts = []
+
+    if (options.has_key('radius')) :
+        radius = options['radius']
+    else:
+        radius = 0
+    if options.has_key('corners_radius'):
+        corners_radius = options['corners_radius']
+        corners = corners_radius
+    else:
+        corners_radius = None
+        if options.has_key('corners'):
+            corners = options['corners']
+        else:
+            corners = None
+
+    for index in xrange(0, numfaces):
+        if (corners is not None
+            and (len(corners) - 1 < index
+                 or not corners[index])):
+            curve_pts.append(coords[index])
+        else :
+            if (index) :
+                prev = index - 1
+            else:
+                prev = numfaces - 1
+            if (index > numfaces - 2) :
+                next = 0
+            else:
+                next = index + 1
+            anglecoords = (coords[prev], coords[index], coords[next])
+
+            if (corners_radius) :
+                rad = corners_radius[index]
+            else:
+                rad = radius
+            quad_pts = rounded_angle_coords(anglecoords, rad)[0]
+            curve_pts.extend(quad_pts)
+
+    return curve_pts
+
+def pathline_coords (coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::pathline_coords
+    # retourne les coordonnées d'une pathline
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> liste de coordonnées des points du path
+    # options :
+    #    -closed : <boolean> ligne fermée
+    #  -shifting : <out|center|in> sens de décalage du path (par défaut center)
+    # -linewidth : <dimension> epaisseur de la ligne
+    #---------------------------------------------------------------------------
+    """
+    numfaces = len(coords)
+    pts = []
+
+    if options.has_key('closed'):
+        closed = options['closed']
+    else:
+        closed = None
+    if (options.has_key('linewidth')) :
+        linewidth = options['linewidth']
+    else:
+        linewidth = 2
+          
+    if (options.has_key('shifting')) :
+        shifting = options['shifting']
+    else:
+        shifting = 'center'
+
+    if ( not numfaces or linewidth < 2):
+        raise ValueError("Invalid PathLine_coords")
+
+    if (closed) :
+        previous = coords[numfaces - 1]
+    else:
+        previous = None
+      
+    next = coords[1]
+    if (shifting == 'center'):
+        linewidth /= 2
+
+    for i in xrange(0, numfaces):
+        pt = coords[i]
+
+        if (previous is None) :
+            # extrémité de curve sans raccord -> angle plat
+            previous = (pt[0] + (pt[0] - next[0]), pt[1] + (pt[1] - next[1]))
+
+        (angle, bisecangle) = vertex_angle(previous, pt, next)
+
+        # distance au centre du cercle inscrit : rayon/sinus demi-angle
+        asin = sin(radians(angle/2))
+        if (asin) :
+            delta = abs(linewidth / asin)
+        else:
+            delta = linewidth
+
+        if (shifting == 'out' or shifting == 'in') :
+            if (shifting == 'out') :
+                adding = -90
+            else:
+                adding = 90
+            pts.append(rad_point(pt, delta, bisecangle + adding))
+            pts.append(pt)
+
+        else :
+            pts.append(rad_point(pt, delta, bisecangle-90))
+            pts.append(rad_point(pt, delta, bisecangle+90))
+
+        if (i == numfaces - 2) :
+            if (closed) :
+                next = coords[0]
+            else:
+                next = (coords[i+1][0] + (coords[i+1][0] - pt[0]),
+                        coords[i+1][1] + (coords[i+1][1] - pt[1]))
+        elif (i == numfaces - 1):
+            next = None
+        else :
+            next = coords[i+2]
+    
+        previous = coords[i]
+
+    if (closed) :
+        pts.extend((pts[0], pts[1], pts[2], pts[3]))
+
+    return pts
+
+
+def curveline_coords(coords, **options) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::curveline_coords
+    # retourne les coordonnées d'une curveLine
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> liste de coordonnées des points de la ligne
+    # options :
+    #    -closed : <boolean> ligne fermée
+    #  -shifting : <out|center|in> sens de décalage du contour
+    #              (par défaut center)
+    # -linewidth : <dimension> epaisseur de la ligne
+    #---------------------------------------------------------------------------
+    """
+    numfaces = len(coords)
+    gopts = []
+    backpts = []
+    pts = []
+
+    if options.has_key('closed'):
+        closed = options['closed']
+    else:
+        closed = None
+    if (options.has_key('linewidth')) :
+        linewidth = options['linewidth']
+    else:
+        linewidth = 2
+    if (options.has_key('shifting')) :
+        shifting = options['shifting']
+    else:
+        shifting = 'center'
+
+    if( not numfaces or linewidth < 2):
+        raise ValueError("Bad coords %s or linewidth %s"%(numfaces, linewidth))
+
+    if (closed) :
+        previous = coords[numfaces - 1]
+    else:
+        previous = None
+        
+    next = coords[1]
+    if (shifting == 'center'):
+        linewidth /= 2 
+
+    for i in xrange(0, numfaces):
+        pt = coords[i]
+
+        if ( previous is None ) :
+            # extrémité de curve sans raccord -> angle plat
+            previous = (pt[0] + (pt[0] - next[0]), pt[1] + (pt[1] - next[1]))
+            
+
+        (angle, bisecangle) = vertex_angle(previous, pt, next)
+
+        # distance au centre du cercle inscrit : rayon/sinus demi-angle
+        asin = sin(radians(angle/2))
+        if (asin) :
+            delta = abs(linewidth / asin)
+        else:
+            delta = linewidth
+
+        if (shifting == 'out' or shifting == 'in') :
+            if (shifting == 'out') :
+                adding = -90
+            else:
+                adding = 90
+            pts.append(rad_point(pt, delta, bisecangle + adding))
+            pts.append(pt)
+
+        else :
+            pts = rad_point(pt, delta, bisecangle+90)
+            gopts.append(pts)
+            pts = rad_point(pt, delta, bisecangle-90)
+            backpts.insert(0, pts)
+
+        if (i == numfaces - 2) :
+            if (closed) :
+                next = coords[0]
+            else:
+                next = (coords[i+1][0] +
+                        (coords[i+1][0] - pt[0]), coords[i+1][1]
+                        + (coords[i+1][1] - pt[1]))
+        else :
+            next = coords[i+2]
+
+        previous = coords[i]
+
+    gopts.extend(backpts)
+
+    if (closed) :
+        gopts.extend ((gopts[0], gopts[1]))
+
+    return gopts
+
+
+def shiftpath_coords(coords, **options) :
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::shiftpath_coords
+    # retourne les coordonnées d'un décalage de path
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordsList> liste de coordonnées des points du path
+    # options :
+    #   -closed : <boolean> ligne fermée
+    # -shifting : <'out'|'in'> sens de décalage du path (par défaut out)
+    #    -width : <dimension> largeur de décalage (par défaut 1)
+    #---------------------------------------------------------------------------
+    """
+    numfaces = len(coords)
+
+    if options.has_key('closed'):
+        closed = options['closed']
+    else:
+        closed = None
+    if (options.has_key('width')) :
+        width = options['width']
+    else:
+        width = 1
+    if (options.has_key('shifting')) :
+        shifting = options['shifting']
+    else:
+        shifting = 'out'
+
+    if (not numfaces or not width):
+        return coords 
+
+    pts = []
+    
+    if (closed) :
+        previous = coords[numfaces - 1]
+    else:
+        previous = None
+    next = coords[1]
+
+    for i in xrange(0, numfaces):
+        pt = coords[i]
+
+        if ( previous is None ) :
+            # extrémité de curve sans raccord -> angle plat
+            previous = (pt[0] + (pt[0] - next[0]), pt[1] + (pt[1] - next[1]))
+            
+
+        (angle, bisecangle) = vertex_angle(previous, pt, next)
+
+        # distance au centre du cercle inscrit : rayon/sinus demi-angle
+        asin = sin(radians(angle/2))
+        if (asin) :
+            delta = abs(width / asin)
+        else:
+            delta = width
+
+        if (shifting == 'out') :
+            adding = -90
+        else:
+            adding = 90
+        (x, y) = rad_point(pt, delta, bisecangle + adding)
+        pts.append((x, y))
+
+
+        if (i > numfaces - 3) :
+            if (closed) :
+                next = coords[0]
+            else:
+                next = (pt[0] + (pt[0] - previous[0]),
+                        pt[1] + (pt[1] - previous[1]))
+
+        else :
+            next = coords[i+2]
+
+        previous = coords[i]
+
+    return pts
+
+
+
+
+def curveitem2polyline_coords(widget, item, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::curveitem2polyline_coords
+    # Conversion des coordonnées Znitem curve (multicontours)
+    # en coordonnées polyline(s)
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # widget : <widget> identifiant du widget zinc
+    #   item : <tagOrId> identifiant de l'item source
+    # options :
+    # -tunits : <integer> nombre pas de division des segments bezier
+    #           (par défaut 20)
+    # -adjust : <boolean> ajustement de la courbe de bezier (par défaut 1)
+    #---------------------------------------------------------------------------
+    """
+    if (not widget.type(item)):
+        raise ValueError("Item Not Found")
+    coords = []
+    numcontours = widget.contour(item)
+    #parentgroup = widget.group(item)
+
+    for contour in xrange(0, numcontours):
+        points = widget.coords(item, contour)
+        contourcoords = curve2polyline_coords(points, **options)
+
+        coords.append(contourcoords)
+
+    return coords
+
+def curve2polyline_coords(points, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::curve2polyline_coords
+    # Conversion curve -> polygone
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # points : <coordsList> liste des coordonnées curve à transformer
+    # options :
+    # -tunits : <integer> nombre pas de division des segments bezier
+    #           (par défaut 20)
+    # -adjust : <boolean> ajustement de la courbe de bezier (par défaut 1)
+    #---------------------------------------------------------------------------
+    """
+    if (options.has_key('tunits')) :
+        tunits = options['tunits']
+    else:
+        tunits = 20
+    if (options.has_key('adjust')) :
+        adjust = options['adjust']
+    else:
+        adjust = 1
+
+    poly = []
+    previous = None
+    bseg = []
+    numseg = 0
+    #prevtype = None
+
+    for point in points:
+        if len(point) == 3:
+            (x, y, c) = point
+        elif len(point) == 2:
+            (x, y, c) = (point, None)
+        else:
+            ValueError("Bad point")
+        if (c == 'c') :
+            if not len(bseg) and previous:
+                bseg.append(previous)
+            bseg.append(point)
+            
+        else :
+            if (len (bseg)) :
+                bseg.append(point)
+                if (adjust) :
+                    pts = bezier_compute(bseg, skipend = 1)
+                    del pts[0]
+                    del pts[0]
+                    poly.extend(pts)
+                     
+                else :
+                    pts = bezier_segment(bseg, tunits = tunits, skipend = 1)
+                    del pts[0]
+                    del pts[0]
+                    poly.extend(pts)
+
+                bseg = []
+                numseg += 1
+                #prevtype = 'bseg'
+
+            else :
+                poly.append((x, y))
+                #prevtype = 'line'
+
+        previous = point
+
+
+    return poly
+
+
+def build_tabboxitem(widget, parentgroup, **options):
+    """
+    #-------------------------------------------------------------------------------
+    # Graphics::build_tabboxitem
+    # construit les items de représentations Zinc d'une boite à onglets
+    #-------------------------------------------------------------------------------
+    # paramètres :
+    #      widget : <widget> identifiant du widget zinc
+    # parentgroup : <tagOrId> identifiant de l'item group parent
+    #
+    #    options :
+    #     -coords : <coordsList> coordonnées haut-gauche et bas-droite
+    #               du rectangle
+    #               englobant du Tabbox
+    #     -params : <hastable> arguments spécifiques des items curve
+    #               à passer au widget
+    #    -texture : <imagefile> ajout d'une texture aux items curve
+    #  -tabtitles : <hashtable> table de hash de définition des titres onglets
+    #  -pageitems : <hashtable> table de hash de définition des pages internes
+    #     -relief : <hashtable> table de hash de définition du relief de forme
+    #
+    # (options de construction géometrique passées à tabbox_coords)
+    #  -numpages : <integer> nombre de pages (onglets) de la boite
+    #    -anchor : <'n'|'e'|'s'|'w'> ancrage (positionnement) de la ligne
+    #              d'onglets
+    # -alignment : <'left'|'center'|'right'> alignement des onglets sur le coté
+    #              d'ancrage
+    #  -tabwidth : <'auto'>|<dimension>|<dimensionList> : largeur des onglets
+    #              'auto' largeur répartie, les largeurs sont auto-ajustée
+    #              si besoin.
+    # -tabheight : <'auto'>|<dimension> : hauteur des onglets
+    #  -tabshift : <'auto'>|<dimension> offset de 'biseau' entre base et haut de
+    #              l'onglet (défaut auto)
+    #    -radius : <dimension> rayon des arrondis d'angle
+    #   -overlap : <'auto'>|<dimension> offset de recouvrement/séparation entre
+    #              onglets
+    #   -corners : <booleanList> liste 'spécifique' des raccords de sommets [0|1]
+    #---------------------------------------------------------------------------
+    """
+    if options.has_key('coords') :
+        coords = options['coords']
+    else:
+        raise ValueError("Coords needed")
+    if options.has_key('params'):
+        params = options['params']
+    else:
+        params = {}
+    if params.has_key('tags'):
+        tags = params['tags']
+    else :
+        tags = []
+    texture = None
+
+    if (options.has_key('texture')) :
+        texture = get_texture(widget,
+                             options['texture'])
+        
+
+    if options.has_key('tabtitles'):
+        titlestyle = options['tabtitles']
+    else :
+        titlestyle = None
+    if (titlestyle) :
+        titles = titlestyle['text']
+    else:
+        titles = None
+
+    tabs = []
+    (shapes, tcoords, invert) = tabbox_coords(**options)
+    if (invert) :
+        k = len(shapes)
+    else:
+        k = -1
+    shapes.reverse()
+    for shape in shapes :
+        if (invert) :
+            k -= 1
+        else :
+            k += +1
+        group = widget.add('group', parentgroup)
+        params['tags'] = tags
+        params['tags'] += (k, 'intercalaire')
+        form = widget.add('curve',
+                          group,
+                          lpts2coords(shape),
+                          **params)
+        if texture :
+            widget.itemconfigure(form, tile = texture)
+
+        if (options.has_key('relief')) :
+            graphicitem_relief(widget, form, **options['relief'])
+            
+
+        if (options.has_key('page')) :
+            build_zinc_item(widget, group, **options['page'])
+    
+        if (titles) :
+            if (invert) :
+                tindex = k
+            else:
+                tindex = len(shapes) - k
+            titlestyle['itemtype'] = 'text'
+            titlestyle['coords'] = tcoords[tindex]
+            titlestyle['params']['text'] = titles[tindex]
+            ltags = list(tags)
+            ltags.append(tindex)
+            ltags.append('titre')
+            titlestyle['params']['tags'] = tuple(ltags)
+            build_zinc_item(widget, group, **titlestyle)
+
+    return tabs
+
+
+def tabbox_coords(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # tabbox_coords
+    # Calcul des shapes de boites à onglets
+    #---------------------------------------------------------------------------
+    # paramètres :
+    # coords : <coordList> coordonnées haut-gauche bas-droite du rectangle
+    #          englobant de la tabbox
+    # options
+    #  -numpages : <integer> nombre de pages (onglets) de la boite
+    #    -anchor : <'n'|'e'|'s'|'w'> ancrage (positionnement) de la
+    #              ligne d'onglets
+    # -alignment : <'left'|'center'|'right'> alignement des onglets
+    #              sur le coté d'ancrage
+    #  -tabwidth : <'auto'>|<dimension>|<dimensionList> : largeur des onglets
+    #              'auto' largeur répartie, les largeurs sont auto-ajustée
+    #               si besoin.
+    # -tabheight : <'auto'>|<dimension> : hauteur des onglets
+    #  -tabshift : <'auto'>|<dimension> offset de 'biseau' entre base et haut
+    #              de l'onglet (défaut auto)
+    #    -radius : <dimension> rayon des arrondis d'angle
+    #   -overlap : <'auto'>|<dimension> offset de recouvrement/séparation
+    #              entre onglets
+    #   -corners : <booleanList> liste 'spécifique' des raccords
+    #              de sommets [0|1]
+    #---------------------------------------------------------------------------
+    """
+    (x_0, y_0) = coords[0]
+    (x_n, y_n) = coords[1]
+    shapes, titles_coords = [], []
+    inverse = None
+
+    #loptions = options.keys()
+    if options.has_key('numpages'):
+        numpages = options['numpages']
+    else:
+        numpages = 0
+    
+    if (not x_0 or not y_0 or not x_n or not y_n or not numpages) :
+        raise ValueError("Vous devez au minimum spécifier\
+        le rectangle englobant et le nombre de pages")
+
+    if (options.has_key('anchor')) :
+        anchor = options['anchor']
+    else:
+        anchor = 'n'
+    if (options.has_key('alignment')) :
+        alignment = options['alignment']
+    else:
+        alignment ='left'
+
+
+    if (options.has_key('tabwidth')) :
+        nlen = options['tabwidth']
+    else:
+        nlen ='auto'
+    if (options.has_key('tabheight')) :
+        thick = options['tabheight']
+    else:
+        thick ='auto'
+    if (options.has_key('tabshift')) :
+        biso = options['tabshift']
+    else:
+        biso = 'auto'
+    if (options.has_key('radius')) :
+        radius = options['radius']
+    else:
+        radius = 0
+    if (options.has_key('overlap')) :
+        overlap = options['overlap']
+    else:
+        overlap = 0
+    if (options.has_key('corners')):
+        corners = options['corners']
+    else:
+        corners = None
+    if (anchor in ( 'n', 's')) :
+        orientation = 'horizontal'
+    else:
+        orientation = 'vertical'
+    if (orientation == 'horizontal') :
+        maxwidth = (x_n - x_0)
+    else:
+        maxwidth = (y_n - y_0)
+    tabswidth = 0
+    align = 1
+
+    if (nlen == 'auto') :
+        tabswidth = maxwidth
+        nlen = float(tabswidth + (overlap * (numpages - 1)))/numpages
+    else :
+        if (type(nlen) in (types.TupleType, types.ListType )) :
+            for w in nlen :
+                tabswidth += (w - overlap)
+      
+            tabswidth += overlap
+        else :
+            tabswidth = (nlen * numpages) - (overlap * (numpages - 1))
+    
+
+        if (tabswidth > maxwidth) :
+            tabswidth = maxwidth
+            nlen = float(tabswidth + (overlap * (numpages - 1)))/numpages
+
+        if (alignment == 'center' and ((maxwidth - tabswidth) > radius)):
+            align = 0 
+
+
+    if (thick == 'auto') :
+        if (orientation == 'horizontal') :
+            thick = int((y_n - y_0)/10)
+        else:
+            thick = int((x_n - y_0)/10)
+        thick = max(10, thick) 
+        thick = min(40, thick)
+
+    if (biso == 'auto') :
+        biso = int(thick/2)
+
+    if ((alignment == 'right' and anchor != 'w') or
+        (anchor == 'w' and alignment != 'right')) :
+
+        if (type(nlen) in (types.TupleType, types.ListType)) :
+            for p in xrange(0, numpages):
+                nlen[p] *= -1
+        else :
+            nlen *= -1
+        biso *= -1
+        overlap *= -1
+
+    if (alignment == 'center') :
+        (biso1, biso2) = (biso/2, biso/2)
+    else:
+        (biso1, biso2) = (0, biso)
+
+    cadre, tabdxy = [], []
+    xref, yref = 0, 0
+    if (orientation == 'vertical') :
+        if (anchor == 'w'):
+            thick *= -1 
+        if (anchor == 'w') :
+            (startx, endx) = (x_0, x_n)
+        else:
+            (startx, endx) = (x_n, x_0)
+        if ((anchor == 'w' and alignment != 'right') or 
+            (anchor == 'e' and alignment == 'right')) :
+            (starty, endy) = (y_n, y_0)
+        else:
+            (starty, endy) = (y_0, y_n)
+
+        xref = startx - thick
+        yref = starty
+        if  (alignment == 'center') :
+            if (anchor == 'w') :
+                ratio = -2
+            else:
+                ratio = 2
+            yref += (float(maxwidth - tabswidth)/ratio)
+
+        cadre = ((xref, endy), (endx, endy), (endx, starty), (xref, starty))
+
+        # flag de retournement de la liste des pts de curve si nécessaire
+        # -> sens anti-horaire
+        inverse = (alignment == 'right')
+
+    else :
+        if (anchor == 's'):
+            thick *= -1
+            (starty, endy) = (y_n, y_0)
+        else :
+            (starty, endy) = (y_0, y_n)
+            
+        if (alignment == 'right') :
+            (startx, endx) = (x_n, x_0)
+        else:
+            (startx, endx) = (x_0, x_n)
+
+
+        yref = starty + thick
+        if (alignment == 'center') :
+            xref = x_0 + (float(maxwidth - tabswidth)/2)
+        else :
+            xref = startx
+
+        cadre = ((endx, yref), (endx, endy), (startx, endy), (startx, yref))
+
+        # flag de retournement de la liste des pts de curve si nécessaire
+        # -> sens anti-horaire
+        inverse = ((anchor == 'n' and alignment != 'right')
+                   or (anchor == 's' and alignment == 'right'))
+         
+        
+    for i in xrange(0, numpages):
+        pts = []
+
+        # décrochage onglet
+        #push (pts, ([xref, yref])) if i > 0
+
+        # cadre
+        pts.extend(cadre)
+
+        # points onglets
+        if (i > 0 or not align) :
+            pts.append((xref, yref)) 
+
+        if (type(nlen) in (types.TupleType, types.ListType)) :
+            tw = nlen[i]
+        else:
+            tw = nlen
+
+        if (type(nlen) in (types.TupleType, types.ListType)) :
+            slen = len(nlen)
+        else:
+            slen = nlen
+        
+        if (orientation == 'vertical') :
+            tabdxy = ((thick, biso1), (thick, tw - biso2), (0, tw))
+        else:
+            tabdxy = ((biso1, -thick), (tw - biso2, -thick), (tw, 0))
+        for delta_xy in tabdxy :
+            pts.append((xref + delta_xy[0], yref + delta_xy[1]))
+    
+
+        if (radius) :
+            if (not options.has_key('corners')) :
+                if (i > 0 or not align) :
+                    corners =  (0, 1, 1, 0, 0, 1, 1, 0)
+                else :
+                    corners = (0, 1, 1, 0, 1, 1, 0, 0, 0)
+      
+            curvepts = roundedcurve_coords(pts,
+                                          radius = radius,
+                                          corners = corners)
+            lcurvepts = list(curvepts)
+            if (inverse):
+                lcurvepts.reverse()
+            shapes.append(lcurvepts)
+        else :
+            if (inverse):
+                pts.reverse()
+            shapes.append(pts)
+
+        if (orientation == 'horizontal') :
+            titles_coords.append((float(xref) + (tw - (biso2 - biso1))/2,
+                                  float(yref) - (thick/2)))
+            xref += (tw - overlap)
+
+        else :
+            titles_coords.append( (float(xref) + (thick/2),
+                                   yref + (slen - ((biso2 - biso1)/2))/2))
+            yref += (slen - overlap)
+            
+    return (shapes, titles_coords, inverse)
+
+
+def graphicitem_relief(widget, item, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::graphicitem_relief
+    # construit un relief à l'item Zinc en utilisant des items Triangles
+    #---------------------------------------------------------------------------
+    # paramètres :
+    #  widget : <widget> identifiant du widget zinc
+    #    item : <tagOrId> identifiant de l'item zinc
+    # options : <hash> table d'options
+    #     -closed : <boolean> le relief assure la fermeture de forme (défaut 1)
+    #     -profil : <'rounded'|'flat'> type de profil (defaut 'rounded')
+    #     -relief : <'raised'|'sunken'> (défaut 'raised')
+    #       -side : <'inside'|'outside'> relief interne ou externe à la forme
+    #               (défaut 'inside')
+    #      -color : <color> couleur du relief (défaut couleur de la forme)
+    #   -smoothed : <boolean> facettes relief lissées ou non (défaut 1)
+    # -lightangle : <angle> angle d'éclairage (défaut valeur générale widget)
+    #      -width : <dimension> 'épaisseur' du relief en pixel
+    #       -fine : <boolean> mode précision courbe de bezier
+    #               (défaut 0 : auto-ajustée)
+    #-------------------------------------------------------------------------------
+    """
+    items = []
+
+    # relief d'une liste d'items -> appel récursif
+    if (type(item) in (types.TupleType, types.ListType)) :
+        for part in item :
+            items.extend(graphicitem_relief(widget, part, **options))
+    else :
+        itemtype = widget.type(item)
+        if not itemtype:
+            raise ValueError("Bad Item")
+
+        parentgroup = widget.group(item)
+        if (options.has_key('priority')) :
+            priority = options['priority']
+        else :
+            priority = widget.itemcget(item, 'priority')+1
+
+        # coords transformés (polyline) de l'item
+        adjust = not options['fine']
+        for coords in zincitem_2_curvecoords(widget,
+                                           item, linear = 1,
+                                           realcoords = 1,
+                                           adjust = adjust) :
+            (pts, colors) = polyline_relief_params(widget,
+                                                 item,
+                                                 coords,
+                                                 **options)
+
+            items.append(widget.add('triangles',
+                                    parentgroup,
+                                    pts,
+                                    priority = priority,
+                                    colors = colors))
+
+
+        # renforcement du contour
+        if (widget.itemcget(item, 'linewidth')) :
+            items.append(widget.clone(item,
+                                      filled = 0,
+                                      priority = priority+1))
+
+    return items
+
+
+def polyline_relief_params(widget, item, coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::polyline_relief_params
+    # retourne la liste des points et des couleurs nécessaires à la construction
+    # de l'item Triangles du relief
+    #---------------------------------------------------------------------------
+    # paramètres :
+    #  widget : <widget> identifiant widget Zinc
+    #    item : <tagOrId> identifiant item Zinc
+    # options : <hash> table d'options
+    #     -closed : <boolean> le relief assure la fermeture de forme (défaut 1)
+    #     -profil : <'rounded'|'flat'> type de profil (defaut 'rounded')
+    #     -relief : <'raised'|'sunken'> (défaut 'raised')
+    #       -side : <'inside'|'outside'> relief interne ou externe à la forme
+    #               (défaut 'inside')
+    #      -color : <color> couleur du relief (défaut couleur de la forme)
+    #   -smoothed : <boolean> facettes relief lissées ou non (défaut 1)
+    # -lightangle : <angle> angle d'éclairage (défaut valeur générale widget)
+    #      -width : <dimension> 'épaisseur' du relief en pixel
+    #---------------------------------------------------------------------------
+    """
+
+    if (options.has_key('closed')) :
+        closed = options['closed']
+    else:
+        closed = 1
+    if (options.has_key('profil')) :
+        profil = options['profil']
+    else:
+        profil = 'rounded'
+    if (options.has_key('relief')) :
+        relief = options['relief']
+    else :
+        relief = 'raised'
+    if (options.has_key('side')) :
+        side = options['side']
+    else:
+        side = 'inside'
+    if (options.has_key('color')) :
+        basiccolor = options['color']
+    else:
+        basiccolor = zincitem_predominantcolor(widget, item)
+    if (options.has_key('smooth')) :
+        smoothed = options['smooth']
+    else:
+        smoothed = 1
+    if (options.has_key('lightangle')) :
+        lightangle = options['lightangle']
+    else:
+        lightangle = widget.cget('lightangle')
+
+    if options.has_key('width'):
+        width = options['width']
+    else:
+        raise ValueError('Options must have width field')
+    if ( width < 1) :
+        (x_0, y_0, x_1, y_1) = widget.bbox(item)
+        width = min(x_1 -x_0, y_1 - y_0)/10
+        if (width < 2) :
+            width = 2
+
+    numfaces = len(coords)
+    if (closed):
+        previous = coords[numfaces - 1]
+    else:
+        previous = None
+    next = coords[1]
+
+    pts = []
+    colors = []
+    alpha = 100
+    m = re.compile("^(?P<color>#[0-9a-fA-F]{6});(?P<alpha>\d{1,2})$")
+    res = m.match(basiccolor)
+    if (res is not None) :
+        (basiccolor, alpha) = res.group('color'), res.group('alpha')
+
+    if ( options.has_key('color')):
+        color = options['color']
+        res = m.match(color)
+        if ((res is None) and (profil == 'flat')):
+            alpha /= 2
+
+    if (profil == 'rounded') :
+        reliefalphas = [0, alpha]
+    else:
+        reliefalphas = [alpha, alpha]
+
+    for i in xrange(0, numfaces):
+        pt = coords[i]
+
+        if (previous) :
+            # extrémité de curve sans raccord -> angle plat
+            previous = (pt[0] + (pt[0] - next[0]), pt[1] + (pt[1] - next[1]))
+    
+
+        (angle, bisecangle) = vertex_angle(previous, pt, next)
+
+        # distance au centre du cercle inscrit : rayon/sinus demi-angle
+        asin = sin(radians(angle/2))
+        if (asin) :
+            delta = abs(width / asin)
+        else:
+            delta = width
+        if (side == 'outside') :
+            decal = -90
+        else:
+            decal = 90
+
+        shift_pt = rad_point(pt, delta, bisecangle+decal)
+        pts.append(shift_pt)
+        pts.append(pt)
+
+        if (smoothed and i) :
+            pts.append(shift_pt)
+            pts.append(pt)
+    
+
+        faceangle = 360 -(linenormal(previous, next)+90)
+
+        light = abs(lightangle - faceangle)
+        if (light > 180):
+            light = 360 - light
+        if light < 1:
+            light = 1 
+
+        if (relief == 'sunken') :
+            lumratio = (180-light)/180
+        else:
+            lumratio = light/180
+
+        if ( not smoothed and i) :
+            #A VOIR
+            #OBSCURE
+            colors.extend((colors[-2], colors[-1]))
+
+        if (basiccolor) :
+            # création des couleurs dérivées
+            shade = lightingcolor(basiccolor, lumratio)
+            color0 = "%s;%s"% (shade, reliefalphas[0])
+            color1 = "%s;%s"% (shade, reliefalphas[1])
+            colors.extend((color0, color1))
+
+        else :
+            c = (255*lumratio)
+            color0 = hexargbcolor(c, c, c, reliefalphas[0])
+            color1 = hexargbcolor(c, c, c, reliefalphas[1])
+            colors.extend((color0, color1))
+    
+
+        if (i == (numfaces - 2)) :
+            if (closed) :
+                next = coords[0]
+            else:
+                next = (coords[i+1][0] + (coords[i+1][0] - pt[0]),
+                        coords[i+1][1] + (coords[i+1][1] - pt[1]))
+        else :
+            next = coords[i+2]
+
+        previous = coords[i]
+
+    if (closed) :
+        pts.extend((pts[0], pts[1], pts[2], pts[3]))
+        colors.extend((colors[0], colors[1]))
+
+        if (not smoothed) :
+            pts.extend((pts[0], pts[1], pts[2], pts[3]))
+            colors.extend((colors[0], colors[1]))
+    
+    return (pts, colors)
+
+
+def graphicitem_shadow(widget, item, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::graphicitem_shadow
+    # Création d'une ombre portée à l'item
+    #---------------------------------------------------------------------------
+    # paramètres :
+    #  widget : <widget> identifiant widget Zinc
+    #    item : <tagOrId> identifiant item Zinc
+    # options : <hash> table d'options
+    #    -opacity : <percent> opacité de l'ombre (défaut 50)
+    #     -filled : <boolean> remplissage totale de l'ombre (hors bordure) (defaut 1)
+    # -lightangle : <angle> angle d'éclairage (défaut valeur générale widget)
+    #   -distance : <dimension> distance de projection de l'ombre en pixel
+    #  -enlarging : <dimension> grossi de l'ombre portée en pixels (defaut 0)
+    #      -width : <dimension> taille de diffusion/diffraction (défaut 4)
+    #      -color : <color> couleur de l'ombre portée (défaut black)
+    #---------------------------------------------------------------------------
+    """
+    items = []
+
+    # relief d'une liste d'items -> appel récursif
+    if (type(item) in (types.TupleType, types.ListType)) :
+        for part in item :
+            items.append(graphicitem_shadow(widget, part, **options))
+        return items
+
+    else :
+
+        itemtype = widget.type(item)
+
+        if not itemtype :
+            raise ValueError("Not a valid Item Id %s"%item)
+
+        # création d'un groupe à l'ombre portée
+        if (options.has_key('parentgroup')) :
+            parentgroup = options['parentgroup']
+        else:
+            parentgroup = widget.group(item)
+        if (options.has_key('priority')) :
+            priority = options['priority']
+        else:
+            priority = widget.itemcget(item, 'priority')-1
+        priority = max(0, priority) 
+
+        shadow = widget.add('group', parentgroup, priority = priority)
+            
+        if (itemtype == 'text') :
+            if (options.has_key('opacity')) :
+                opacity = options['opacity']
+            else:
+                opacity = 50
+            if (options['color']) :
+                color = options['color']
+            else:
+                color = '#000000'
+            
+            clone = widget.clone(item, color = "%s;%s"% (color, opacity))
+            widget.chggroup(clone, shadow)
+
+        else :
+
+            # création des items (de dessin) de l'ombre
+            if ( options.has_key('filled')) :
+                filled = options['filled']
+            else:
+                filled = 1
+      
+            # coords transformés (polyline) de l'item
+            for coords in zincitem_2_curvecoords(widget,
+                                               item,
+                                               linear = 1,
+                                               realcoords = 1) :
+                (t_pts, i_pts, colors) = polyline_shadow_params( coords,
+                                                               **options)
+                
+                # option filled : remplissage hors bordure
+                # de l'ombre portée (item curve)
+                if (filled) :
+                    if (len(items)) :
+                        widget.contour(items[0], 'add', 0, i_pts)
+	
+                    else :
+                        items.append( widget.add('curve', shadow, i_pts,
+                                                  linewidth = 0,
+                                                  filled = 1,
+                                                  fillcolor = colors[0],
+                                                  ))
+                        
+                # bordure de diffusion de l'ombre (item triangles)
+                items.append( widget.add('triangles', shadow, t_pts,
+                                          colors = colors))
+      
+
+        # positionnement de l'ombre portée
+        if (options.has_key('distance')) :
+            distance = options['distance']
+        else:
+            distance = 10
+        if (options.has_key('lightangle')) :
+            lightangle = options['lightangle']
+        else:
+            lightangle = widget.cget('lightangle')
+
+        (delta_x, delta_y) = rad_point((0, 0),
+                             distance,
+                             lightangle+180)
+        widget.translate(shadow, delta_x, -delta_y)
+
+    return shadow
+
+
+def polyline_shadow_params(coords, **options):
+    """
+    #---------------------------------------------------------------------------
+    # Graphics::polyline_shadow_params
+    # retourne les listes des points et de couleurs nécessaires à la 
+    # construction des items triangles (bordure externe) et curve
+    # (remplissage interne) de l'ombre portée
+    #---------------------------------------------------------------------------
+    # paramètres :
+    #    coords : coordonnées
+    # options : <hash> table d'options
+    #    -opacity : <percent> opacité de l'ombre (défaut 50)
+    # -lightangle : <angle> angle d'éclairage (défaut valeur générale widget)
+    #   -distance : <dimension> distance de projection de l'ombre en pixel
+    #               (défaut 10)
+    #  -enlarging : <dimension> grossi de l'ombre portée en pixels (defaut 2)
+    #      -width : <dimension> taille de diffusion/diffraction
+    #               (défaut distance -2)
+    #      -color : <color> couleur de l'ombre portée (défaut black)
+    #---------------------------------------------------------------------------
+    """
+    if (options.has_key('distance')) :
+        distance = options['distance']
+    else:
+        distance = 10
+    if (options.has_key('width')) :
+        width = options['width']
+    else:
+        width = distance-2
+    if (options.has_key('opacity')) :
+        opacity = options['opacity']
+    else:
+        opacity = 50
+    if (options.has_key('color')) :
+        color = options['color']
+    else:
+        color ='#000000'
+    if (options.has_key('enlarging')) :
+        enlarging = options['enlarging']
+    else :
+        enlarging = 2
+
+    if (enlarging) :
+        coords = shiftpath_coords(coords,
+                                 width = enlarging,
+                                 closed = 1,
+                                 shifting = 'out')
+
+    numfaces = len(coords)
+    previous = coords[numfaces - 1]
+    next = coords[1]
+
+    t_pts = []
+    i_pts = []
+    colors = []
+    (color0, color1) = ("%s;%s"% (color, opacity), "%s;0"% color)
+
+    for i in xrange(0, numfaces):
+        pt = coords[i]
+
+        #A VOIR
+        #Je ne vois pas quand cela peut arriver
+        if (not previous) :
+            # extrémité de curve sans raccord -> angle plat
+            previous = (pt[0] + (pt[0] - next[0]), pt[1] + (pt[1] - next[1]))
+
+        (angle, bisecangle) = vertex_angle(previous, pt, next)
+
+        # distance au centre du cercle inscrit : rayon/sinus demi-angle
+        asin = sin(radians(angle/2))
+        if (asin) :
+            delta = abs(width / asin)
+        else :
+            delta =  width
+        decal = 90
+
+        shift_pt = rad_point(pt, delta, bisecangle+decal)
+        i_pts.append(shift_pt)
+        t_pts.append(shift_pt)
+        t_pts.append(pt)
+        
+        colors.append(color0)
+        colors.append(color1)
+        if (i == numfaces - 2) :
+            next = coords[0]
+        else :
+            next = coords[i+2]
+
+        previous = coords[i]
+
+    # fermeture
+    t_pts.extend((t_pts[0], t_pts[1], t_pts[2], t_pts[3]))
+    i_pts.extend((t_pts[0], t_pts[1]))
+    colors.extend((color0, color1, color0, color1))
+
+    return (t_pts, i_pts, colors)
+
+
+
+
+
+#Local Variables:
+#mode : python
+#tab-width: 4
+#end: