DESCRIPTION.

Créer un nouveau controle de type zone de dessin, ou toile (widget : tkinter.Canvas ( )).

SYNTAXE.

CAN_Toile = tkinter.Canvas ( parent , attribut1 = valeur , ... , attributn = valeur )

CAN_Toile = ⇨ affectation de l'instance du controle [ optionnel ]

tkinter.Canvas ( ) ⇨ création d'une instance de tkinter.Canvas ( ) [ OBLIGATOIRE ]

parent ⇨ conteneur de l'instance de tkinter.Canvas ( ) [ OBLIGATOIRE ]

attribut = valeur ⇨ attribut à modifier avec sa nouvelle valeur [ optionnel ]

REMARQUES.

Les classes tkinter.Canvas ( ) et tkinter.Text ( ) du module tkinter sont des classes produisant des super controles.

Les zones de dessin, ou toiles, créées avec la classe tkinter.Canvas ( ) sont de véritables "petits" créateurs graphiques, qui peuvent aussi être considérés comme des conteneurs spéciaux. Dotés de nombreux types éléments graphiques, allant des simples lignes aux figures géométriques complexes, ils peuvent aussi recevoir et placer finement des textes, ainsi que tous les autres types de controles de tkinter. 

Un objet créé avec la classe tkinter.Canvas ( ) pourra contenir :

- des lignes droites ou brisées avec sa méthode create_line ( ) ;

- des carrés ou des rectangles avec sa méthode create_rectangle ( ) ;

- des cercles, des ronds et des ellipses avec sa méthode create_oval ( ) ;

- des figures géométriques plus ou moins complexes avec sa méthode create_polygon ( ) ;

- des courbes , des portions de cercle ou d'ellipse avec sa méthode create_arc ( ) ;

- des textes formatés et mis en forme avec sa méthode create_text ( ) ;

- des images monochromes avec sa méthode create_bitmap ( ) ;

- des images couleurs importer de fichiers avec sa méthode create_image ( ) ;

- des controles, dans un ou des conteneurs, pour agir activement avec sa méthode create_window ( ).

Chacun de ces éléments sera détaillé dans la partie traitant de son type, par exemple l'utilisation de lignes sera taillée dans la méthode create_line ( ) de tkinter.Canvas ( ).

Les objets permanents de type tkinter.Canvas ( ) sont identifiés dans le site par : CAN_. 

Voir les conventions sur les variables utilisées dans ce site ...

CREATION D'UNE ZONE DE DESSIN.

Les zones de dessin, ou toiles, sont crées comme tous les autres controle de tkinter, grâce à leur constructeur de classe tkinter.Canvas ( ) et leur premier attribut doit être l'identification de son conteneur, son parent. Il est prudent de définir, dès la création de la liste fixe à choix, une couleur de fond et ses dimensions. 

import tkinter

TKI_Principal = tkinter.Tk ( ) 

tkinter.Canvas ( TKI_Principal , bg = "white" , width = 320 , height = 240 ).pack ( padx = 5 , pady = 5 )

tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy ).pack ( )

TKI_Principal.mainloop ( )

CREATION DES ELEMENTS D'UNE ZONE DE DESSIN.

Les éléments graphiques, appartenant à une zone de dessin, seront définis après la création de cette zone de dessin. Contrairement aux controles de tkinter, les éléments d'une zone de dessin ne sont pas placés avec un gestionnaire de placement, mais en indiquant, obligatoirement, et en nombre suffisant selon la nature de l'élément, les coordonnées de leurs sommets à la leur création. Ces sommets pourront ensuite être déplacés, si besoin, avec la méthode tkinter.Canvas ( ).coords ( ). Un, ou des sommets, peuvent se superposer et/ou être placés hors des limites de la zone de dessin, même avec des valeurs négatives.

import tkinter

TKI_Principal = tkinter.Tk ( )

ktitre = "Mon Python à moi,\nun Python pour tous."

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , width = 500 , height = 500 )

CAN_Toile.create_line ( 10 , 10 , 160 , 110 , width = 3 , fill = "olive" )

CAN_Toile.create_rectangle ( 200 , 10 , 300 , 110 , fill = "red" )

CAN_Toile.create_rectangle ( 340 , 10 , 490 , 110 , fill = "lime" ) 

CAN_Toile.create_arc ( 40 , 210 , 140 , 310 , start = 45 , extent = 270 , width = 7 , style = "arc"  ) 

CAN_Toile.create_oval ( 200 , 210 , 300 , 310 , fill = "yellow" ) 

CAN_Toile.create_oval ( 340 , 210 , 490 , 310 , fill = "orange" ) 

CAN_Toile.create_text ( 250 , 420 , text = ktitre , font = ( None , 24 ) , justify = "center" , fill = "green" )

CAN_Toile.pack ( )

BUT_Quitter.pack ( )

TKI_Principal.mainloop ( )

GESTION DES ELEMENTS GRACE A LEUR IDENTIFIANT.

Tous les éléments (arc, bitmap, image, line, oval, polygon, rectangle, text ou window ) créés dans une zone de dessin reçoivent un identifiant numérique (Id) unique qui permet de le gérer. Cette Id est un nombre entier démarrant du chiffre 1 et étant incrémenté de 1 à chaque nouvelle création. Il est aussi possible d'identifier chaque élément en l'affectant à une variable lors de sa création. Par exemple : LigneA = CAN_Zone.create_line ( ... ) pourra alors être appelé par son identifiant numérique, s'il est connu ou par LigneA.

import tkinter

def FNC_Selection ( event ) :

kactuel = int ( LAB_Ligne [ "text" ].split ( " : " ) [ -1 ] )

CAN_Toile.itemconfigure ( kactuel , fill = "pink" , width = 1 )

kselection = SCA_Identifiant.get ( )

CAN_Toile.itemconfigure ( kselection , fill = "red" , width = 3 )

LAB_Ligne [ "text" ] = f"Identifiant sélectionné : { kselection }"

TKI_Principal = tkinter.Tk ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

SCA_Identifiant = tkinter.Scale ( TKI_Principal , from_ = 1 , to = 12 , command = FNC_Selection )

LAB_Ligne = tkinter.Label ( TKI_Principal , text = "Identifiant sélectionné : 1 " )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , width = 400 , height = 300 )

for kligne in range ( 10 , 290 , 25 ) : CAN_Toile.create_line ( 10 , kligne , 390 , kligne , fill = "pink" )

SCA_Identifiant.pack ( side = "left" , fill = "both" )

LAB_Ligne.pack ( )

CAN_Toile.pack ( )

BUT_Quitter.pack ( )

FNC_Selection ( None )

TKI_Principal.mainloop ( )

GESTION DES ELEMENTS GRACE A LEURS TAGS.

Tous les éléments (arc, bitmap, image, line, oval, polygon, rectangle, text ou window ) peuvent recevoir un ou plusieurs tags. Un tag est une chaîne de caractères quelconque choisie par le créateur du script. Mais d'autres tags pourront être ajoutés, ou retirés, automatiquement par le script ou par des actions de l'utilisateur, mais prévues par le programme. 

Les éléments possédant un tag commun, forment un groupe d'éléments, et ils pourront donc être appelés ensemble dans les méthodes où ce tag sera précisé. Les éléments associés par un tag commun, pourront toujours être appelé individuellement grâce à leur identifiant numérique, leur nom (de variable) ou un tag qui leur est propre. Un élément peut aussi appartenir à plusieurs groupes. Les tags, et les groupes qu'ils permettent de former, sont des outils très précieux pour la sélection pertinente des éléments d'une zone de dessin.

Un élément peut être associé, ou dissocié, à un groupe d’éléments (par un tag) :

- lors de sa création ( ... , tags = ( "tag1" , "tag2" , ... , "tagn" ) ;

- en modifiant la valeur de son attribut tags avec la méthode itemconfigure ( ) ou itemconfig ( ) ;

- avec les méthodes addtag_above ( ), addtag_all ( ), addtag_below ( ), addtag_closet ( ), addtag_enclosed ( ), addtag_overlapping ( ), addtag_withtag ( ).

Il existe des groupes spéciaux gérés par tkinter :  

- tags = "current", qui ne contient que l'élément présent sous la pointeur de la souris, ou rien ;

- tags = "all", qui ne contient tous les éléments créés, et non détruits, dans la zone de dessin.

import tkinter

def FNC_Selection ( ) :

kactuel = LAB_Carres [ "text" ].split ( " : " ) [ -1 ]

CAN_Toile.itemconfigure ( kactuel , fill = kactuel )

LAB_Carres [ "text" ] = f"Sélectionner tous les : { SPI_Choix.get ( ) }"

def FNC_Cycle ( ) :

ktag = SPI_Choix.get ( )

kvisuel = CAN_Toile.itemcget ( ktag , "fill" )    

if kvisuel == ktag :

CAN_Toile.itemconfigure ( ktag , fill = "aqua" )

else :

CAN_Toile.itemconfigure ( ktag , fill = ktag )

TKI_Principal.after ( 250 , FNC_Cycle )

TKI_Principal = tkinter.Tk ( )

kcouleurs = [ "lime" , "red" , "magenta" , "blue" , "orange" ]

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

SPI_Choix = tkinter.Spinbox ( TKI_Principal , values = kcouleurs , wrap = True , command = FNC_Selection )

LAB_Carres = tkinter.Label ( TKI_Principal , text = "Sélectionner tous les : lime" )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , width = 450 , height = 450 )

for kligne in range ( 20 , 400 , 60 ) :

for kcolonne in range ( 20 , 400 , 60 ) :

kcouleur = kcouleurs.pop ( 0 )

CAN_Toile.create_rectangle ( kligne , kcolonne , ( kligne + 50 ) , ( kcolonne + 50 ) , fill = kcouleur , tags = ( kcouleur , ) )

kcouleurs.append ( kcouleur )

del kcouleurs

LAB_Carres.pack ( )

CAN_Toile.pack ( )

SPI_Choix.pack ( )

BUT_Quitter.pack ( )

FNC_Cycle ( )

TKI_Principal.mainloop ( )

FAIRE DEFILER UNE ZONE DE DESSIN EN LUI ASSOCIANT DES ASCENSEURS.

Les attributs width et height d'un objet toile, créé avec la classe tkinter.Canvas ( ), définissent les dimensions visibles de l'objet toile. Si les éléments incorporés dans cette objet toile sont positionnés à des coordonnées extérieures à cette zone de visibilité, il est possible d'associer des objets tkinter.Scrollbar ( ) à l'objet toile pour les atteindre visuellement.

Ces ascenseurs pourront alors parcourir toute la surface de l'objet toile et placer la zone recherchée dans la zone de visibilité. Il est possible de définir une zone restreinte d’accessibilité de l'objet toile par ses ascenseurs avec l'attribut scrollregion de l'objet toile. Si l'attribut scrollregion de l'objet toile n'est pas spécifié, l'association d'objets tkinter.Scrollbar ( ) à l'objet toile sera inutile car la zone accessibilité sera la même que la zone de visibilité défini avec les attributs width et height de l'objet toile. La zone d'accessibilité pourra toujours être redéfini ultérieurement avec : toile [ "scrollregion" ], toile.itemconfigure ( ) ou toile.itemconfig ( ) ;

L'attribut confine de l'objet toile permet de ne pas, ou plus, s'astreindre à la seule région d’accessibilité, définit avec l'attribut scrollregion de l'objet toile, et d'atteindre tous les éléments contenus dans l'objet toile, si des ascenseurs lui sont liés, ou de rétablir cette restriction.  

import tkinter

TKI_Principal = tkinter.Tk ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

BAR_Cote = tkinter.Scrollbar ( TKI_Principal )

BAR_Bas = tkinter.Scrollbar ( TKI_Principal , orient = "horizontal"  )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , scrollregion = ( -200 , -200 , 1000 , 1000 ) , width = 300 , height = 300 )

for kligne in range ( 9 ) :

CAN_Toile.create_line ( 0 , ( kligne * 100 ) , 800 , ( kligne * 100 ) , fill = "black" )

CAN_Toile.create_line ( ( kligne * 100 ) , 0 , ( kligne * 100 ) , 800 , fill = "black" )

CAN_Toile.create_rectangle ( 10 , 10 , 110 , 110 , fill = "pink" )

CAN_Toile.create_rectangle ( 290 , 10 , 390 , 110 , fill = "red" )

CAN_Toile.create_rectangle ( 10 , 290 , 110 , 390 , fill = "green" ) 

CAN_Toile.create_rectangle ( 290 , 290 , 390 , 390 , fill = "blue" ) 

CAN_Toile.create_rectangle ( 180 , 130 , 570 , 170 , fill = "yellow" ) 

CAN_Toile.create_rectangle ( 130 , 180 , 170 , 570 , fill = "orange" ) 

CAN_Toile [ "xscrollcommand" ] = BAR_Bas.set

BAR_Bas [ "command" ] = CAN_Toile.xview

CAN_Toile [ "yscrollcommand" ] = BAR_Cote.set

BAR_Cote [ "command" ] = CAN_Toile.yview

CAN_Toile.grid ( row = 0 , column = 0 , sticky = "nesw" )

BAR_Cote.grid ( row = 0 , column = 1 , sticky = "nesw" )

BAR_Bas.grid ( row = 1 , column = 0 , sticky = "nesw" )

BUT_Quitter.grid ( row = 2 , column = 0 , sticky = "nesw" )

TKI_Principal.mainloop ( )

FAIRE DEFILER UNE ZONE DE DESSIN AVEC LA SOURIS.

Les attributs width et height d'un objet toile, créé avec la classe tkinter.Canvas ( ), définissent les dimensions visibles de l'objet toile. Si les éléments incorporés dans cette objet toile sont positionnés à des coordonnées extérieures à cette zone de visibilité, il est possible de faire défiler l'objet toile pour les atteindre visuellement, avec les méthodes tkinter.Canvas ( ).scan_mark ( ) et  tkinter.Canvas ( ).scan_dragto ( ).

L'utilisation, en association, de ces 2 méthodes, permet à l'utilisateur de faire défiler l'intégralité de la zone de dessin par un cliquer-glisser classique, c'est-à-dire en plaçant le pointeur de la souris sur la zone de dessin puis, en maintenant l'un des boutons de la souris enfoncé, de déplacer le pointeur de la souris pour modifier la zone de visibilité de la zone de dessin.

Cette action ce programme en 2 temps. Tous d'abord, il faut lier un gestionnaire d'événement qui invoquera la méthode tkinter.Canvas ( ).scan_mark ( ) lors d'un appui sur un bouton de la souris pour lui passer les coordonnées initiales du pointeur de la souris. Ensuite, un autre gestionnaire surveillant le déplacement de la souris si un bouton est enfoncé (voir liste des modificateurs d'événements) appellera la méthode tkinter.Canvas ( ).scan_dragto ( ). qui effectuera le déplacement de la zone de visibilité en fonction des coordonnées du pointeur de la souris et au coefficient de déplacement, pas du saut par déplacement de pixel, indiqué.

import tkinter

def FNC_Deplacer ( event ) :

CAN_Toile.scan_dragto ( event.x , event.y , SCA_Vitesse.get ( ) )

def FNC_Enfoncer ( event )  :

CAN_Toile.scan_mark ( event.x , event.y ) 

TKI_Principal = tkinter.Tk ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

SCA_Vitesse = tkinter.Scale ( TKI_Principal , orient = "horizontal" , from_ = 1 , to = 50 )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , scrollregion = ( -200 , -200 , 1000 , 1000 ) , width = 300 , height = 300 )

for kligne in range ( 9 ) :

CAN_Toile.create_line ( 0 , ( kligne * 100 ) , 800 , ( kligne * 100 ) , fill = "black" )

CAN_Toile.create_line ( ( kligne * 100 ) , 0 , ( kligne * 100 ) , 800 , fill = "black" )

CAN_Toile.create_rectangle ( 10 , 10 , 110 , 110 , fill = "pink" )

CAN_Toile.create_rectangle ( 290 , 10 , 390 , 110 , fill = "red" )

CAN_Toile.create_rectangle ( 10 , 290 , 110 , 390 , fill = "green" ) 

CAN_Toile.create_rectangle ( 290 , 290 , 390 , 390 , fill = "blue" ) 

CAN_Toile.create_rectangle ( 180 , 130 , 570 , 170 , fill = "yellow" ) 

CAN_Toile.create_rectangle ( 130 , 180 , 170 , 570 , fill = "orange" ) 

CAN_Toile.bind ( "<ButtonPress-1>" , FNC_Enfoncer )

CAN_Toile.bind ( "<Button1-Motion>" , FNC_Deplacer )

CAN_Toile.pack ( )

SCA_Vitesse.pack ( )

tkinter.Label ( TKI_Principal , text = "Sélectionnez une vitesse de défilement" ).pack ( )

BUT_Quitter.pack ( )

TKI_Principal.mainloop ( )

SELECTIONNER UN ELEMENT AVEC LA SOURIS POUR LE MODIFIER.

Un élément, ou un groupe d'éléments, d'un objet tkinter.Canvas ( ) peuvent réagir aux événements de l'utilisateur en liant le gestionnaire d'événement à un de leur tags avec la méthode tkinter.Canvas ( ).tag_bind ( ). Si le tag utilisé pour cette surveillance des événements est "current", il devient, alors, facile d'agir sur un élément particulier, celui sous la souris. La méthode tkinter.Canvas ( ).find_withtag ( ) retourne un tuple ( ) contenant les identifiants, Id, de tous les éléments, groupe, ayant un certain tag. 

import tkinter

def FNC_Selection ( event ) :

if TKV_Element.get ( ) : CAN_Toile.itemconfigure ( TKV_Element.get ( ) , fill = TKV_Couleur.get ( ) )

kselectionne = CAN_Toile.find_withtag ( "current" ) [ 0 ]

TKV_Element.set ( kselectionne )

TKV_Couleur.set ( CAN_Toile.itemcget ( kselectionne , "fill" ) )

CAN_Toile.itemconfigure ( kselectionne , fill = "lime" )

def FNC_Survole ( ) :

kelement = CAN_Toile.find_withtag ( "current" )

if kelement :

kmessage = f"Le pointeur survole l'élément : { kelement } tagué\n"

kmessage += f"{ CAN_Toile.gettags ( kelement ) }.\nCliquez pour le sélectionner"

LAB_Message [ "text" ] = kmessage

else :

LAB_Message [ "text" ] = "\nAucun élément sous la souris.\n"

TKI_Principal.after ( 50 , FNC_Survole )

TKI_Principal = tkinter.Tk ( )

TKV_Element = tkinter.IntVar ( )

TKV_Couleur = tkinter.StringVar ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

BAR_Cote = tkinter.Scrollbar ( TKI_Principal )

BAR_Bas = tkinter.Scrollbar ( TKI_Principal , orient = "horizontal"  )

LAB_Message = tkinter.Label ( TKI_Principal )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , closeenough = 10 , scrollregion = ( -200 , -200 , 1000 , 1000 ) , width = 300 , height = 300 )

for kligne in range ( 9 ) :

kpas = kligne * 100

krang = str ( kligne )

CAN_Toile.create_line ( 0 , kpas , 800 , kpas , fill = "black" , tags = ( "noir" , "repère" , "vertical" , krang ) )

CAN_Toile.create_line ( kpas , 0 , kpas , 800 , fill = "black" , tags = ( "noir" , "repère" , "horizontal" , krang ) )

CAN_Toile.create_rectangle ( 10 , 10 , 110 , 110 , fill = "pink" , tags = ( "rose" , "rectangle" ) )

CAN_Toile.create_oval ( 290 , 10 , 390 , 110 , fill = "red" , tags = ( "rouge" , "ovale" ) )

CAN_Toile.create_rectangle ( 10 , 290 , 110 , 390 , fill = "green" , tags = ( "vert" , "rectangle" ) )

CAN_Toile.create_oval ( 290 , 290 , 390 , 390 , fill = "blue" , tags = ( "bleu" , "ovale" ) )

CAN_Toile.create_oval ( 180 , 130 , 570 , 170 , fill = "yellow" , tags = ( "jaune" , "ovale" ) )

CAN_Toile.create_rectangle ( 130 , 180 , 170 , 570 , fill = "orange" , tags = ( "orange" , "rectangle" ) )

CAN_Toile.tag_bind ( "current" , "<ButtonRelease-1>" , FNC_Selection )

CAN_Toile [ "xscrollcommand" ] = BAR_Bas.set

CAN_Toile [ "yscrollcommand" ] = BAR_Cote.set

BAR_Bas [ "command" ] = CAN_Toile.xview

BAR_Cote [ "command" ] = CAN_Toile.yview

CAN_Toile.grid ( row = 0 , column = 0 , sticky = "nesw" )

BAR_Cote.grid ( row = 0 , column = 1 , sticky = "nesw" )

BAR_Bas.grid ( row = 1 , column = 0 , sticky = "nesw" )

LAB_Message.grid ( row = 2 , column = 0 , sticky = "nesw" )

BUT_Quitter.grid ( row = 3 , column = 0 , sticky = "nesw" )

FNC_Survole ( )

TKI_Principal.mainloop ( )

SELECTIONNER ET DEPLACER UN ELEMENT AVEC LA SOURIS.

La méthode tkinter.Canvas ( ).move ( ), modifie la position de l'élément présent en premier argument. Les valeur des 2 autres arguments sont des int ( ) exprimés en pixels. Le deuxième argument indique le déplacement de l'élément vers la droite, valeur positive, ou vers la gauche, valeur négative. Alors que le troisième argument permet un mouvement vers le bas, valeur positive, ou vers le haut, valeur négative. 

import tkinter

def FNC_Selection ( event ) :

if TKV_Element.get ( ) :

TKV_Element.set ( 0 )

LAB_Message [ "text" ] = "1. Cliquez sur un élément pour le déplacer."

else :

TKV_Element.set ( CAN_Toile.find_withtag ( "current" ) [ 0 ] )

TKV_Abscisse.set ( event.x )

TKV_Ordonnee.set ( event.y )

LAB_Message [ "text" ] = "2. Re-cliquez pour fixer l'élément."

FNC_Deplacer ( )

def FNC_Deplacer ( ) :

kabscisse = TKI_Principal.winfo_pointerx ( ) - CAN_Toile.winfo_rootx ( )

kordonnee = TKI_Principal.winfo_pointery ( ) - CAN_Toile.winfo_rooty ( )

khorizontal = kabscisse - TKV_Abscisse.get ( )

kvertical = kordonnee - TKV_Ordonnee.get ( )

TKV_Abscisse.set ( kabscisse )

TKV_Ordonnee.set ( kordonnee )

CAN_Toile.move ( TKV_Element.get ( ) , khorizontal , kvertical )

CAN_Toile.update ( )

if TKV_Element.get ( ) : TKI_Principal.after ( 25 , FNC_Deplacer )

TKI_Principal = tkinter.Tk ( )

TKV_Element = tkinter.IntVar ( )

TKV_Abscisse = tkinter.IntVar ( )

TKV_Ordonnee = tkinter.IntVar ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

LAB_Message = tkinter.Label ( TKI_Principal , text = "1. Cliquez sur un élément pour le déplacer." )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , width = 500 , height = 500 )

