# `tkinter` — Interface Python pour Tcl/Tk

Code source : Lib/tkinter/__init__.py

The `tkinter` package ("Tk interface") is the standard Python interface to the Tcl/Tk GUI toolkit. Both Tk and `tkinter` are available on most Unix platforms, including macOS, as well as on Windows systems.

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

- TkDocs

    Extensive tutorial on creating user interfaces with Tkinter. Explains key concepts, and illustrates recommended approaches using the modern API.

- Tkinter 8.5 reference: a GUI for Python

    Reference documentation for Tkinter 8.5 detailing available classes, methods, and options.

Tcl/Tk Resources:

- Commandes Tk

    Comprehensive reference to each of the underlying Tcl/Tk commands used by Tkinter.

- Tcl/Tk Home Page

    Additional documentation, and links to Tcl/Tk core development.

Books:

- Modern Tkinter for Busy Python Developers

    By Mark Roseman. (ISBN 978-1999149567)

- Python and Tkinter Programming

    By Alan Moore. (ISBN 978-1788835886)

- Programming Python

    By Mark Lutz; has excellent coverage of Tkinter. (ISBN 978-0596158101)

- Tcl and the Tk Toolkit (2nd edition)

    By John Ousterhout, inventor of Tcl/Tk, and Ken Jones; does not cover Tkinter. (ISBN 978-0321336330)

## Modules Tkinter

Support for Tkinter is spread across several modules. Most applications will need the main `tkinter` module, as well as the `tkinter.ttk` module, which provides the modern themed widget set and API:

    from tkinter import *
    from tkinter import ttk

class `tkinter.``Tk`(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

  Construct a toplevel Tk widget, which is usually the main window of an application, and initialize a Tcl interpreter for this widget. Each instance has its own associated Tcl interpreter.

  The `Tk` class is typically instantiated using all default values. However, the following keyword arguments are currently recognized:

  screenName

    When given (as a string), sets the `DISPLAY` environment variable. (X11 only)

  baseName

    Name of the profile file. By default, baseName is derived from the program name (`sys.argv[0]`).

  className

    Name of the widget class. Used as a profile file and also as the name with which Tcl is invoked (argv0 in interp).

  useTk

    If `True`, initialize the Tk subsystem. The `tkinter.Tcl()` function sets this to `False`.

  sync

    If `True`, execute all X server commands synchronously, so that errors are reported immediately. Can be used for debugging. (X11 only)

  use

    Specifies the id of the window in which to embed the application, instead of it being created as an independent toplevel window. id must be specified in the same way as the value for the -use option for toplevel widgets (that is, it has a form like that returned by `winfo_id()`).

    Note that on some platforms this will only work correctly if id refers to a Tk frame or toplevel that has its -container option enabled.

  `Tk` reads and interprets profile files, named `.className.tcl` and `.baseName.tcl`, into the Tcl interpreter and calls `exec()` on the contents of `.className.py` and `.baseName.py`. The path for the profile files is the `HOME` environment variable or, if that isn't defined, then `os.curdir`.

  `tk`

    The Tk application object created by instantiating `Tk`. This provides access to the Tcl interpreter. Each widget that is attached the same instance of `Tk` has the same value for its `tk` attribute.

  `master`

    The widget object that contains this widget. For `Tk`, the master is `None` because it is the main window. The terms master and parent are similar and sometimes used interchangeably as argument names; however, calling `winfo_parent()` returns a string of the widget name whereas `master` returns the object. parent/child reflects the tree-like relationship while master/slave reflects the container structure.

  `children`

    The immediate descendants of this widget as a `dict` with the child widget names as the keys and the child instance objects as the values.

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

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

The modules that provide Tk support include:

`tkinter`

  Main Tkinter module.

`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.ttk`

  Themed widget set introduced in Tk 8.5, providing modern alternatives for many of the classic widgets in the main `tkinter` module.

Additional modules:

`_tkinter`

  A binary module that contains the low-level interface to Tcl/Tk. It is automatically imported by the main `tkinter` module, and should never be used directly by application programmers. It is usually a shared library (or DLL), but might in some cases be statically linked with the Python interpreter.

`idlelib`

  Python's Integrated Development and Learning Environment (IDLE). Based on `tkinter`.

`tkinter.constants`

  Symbolic constants that can be used in place of strings when passing various parameters to Tkinter calls. Automatically imported by the main `tkinter` module.

`tkinter.dnd`

  (experimental) Drag-and-drop support for `tkinter`. This will become deprecated when it is replaced with the Tk DND.

`tkinter.tix`

  (deprecated) An older third-party Tcl/Tk package that adds several new widgets. Better alternatives for most can be found in `tkinter.ttk`.

`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 dans la base de données | `'relief'`
2 | classe de l'option pour la recherche dans la base de données | `'Relief'`
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

  Colors can be given as the names of X colors in the rgb.txt file, or as strings representing RGB values in 4 bit: `"#RGB"`, 8 bit: `"#RRGGBB"`, 12 bit: `"#RRRGGGBBB"`, or 16 bit: `"#RRRRGGGGBBBB"` ranges, where R,G,B here represent any legal hex digit. See page 160 of Ousterhout's book for details.

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 Tkinter | Tk | Champ évènement de 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`.