"tkinter" — Interface Python pour Tcl/Tk
****************************************

**Code source :** Lib/tkinter/__init__.py

======================================================================

Le paquet "tkinter" (« interface Tk ») est l'interface Python standard
de la boîte à outils d'IUG Tk.  Tk et "tkinter" sont disponibles sur
la plupart des plates-formes Unix, ainsi que sur les systèmes Windows
(Tk lui-même ne fait pas partie de Python ; il est maintenu par
ActiveState).

Exécuter "python -m tkinter" depuis la ligne de commande ouvre une
fenêtre de démonstration d'une interface Tk simple, vous indiquant que
"tkinter" est correctement installé sur votre système et indiquant
également quelle version de Tcl/Tk est installée ; vous pouvez donc
lire la documentation Tcl/Tk spécifique à cette version.

Voir aussi:

  Documentation de Tkinter :

  Python Tkinter Resources
     Le *Python Tkinter Topic Guide* fournit beaucoup d'informations
     sur l'utilisation de Tk à partir de Python et des liens vers
     d'autres sources d'information sur Tk.

  TKDocs
     Tutoriel complet plus convivial pour certains des objets
     graphiques.

  Tkinter 8.5 reference: a GUI for Python
     Documents de référence en ligne.

  Documents Tkinter sur effbot
     Référence en ligne pour *tkinter* réalisée par *effbot.org*.

  Programming Python
     Livre de Mark Lutz, qui couvre excellemment bien Tkinter.

  Modern Tkinter for Busy Python Developers
     Livre de Mark Roseman sur la construction d'interfaces graphiques
     esthétiques et modernes avec Python et Tkinter.

  Python and Tkinter Programming
     Livre de John Grayson (ISBN 1-884777-81-3).

  Documentation de Tcl/Tk :

  Commandes Tk
     La plupart des commandes sont disponibles sous forme de classes
     "tkinter" ou "tkinter.ttk". Modifiez '8.6' pour correspondre à
     votre version installée de Tcl/Tk.

  Pages de manuel récentes de Tcl/Tk
     Manuels récents de Tcl/Tk sur *www.tcl.tk*.

  Page d'accueil Tcl chez ActiveState
     Le développement de Tk/Tcl se déroule en grande partie au sein
     d'ActiveState.

  Tcl and the Tk Toolkit
     Livre de John Ousterhout, l'inventeur de Tcl.

  Practical Programming in Tcl and Tk
     Le livre encyclopédique de Brent Welch.


Modules Tkinter
===============

La plupart du temps, "tkinter" est tout ce dont vous avez vraiment
besoin mais un certain nombre de modules supplémentaires sont
également disponibles.  L'interface Tk est située dans un module
binaire nommé "_tkinter". Ce module contient l'interface de bas niveau
vers Tk et ne doit jamais être utilisé directement par les
développeurs. Il s'agit généralement d'une bibliothèque partagée (ou
DLL) mais elle peut, dans certains cas, être liée statiquement à
l'interpréteur Python.

En plus du module d'interface Tk, "tkinter" inclut un certain nombre
de modules Python, "tkinter.constants" étant l'un des plus importants.
Importer "tkinter" charge automatiquement "tkinter.constants" donc,
habituellement, pour utiliser Tkinter, tout ce dont vous avez besoin
est une simple commande d'importation :

   import tkinter

Ou, plus souvent :

   from tkinter import *

class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=1)

   La classe "Tk" est instanciée sans argument. Cela crée un widget de
   haut niveau de Tk qui est généralement la fenêtre principale d'une
   application. Chaque instance a son propre interpréteur Tcl associé.

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=0)

   La fonction "Tcl()" est une fonction fabrique qui crée un objet
   similaire à celui créé par la classe "Tk", sauf qu'elle
   n'initialise pas le sous-système Tk.  Ceci est le plus souvent
   utile lorsque vous pilotez l'interpréteur Tcl dans un environnement
   où vous ne voulez pas créer des fenêtres de haut niveau
   supplémentaires, ou alors si c'est impossible (comme les systèmes
   Unix/Linux sans un serveur X).  Un objet créé par "Tcl()" peut
   avoir une fenêtre de haut niveau créée (et le sous-système Tk
   initialisé) en appelant sa méthode "loadtk()".

Parmi les modules qui savent gérer Tk, nous pouvons citer :

"tkinter.colorchooser"
   Boîte de dialogue permettant à l'utilisateur de choisir une
   couleur.

"tkinter.commondialog"
   Classe de base pour les boîtes de dialogue définies dans les autres
   modules listés ici.

"tkinter.filedialog"
   Boîtes de dialogue standard permettant à l'utilisateur de spécifier
   un fichier à ouvrir ou à enregistrer.

"tkinter.font"
   Utilitaires pour gérer les polices de caractères.

"tkinter.messagebox"
   Accès aux boîtes de dialogue Tk standard.

"tkinter.scrolledtext"
   Outil d'affichage de texte avec une barre de défilement verticale
   intégrée.

"tkinter.simpledialog"
   Boîtes de dialogue simples et fonctions utilitaires.

"tkinter.dnd"
   Support du glisser-déposer pour "tkinter". Il s'agit d'une méthode
   expérimentale qui ne sera plus maintenue lorsqu'elle sera remplacée
   par Tk DND.

"turtle"
   Tortue graphique dans une fenêtre Tk.


Guide de survie Tkinter
=======================

Cette section n'est pas conçue pour être un tutoriel exhaustif de Tk
ou Tkinter.  Il s'agit plutôt d'un guide d'introduction au système.

Crédits :

* *Tk* a été écrit par John Ousterhout de Berkeley.

* *Tkinter* a été écrit par Steen Lumholt et Guido van Rossum.

* Ce guide de survie a été écrit par Matt Conway de l'Université de
  Virginie.

* Le rendu HTML, avec quelques modifications, a été réalisé à partir
  d'une version FrameMaker par Ken Manheimer.

* Fredrik Lundh a élaboré et mis à jour les descriptions de
  l'interface des classes, en cohérence avec Tk 4.2.

* Mike Clarkson a converti la documentation en LaTeX et a compilé le
  chapitre *Interface utilisateur* du manuel de référence.


Mode d'emploi
-------------

Cette section est divisée en deux parties : la première moitié (à peu
près) couvre la partie théorique, tandis que la seconde moitié peut
être utilisée comme guide pratique.

Lorsque l'on essaie de répondre à des questions sur la manière de
faire « ceci ou cela », il est souvent préférable de trouver comment
le faire en Tk, puis de le convertir en fonction correspondante
"tkinter". Les programmeurs Python peuvent souvent deviner la commande
Python correcte en consultant la documentation Tk. Cela signifie que
pour utiliser Tkinter, vous devez en savoir un peu plus sur Tk. Ce
document ne peut pas remplir ce rôle, alors le mieux que nous
puissions faire est de vous indiquer la meilleure documentation qui
existe. Voici quelques conseils :

* Les auteurs conseillent fortement d'obtenir une copie des pages de
  manuel de Tk. En particulier, les pages de manuel dans le répertoire
  "manN" sont les plus utiles. Les pages de manuel "man3" décrivent
  l'interface C de la bibliothèque Tk et ne sont donc pas
  particulièrement utiles aux développeurs de scripts.

* Addison-Wesley a publié un livre intitulé *Tcl and the Tk Toolkit*
  de John Ousterhout (ISBN 0-201-63337-X) qui est une bonne
  introduction à Tcl et Tk pour débutants.  Le livre n'est pas
  exhaustif et, pour beaucoup de détails, il renvoie aux pages du
  manuel.

* "tkinter/__init__.py" est souvent un dernier recours, mais peut être
  un bon endroit où aller quand rien d'autre ne fait sens.


Un simple programme *Hello World*
---------------------------------

   import tkinter as tk

   class Application(tk.Frame):
       def __init__(self, master=None):
           super().__init__(master)
           self.master = master
           self.pack()
           self.create_widgets()

       def create_widgets(self):
           self.hi_there = tk.Button(self)
           self.hi_there["text"] = "Hello World\n(click me)"
           self.hi_there["command"] = self.say_hi
           self.hi_there.pack(side="top")

           self.quit = tk.Button(self, text="QUIT", fg="red",
                                 command=self.master.destroy)
           self.quit.pack(side="bottom")

       def say_hi(self):
           print("hi there, everyone!")

   root = tk.Tk()
   app = Application(master=root)
   app.mainloop()


Un (très) rapide aperçu de Tcl/Tk
=================================

La hiérarchie de classes semble compliquée mais, dans la pratique, les
développeurs d'applications se réfèrent presque toujours aux classes
situées tout en bas de la hiérarchie.

Notes :

* Ces classes sont fournies dans le but d'organiser certaines
  fonctions sous un seul espace de nommage. Elles n'ont pas vocation à
  être instanciées indépendamment.

* La classe "Tk" est destinée à être instanciée une seule fois dans
  une application. Les développeurs d'applications n'ont pas besoin
  d'en instancier une explicitement, Le système en crée une au besoin
  quand une des autres classes est instanciée.

* La classe "Widget" n'est pas destinée à être instanciée, elle est
  destinée uniquement au sous-classement pour faire de « vrais »
  objets graphiques (en C++, on appelle cela une « classe abstraite
  »).

Pour comprendre cette documentation, il y aura des moments où vous
aurez besoin de savoir comment lire de courts passages de Tk et
comment identifier les différentes parties d'une commande Tk.   (Voir
la section Correspondance entre Basic Tk et Tkinter pour les
équivalents "tkinter" de ce qui suit).

Les scripts Tk sont des programmes Tcl.  Comme tous les programmes
Tcl, les scripts Tk ne sont que des listes de commandes séparées par
des espaces.  Un objet graphique Tk n'est constitué que de sa
*classe*, des *options* qui l'aident à se configurer et des *actions*
qui lui font faire des choses utiles.

Pour créer un objet graphique en Tk, la commande est toujours de la
forme :

   classCommand newPathname options

*classCommand*
   indique le type d'objet graphique à réaliser (un bouton, une
   étiquette, un menu…)

*newPathname*
   est le nouveau nom pour cet objet graphique.  Tous les noms dans Tk
   doivent être uniques.  Pour vous aider à respecter cette règle, les
   objets graphiques dans Tk sont nommés avec des *noms d'accès*, tout
   comme les fichiers dans le système de fichiers.  L'objet graphique
   de niveau supérieur, la racine (*root* en anglais), s'appelle "."
   (point) et les enfants sont délimités par plusieurs points.  Par
   exemple, ".myApp.controlPanel.okButton" pourrait être le nom d'un
   objet graphique.

*options*
   configure l'apparence de l'objet graphique et, dans certains cas,
   son comportement.  Les options se présentent sous la forme d'une
   liste de paramètres et de valeurs. Les paramètres sont précédés
   d'un « - », comme les paramètres d'une ligne de commande du shell
   Unix, et les valeurs sont mises entre guillemets si elles font plus
   d'un mot.

Par exemple :

   button   .fred   -fg red -text "hi there"
      ^       ^     \______________________/
      |       |                |
    class    new            options
   command  widget  (-opt val -opt val ...)

Une fois créé, le chemin d'accès à l'objet graphique devient une
nouvelle commande.  Cette nouvelle *commande d'objet graphique* est
l'interface du programmeur pour que le nouvel objet graphique effectue
une *action*.  En C, cela prend la forme "someAction(fred,
someOptions)", en C++, cela prend la forme
*fred.someAction(someOptions)* et, en Tk, vous dites :

   .fred someAction someOptions

Notez que le nom de l'objet, ".fred", commence par un point.

Comme vous pouvez vous y attendre, les valeurs autorisées pour
*someAction* dépendent de la classe de l'objet graphique : ".fred
disable" fonctionne si "fred" est un bouton ("fred" devient grisé),
mais ne fonctionne pas si "fred" est une étiquette (la désactivation
des étiquettes n'existe pas dans Tk).

Les valeurs possibles de *someOptions* dépendent de l'action.
Certaines actions, comme "disable", ne nécessitent aucun argument ;
d'autres, comme la commande "delete" d'une zone de saisie, nécessitent
des arguments pour spécifier l'étendue du texte à supprimer.


Correspondance entre *Basic Tk* et *Tkinter*
============================================

Les commandes de classes dans Tk correspondent aux constructeurs de
classes dans Tkinter.

   button .fred                =====>  fred = Button()

Le constructeur d'un objet est implicite dans le nouveau nom qui lui
est donné lors de la création.  Dans Tkinter, les constructeurs sont
spécifiés explicitement.

   button .panel.fred          =====>  fred = Button(panel)

Les options de configuration dans Tk sont données dans des listes de
paramètres séparés par des traits d'union suivies de leurs valeurs.
Dans Tkinter, les options sont spécifiées sous forme d'arguments par
mots-clés dans le constructeur d'instance, et d'arguments par mots-
clés pour configurer les appels ou sous forme d'une entrée, dans le
style dictionnaire, d'instance pour les instances établies.  Voir la
section Définition des options pour la façon de définir les options.

   button .fred -fg red        =====>  fred = Button(panel, fg="red")
   .fred configure -fg red     =====>  fred["fg"] = red
                               OR ==>  fred.config(fg="red")

Dans Tk, pour effectuer une action sur un objet graphique, utilisez le
nom de l'objet graphique comme une commande et faites-le suivre d'un
nom d'action, éventuellement avec des arguments (options).  Dans
Tkinter, vous appelez des méthodes sur l'instance de classe pour
invoquer des actions sur l'objet graphique.  Les actions (méthodes)
qu'un objet graphique donné peut effectuer sont listées dans
"tkinter/__init__.py".

   .fred invoke                =====>  fred.invoke()

Pour donner un objet graphique à l'empaqueteur (ce qui gère la
disposition à l'écran), appelez "pack" avec des arguments optionnels.
Dans Tkinter, la classe "Pack" contient toutes ces fonctionnalités et
les différentes formes de la commande "pack" sont implémentées comme
méthodes.  Tous les objets graphiques de "tkinter" sont sous-classés
depuis l'empaqueteur et donc héritent de toutes les méthodes
d'empaquetage. Voir la documentation du module "tkinter.tix" pour plus
d'informations sur le gestionnaire de disposition des formulaires.

   pack .fred -side left       =====>  fred.pack(side="left")


Relations entre Tk et Tkinter
=============================

De haut en bas :

Votre application (Python)
   Une application Python fait un appel "tkinter".

*tkinter* (paquet Python)
   Cet appel (par exemple, la création d'un objet graphique de type
   bouton) est implémenté dans le paquet "tkinter", qui est écrit en
   Python.  Cette fonction Python analyse les commandes et les
   arguments et les convertit en une forme qui les fait ressembler à
   un script Tk au lieu d'un script Python.

_tkinter (C)
   Ces commandes et leurs arguments sont passés à une fonction C dans
   le module d'extension "_tkinter" — notez le tiret bas.

Objets graphiques Tk (C et Tcl)
   Cette fonction C est capable d'effectuer des appels vers d'autres
   modules C, y compris les fonctions C qui composent la bibliothèque
   Tk.  Tk est implémenté en C et un peu en Tcl. La partie Tcl des
   objets graphiques Tk est utilisée pour lier certains comportements
   par défaut aux objets graphiques, et est exécutée une fois au
   moment où le paquet Python "tkinter" est importé (cette étape est
   transparente pour l'utilisateur).

Tk (C)
   La partie Tk des objets graphiques Tk implémente la correspondance
   finale avec …

Xlib (C)
   la bibliothèque *Xlib* pour dessiner des éléments graphiques à
   l'écran.


Guide pratique
==============


Définition des options
----------------------

Les options contrôlent des paramètres tels que la couleur et la
largeur de la bordure d'un objet graphique. Les options peuvent être
réglées de trois façons :

Lors de la création de l'objet, à l'aide d'arguments par mots-clés
      fred = Button(self, fg="red", bg="blue")

Après la création de l'objet, en manipulant le nom de l'option comme
une entrée de dictionnaire
      fred["fg"] = "red"
      fred["bg"] = "blue"

Utilisez la méthode "config()" pour mettre à jour plusieurs attributs
après la création de l'objet
      fred.config(fg="red", bg="blue")

Pour l'explication complète d'une option donnée et de son
comportement, voir les pages de manuel Tk de l'objet graphique en
question.

Notez que les pages de manuel listent « OPTIONS STANDARD » et «
OPTIONS SPÉCIFIQUES D'OBJETS GRAPHIQUES » pour chaque objet graphique.
La première est une liste d'options communes à de nombreux objets
graphiques, la seconde est une liste d'options propres à cet objet
graphique particulier.  Les options standard sont documentées sur la
page de manuel *options(3)*.

Aucune distinction n'est faite dans ce document entre les options
standard et les options spécifiques à un objet graphique.  Certaines
options ne s'appliquent pas à certains types d'objets graphiques. La
réaction d'un objet graphique donné à une option particulière dépend
de la classe de l'objet graphique ; les boutons possèdent une option
"command", pas les étiquettes.

Les options gérées par un objet graphique donné sont listées dans la
page de manuel de cet objet graphique, ou peuvent être interrogées à
l'exécution en appelant la méthode "config()" sans argument, ou en
appelant la méthode "keys()" sur cet objet graphique.  La valeur de
retour de ces appels est un dictionnaire dont la clé est le nom de
l'option sous forme de chaîne (par exemple, "'relief'") et dont les
valeurs sont des *5-uplets*.

Certaines options, comme "bg", sont des synonymes d'options communes
qui ont des noms longs ("bg" est une abréviation pour "background" «
arrière-plan »). Passer le nom abrégé d'une option à la méthode
"config()" renvoie un couple, pas un quintuplet. Le couple renvoyé
contient le nom abrégé et le nom *réel* de l'option, par exemple
"('bg','background')".

+---------+-----------------------------------+----------------+
| Index   | Signification                     | Exemple        |
|=========|===================================|================|
| 0       | nom des options                   | "'relief'"     |
+---------+-----------------------------------+----------------+
| 1       | nom de l'option pour la recherche | "'relief'"     |
|         | dans la base de données           |                |
+---------+-----------------------------------+----------------+
| 2       | classe de l'option pour la        | "'Relief'"     |
|         | recherche dans la base de données |                |
+---------+-----------------------------------+----------------+
| 3       | valeur par défaut                 | "'raised'"     |
+---------+-----------------------------------+----------------+
| 4       | valeur actuelle                   | "'groove'"     |
+---------+-----------------------------------+----------------+

Exemple :

   >>> print(fred.config())
   {'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

Bien sûr, le dictionnaire affiché contient toutes les options
disponibles et leurs valeurs.  Ceci n'est donné qu'à titre d'exemple.


L'empaqueteur
-------------

The packer is one of Tk's geometry-management mechanisms.    Geometry
managers are used to specify the relative positioning of widgets
within their container - their mutual *master*.  In contrast to the
more cumbersome *placer* (which is used less commonly, and we do not
cover here), the packer takes qualitative relationship specification -
*above*, *to the left of*, *filling*, etc - and works everything out
to determine the exact placement coordinates for you.

La taille d'un objet graphique *constructeur* est déterminée par la
taille des « objets graphiques hérités » à l'intérieur.  L'empaqueteur
est utilisé pour contrôler l'endroit où les objets graphiques hérités
apparaissent à l'intérieur du constructeur dans lequel ils sont
empaquetés.  Vous pouvez regrouper des objets graphiques dans des
cadres, et des cadres dans d'autres cadres, afin d'obtenir le type de
mise en page souhaité. De plus, l'arrangement est ajusté dynamiquement
pour s'adapter aux changements incrémentiels de la configuration, une
fois qu'elle est empaquetées.

Notez que les objets graphiques n'apparaissent pas tant que leur
disposition n'a pas été spécifiée avec un gestionnaire de géométrie.
C'est une erreur de débutant courante de ne pas tenir compte de la
spécification de la géométrie, puis d'être surpris lorsque l'objet
graphique est créé mais que rien n'apparaît.  Un objet graphique
n'apparaît qu'après que, par exemple, la méthode "pack()" de
l'empaqueteur lui ait été appliquée.

La méthode *pack()* peut être appelée avec des paires mot-
clé-option/valeur qui contrôlent où l'objet graphique doit apparaître
dans son conteneur et comment il doit se comporter lorsque la fenêtre
principale de l'application est redimensionnée.  En voici quelques
exemples :

   fred.pack()                     # defaults to side = "top"
   fred.pack(side="left")
   fred.pack(expand=1)


Options de l'empaqueteur
------------------------

Pour de plus amples informations sur l'empaqueteur et les options
qu'il peut prendre, voir les pages de manuel et la page 183 du livre
de John Ousterhout.

*anchor*
   Type d'ancrage.  Indique l'endroit où l'empaqueteur doit placer
   chaque enfant dans son espace.

*expand*
   Booléen, "0" ou "1".

*fill*
   Valeurs acceptées : "'x'", "'y'", "'both'", "'none'".

*ipadx* et *ipady*
   Une distance — désignant l'écart interne de chaque côté de l'objet
   graphique hérité.

*padx* et *pady*
   Une distance — désignant l'écart externe de chaque côté de l'objet
   graphique hérité.

*side*
   Valeurs acceptées : "'left'", "'right'", "'top'", "'bottom'".


Association des variables de l'objet graphique
----------------------------------------------

L'assignation d'une valeur à certains objets graphiques (comme les
objets graphique de saisie de texte) peut être liée directement aux
variables de votre application à l'aide d'options spéciales.  Ces
options sont "variable", "textvariable", "onvalue", "offvalue" et
"value".  Ce lien fonctionne dans les deux sens : si la variable
change pour une raison ou pour une autre, l'objet graphique auquel
elle est connectée est mis à jour pour refléter la nouvelle valeur.

Malheureusement, dans l'implémentation actuelle de "tkinter" il n'est
pas possible de passer une variable Python arbitraire à un objet
graphique via une option "variable" ou "textvariable".  Les seuls
types de variables pour lesquels cela fonctionne sont les variables
qui sont sous-classées à partir d'une classe appelée *Variable*,
définie dans "tkinter".

Il existe de nombreuses sous-classes utiles de *Variable* déjà
définies : "StringVar", "IntVar", "DoubleVar" et "BooleanVar".  Pour
lire la valeur courante d'une telle variable, appelez la méthode
"get()" dessus et, pour changer sa valeur, appelez la méthode "set()".
Si vous suivez ce protocole, l'objet graphique suivra toujours la
valeur de la variable, sans autre intervention de votre part.

Par exemple :

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master):
           super().__init__(master)
           self.pack()

           self.entrythingy = tk.Entry()
           self.entrythingy.pack()

           # Create the application variable.
           self.contents = tk.StringVar()
           # Set it to some value.
           self.contents.set("this is a variable")
           # Tell the entry widget to watch this variable.
           self.entrythingy["textvariable"] = self.contents

           # Define a callback for when the user hits return.
           # It prints the current value of the variable.
           self.entrythingy.bind('<Key-Return>',
                                self.print_contents)

       def print_contents(self, event):
           print("Hi. The current entry content is:",
                 self.contents.get())

   root = tk.Tk()
   myapp = App(root)
   myapp.mainloop()


Le gestionnaire de fenêtres
---------------------------

Dans Tk, il y a une commande pratique, "wm", pour interagir avec le
gestionnaire de fenêtres.  Les options de la commande "wm" vous
permettent de contrôler les titres, le placement, les icônes en mode
*bitmap* et encore d'autres choses du même genre.  Dans "tkinter", ces
commandes ont été implémentées en tant que méthodes sur la classe
"Wm".  Les objets graphiques de haut niveau sont sous-classés à partir
de la classe "Wm", ils peuvent donc appeler directement les méthodes
de "Wm".

Pour accéder à la fenêtre du plus haut niveau qui contient un objet
graphique donné, vous pouvez souvent simplement vous référer au parent
de cet objet graphique.  Bien sûr, si l'objet graphique a été
empaqueté à l'intérieur d'un cadre, le parent ne représentera pas la
fenêtre de plus haut niveau.  Pour accéder à la fenêtre du plus haut
niveau qui contient un objet graphique arbitraire, vous pouvez appeler
la méthode "_root()". Cette méthode commence par un soulignement pour
indiquer que cette fonction fait partie de l'implémentation, et non
d'une interface avec la fonctionnalité Tk.

Voici quelques exemples d'utilisation courante :

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master=None):
           super().__init__(master)
           self.pack()

   # create the application
   myapp = App()

   #
   # here are method calls to the window manager class
   #
   myapp.master.title("My Do-Nothing Application")
   myapp.master.maxsize(1000, 400)

   # start the program
   myapp.mainloop()


Types de données des options Tk
-------------------------------

*anchor*
   Les valeurs acceptées sont des points cardinaux : "« n »", "« ne
   »", "« e »", "« se »", "« s »", "« sw »", "« w »", "« nw »" et "«
   center »".

*bitmap*
   Il y a huit bitmaps intégrés nommés : "« error »", "« gray25 »", "«
   gray50 »", "« hourglass »", "« info »", "« questhead »", "«
   question »", "« warning »'".  Pour spécifier un nom de fichier
   bitmap X, indiquez le chemin complet du fichier, précédé de "@",
   comme dans ""@/usr/contrib/bitmap/gumby.bit"".

*boolean*
   Vous pouvez lui donner les entiers 0 ou 1 ou les chaînes de
   caractères ""yes"" ou ""no"".

*callback*
   N'importe quelle fonction Python qui ne prend pas d'argument.  Par
   exemple :

      def print_it():
          print("hi there")
      fred["command"] = print_it

*color*
   Les couleurs peuvent être données sous forme de noms de couleurs
   Xorg dans le fichier *rgb.txt*, ou sous forme de chaînes
   représentant les valeurs RVB en 4 bits : "« #RGB »", 8 bits : "«
   #RRVVBB »", 12 bits``« #RRRVVVBBB »", ou 16 bits ``« #RRRRVVVVBBBB
   »", où R,V,B représente ici tout chiffre hexadécimal valide.  Voir
   page 160 du livre d'Ousterhout pour plus de détails.

*cursor*
   Les noms de curseurs Xorg standard que l'on trouve dans
   "cursorfont.h" peuvent être utilisés, sans le préfixe "XC_".  Par
   exemple pour obtenir un curseur en forme de main ("XC_hand2"),
   utilisez la chaîne "« hand2 »".  Vous pouvez également spécifier
   votre propre bitmap et fichier masque. Voir page 179 du livre
   d'Ousterhout.

*distance*
   Les distances à l'écran peuvent être spécifiées en pixels ou en
   distances absolues. Les pixels sont donnés sous forme de nombres et
   les distances absolues sous forme de chaînes de caractères, le
   dernier caractère indiquant les unités : "c" pour les centimètres,
   "i" pour les pouces (*inches* en anglais), "m" pour les
   millimètres, "p" pour les points d'impression.  Par exemple, 3,5
   pouces est noté "« 3.5i »".

*font*
   *Tk* utilise un format de nom de police sous forme de liste, tel
   que "{courier 10 bold}". Les tailles de polices avec des nombres
   positifs sont mesurées en points ; les tailles avec des nombres
   négatifs sont mesurées en pixels.

*geometry*
   Il s'agit d'une chaîne de caractères de la forme "largeurxhauteur",
   où la largeur et la hauteur sont mesurées en pixels pour la plupart
   des objets graphiques (en caractères pour les objets graphiques
   affichant du texte). Par exemple : "fred["geometry"] = "200x100"".

*justify*
   Les valeurs acceptées sont les chaînes de caractères : *« left »`*,
   "« center »", "« right »" et "« fill »".

*region*
   c'est une chaîne de caractères avec quatre éléments séparés par des
   espaces, chacun d'eux étant une distance valide (voir ci-dessus).
   Par exemple : ""2 3 4 5"``et ``" 3i 2i 4.5i 2i"``et ``"3c 2c 4c
   10.43c"" sont toutes des régions valides.

*relief*
   Détermine le style de bordure d'un objet graphique.  Les valeurs
   valides sont : ""raised"", ""sunken"", ""flat"", ""groove"", et
   ""ridge"".

*scrollcommand*
   C'est presque toujours la méthode "set()" d'un objet graphique de
   défilement, mais peut être n'importe quelle méthode d'objet
   graphique qui prend un seul argument.

wrap
   Doit être l'un d'eux : ""none"", ""char"", ou ""word"".


Liaisons et événements
----------------------

La méthode *bind* de la commande d'objet graphique vous permet de
surveiller certains événements et d'avoir un déclencheur de fonction
de rappel lorsque ce type d'événement se produit.  La forme de la
méthode de liaison est la suivante :

   def bind(self, sequence, func, add=''):

où :

*sequence*
   est une chaîne de caractères qui indique le type d'événement cible.
   (Voir la page du manuel de *bind* et la page 201 du livre de John
   Ousterhout pour plus de détails).

*func*
   est une fonction Python, prenant un argument, à invoquer lorsque
   l'événement se produit. Une instance d’évènement sera passée en
   argument. (Les fonctions déployées de cette façon sont communément
   appelées *callbacks* ou « fonctions de rappel » en français).

*add*
   est facultative, soit "''" ou "'+'".  L'envoi d'une chaîne de
   caractères vide indique que cette liaison doit remplacer toute
   autre liaison à laquelle cet événement est associé.  L'envoi
   de``«+»`` signifie que cette fonction doit être ajoutée à la liste
   des fonctions liées à ce type d'événement.

Par exemple :

   def turn_red(self, event):
       event.widget["activeforeground"] = "red"

   self.button.bind("<Enter>", self.turn_red)

Remarquez comment on accède au champ *objet graphique* de l'événement
dans la fonction de rappel "turn_red()".  Ce champ contient l'objet
graphique qui a capturé l'événement Xorg.  Le tableau suivant
répertorie les autres champs d'événements auxquels vous pouvez
accéder, et comment ils sont nommés dans Tk, ce qui peut être utile
lorsque vous vous référez aux pages de manuel Tk.

+------+-----------------------+------+-----------------------+
| Tk   | Champ *évènement* de  | Tk   | Champ *évènement* de  |
|      | Tkinter               |      | Tkinter               |
|======|=======================|======|=======================|
| %f   | focus                 | %A   | char                  |
+------+-----------------------+------+-----------------------+
| %h   | hauteur               | %E   | send_event            |
+------+-----------------------+------+-----------------------+
| %k   | keycode               | %K   | keysym                |
+------+-----------------------+------+-----------------------+
| %s   | state                 | %N   | keysym_num            |
+------+-----------------------+------+-----------------------+
| %t   | time                  | %T   | type                  |
+------+-----------------------+------+-----------------------+
| %w   | width                 | %W   | widget                |
+------+-----------------------+------+-----------------------+
| %x   | x                     | %X   | x_root                |
+------+-----------------------+------+-----------------------+
| %y   | y                     | %Y   | y_root                |
+------+-----------------------+------+-----------------------+


Le paramètre index
------------------

Un certain nombre d'objets graphiques nécessitent le passage de
paramètres « indicés ».  Ils sont utilisés pour pointer vers un
endroit spécifique dans un objet graphique de type *Texte*, ou vers
des caractères particuliers dans un objet graphique de type *Entrée*,
ou vers des éléments de menu particuliers dans un objet graphique de
type *Menu*.

Index des objets graphique de type *Entrée* ("index", "view index",
etc.)
   Les objets graphiques de type *Entrée* ont des options qui se
   réfèrent à la position des caractères dans le texte affiché.  Vous
   pouvez utiliser ces fonctions "tkinter" pour accéder à ces points
   spéciaux dans les objets graphiques texte :

Index des objets graphiques texte
   La notation de l'index des objets graphiques de type *Texte* est
   très riche et mieux décrite dans les pages du manuel Tk.

Index menu (*menu.invoke()*, *menu.entryconfig()*, etc.)
   Certaines options et méthodes pour manipuler les menus nécessitent
   des éléments de spécifiques. Chaque fois qu'un index de menu est
   nécessaire pour une option ou un paramètre, vous pouvez utiliser :

   * un entier qui fait référence à la position numérique de l'entrée
     dans l'objet graphique, comptée à partir du haut, en commençant
     par 0 ;

   * la chaîne de caractères ""active"", qui fait référence à la
     position du menu qui se trouve actuellement sous le curseur ;

   * la chaîne de caractères ""last"" qui fait référence au dernier
     élément du menu ;

   * un entier précédé de "@", comme dans "@6", où l'entier est
     interprété comme une coordonnée y de pixels dans le système de
     coordonnées du menu ;

   * la chaîne de caractères ""none"", qui n'indique aucune entrée du
     menu, le plus souvent utilisée avec "menu.activate()" pour
     désactiver toutes les entrées, et enfin,

   * une chaîne de texte dont le motif correspond à l'étiquette de
     l'entrée de menu, telle qu'elle est balayée du haut vers le bas
     du menu.  Notez que ce type d'index est considéré après tous les
     autres, ce qui signifie que les correspondances pour les éléments
     de menu étiquetés "last", "active" ou "none" peuvent être
     interprétés comme les littéraux ci-dessus, plutôt.


Images
------

Des images de différents formats peuvent être créées à travers la
sous-classe correspondante de "tkinter.Image" :

* "BitmapImage" pour les images au format *XBM*.

* "PhotoImage" pour les images aux formats *PGM*, *PPM*, *GIF* et
  *PNG*. Ce dernier est géré à partir de Tk 8.6.

L'un ou l'autre type d'image est créé par l'option "file" ou "data"
(d'autres options sont également disponibles).

L'objet image peut alors être utilisé partout où un objet graphique
sait gérer une option "image" (par ex. étiquettes, boutons, menus).
Dans ces cas, Tk ne conserve pas de référence à l'image. Lorsque la
dernière référence Python à l'objet image est supprimée, les données
de l'image sont également supprimées, et Tk affiche une boite vide à
l'endroit où l'image était utilisée.

Voir aussi:

  Le paquet Pillow ajoute la prise en charge de formats tels que
  *BMP*, *JPEG*, *TIFF* et *WebP*, entre autres.


Gestionnaires de fichiers
=========================

*Tk* vous permet d'enregistrer et de *désenregistrer* une fonction de
rappel qui est appelée depuis la boucle principale de Tk lorsque des
entrées-sorties sont possibles sur un descripteur de fichier. Un seul
gestionnaire peut être enregistré par descripteur de fichier. Exemple
de code :

   import tkinter
   widget = tkinter.Tk()
   mask = tkinter.READABLE | tkinter.WRITABLE
   widget.tk.createfilehandler(file, mask, callback)
   ...
   widget.tk.deletefilehandler(file)

Cette fonction n'est pas disponible sous Windows.

Dans la mesure où vous ne savez pas combien d'octets sont disponibles
en lecture, il ne faut pas utiliser les méthodes "BufferedIOBase" ou
"TextIOBase" "read()" ou "readline()", car elles requièrent d'indiquer
le nombre de *bytes* à lire. Pour les connecteurs, les méthodes
"recv()" ou "recvfrom()" fonctionnent bien ; pour les autres fichiers,
utilisez des lectures brutes ou "os.read(file.fileno(),
maxbytecount)".

Widget.tk.createfilehandler(file, mask, func)

   Enregistre la fonction de rappel du gestionnaire de fichiers
   *func*. L'argument "file" peut être soit un objet avec une méthode
   "fileno()" (comme un objet fichier ou connecteur), soit un
   descripteur de fichier de type entier. L'argument "mask" est une
   combinaison *OU* de l'une des trois constantes ci-dessous. La
   fonction de rappel s'utilise comme suit :

      callback(file, mask)

Widget.tk.deletefilehandler(file)

   Désenregistre un gestionnaire de fichiers.

tkinter.READABLE
tkinter.WRITABLE
tkinter.EXCEPTION

   Constantes utilisées dans les arguments "mask".