CAN_Toile.create_rectangle ( 10 , 10 , 110 , 110 , fill = "yellow" )

CAN_Toile.create_rectangle ( 390 , 390 , 490 , 490 , fill = "green" )

CAN_Toile.create_oval ( 440 , 10 , 490 , 210 , fill = "red" )

CAN_Toile.create_oval ( 10 , 440 , 210 , 490 , fill = "blue" )

CAN_Toile.create_polygon ( 150 , 250 , 250 , 150 , 350 , 250 , 250 , 350 , fill = "orange" )

CAN_Toile.tag_bind ( "current" , "<ButtonRelease-1>" , FNC_Selection )

LAB_Message.pack ( )

CAN_Toile.pack ( )

BUT_Quitter.pack ( )

TKI_Principal.mainloop ( )

MODIFIER L'ASPECT DES BORDURES DES ELEMENTS.

Les attributs dash, activedash, disableddash, permettent de modifier le tracer des bordures des l'élément de façon discontinue grâce à une suite de int ( ) , entre 1 et 255, renseignés dans un tuple ( ), indiquant le nombre de pixels visibles, puis le nombre de pixels non visibles. par exemple avec dash = ( 7 , 3 , 10 , 5 , 8 , 4 ) trace une bordure donc les 7 premiers pixels sont visibles et les 3 pixels suivants sont invisible ; puis les 10 pixels suivants sont visibles et les 5 pixels suivants sont invisible ; enfin les 8 pixels suivants sont visibles et les 4 pixels suivants sont invisible puis le cycle recommence avec jusque la fin de la bordure.

L'attribut dashoffset permet de décaler le départ de la ligne d'un certain nombre de pixels, en effaçant les premiers pixels de la ligne. Par exemple avec dash = ( 7 , 3 , 10 , 5 , 8 , 4 ) et dashoffset = 3, trace une bordure donc les 3 premiers pixels sont effacés et les 4 (7 - 3 = 4) suivants sont visibles ; puis les 3 pixels suivants sont invisible ... . A partir du deuxième cycle de dash, les 7 premiers pixels (première valeur du tuple ( )) seront tous affichés.

Le comportement de ces attributs, peut varier selon l'environnement utilisée. Il peut même, dans certain cas, être ignoré ou produire des résultats visuels inattendus. 

import tkinter

def FNC_Trace ( event ) :

CAN_Toile.itemconfigure ( 1 , dash = ( SCA_Plein.get ( ) , SCA_Vide.get ( ) ) )

TKI_Principal = tkinter.Tk ( )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )

SCA_Plein = tkinter.Scale ( TKI_Principal , orient = "horizontal" , from_ = 1 , to = 255 , command = FNC_Trace )

SCA_Vide = tkinter.Scale ( TKI_Principal , orient = "horizontal" , from_ = 1 , to = 255 , command = FNC_Trace )

CAN_Toile = tkinter.Canvas ( TKI_Principal , bg = "white" , width = 400 , height = 400 )

CAN_Toile.create_rectangle ( 50 , 50 , 350 , 350 , width = 5 )

CAN_Toile.grid ( row = 0 , column = 0 , columnspan = 4 , sticky = "nesw" )

tkinter.Label ( TKI_Principal , text = "Plein : " , justify = "right" , anchor = "se" ).grid ( row = 1 , column = 0 , sticky = "sw" )

SCA_Plein.grid ( row = 1 , column = 1 , sticky = "nesw" )

tkinter.Label ( TKI_Principal , text = "Vide : " , justify = "right" , anchor = "se" ).grid ( row = 1 , column = 2 , sticky = "sw" )

SCA_Vide.grid ( row = 1 , column = 3 , sticky = "nesw" )

BUT_Quitter.grid ( row = 4 , column = 0 , columnspan = 4 , sticky = "nesw" )

SCA_Plein.set ( 10 )

SCA_Vide.set ( 10 )

TKI_Principal.mainloop ( )