aboutsummaryrefslogtreecommitdiff
path: root/Python/build/lib.linux-x86_64-2.7/Zinc/graphics.py
diff options
context:
space:
mode:
Diffstat (limited to 'Python/build/lib.linux-x86_64-2.7/Zinc/graphics.py')
-rwxr-xr-xPython/build/lib.linux-x86_64-2.7/Zinc/graphics.py2351
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: