24.1. Tkinter
— Python interface to Tcl/Tk¶
The Tkinter
module (« Tk interface ») is the standard Python interface to
the Tk GUI toolkit. Both Tk and Tkinter
are available on most Unix
platforms, as well as on Windows systems. (Tk itself is not part of Python; it
is maintained at ActiveState.)
Running python -m Tkinter
from the command line should open a window
demonstrating a simple Tk interface, letting you know that Tkinter
is
properly installed on your system, and also showing what version of Tcl/Tk is
installed, so you can read the Tcl/Tk documentation specific to that version.
Note
Tkinter
has been renamed to tkinter
in Python 3. The
2to3 tool will automatically adapt imports when converting your
sources to Python 3.
Voir aussi
Tkinter documentation:
- 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
Book by Mark Roseman about building attractive and modern graphical user interfaces with Python and Tkinter.
- Python and Tkinter Programming
Book by John Grayson (ISBN 1-884777-81-3).
Tcl/Tk documentation:
- Tk commands
Most commands are available as
Tkinter
orTkinter.ttk
classes. Change “8.6” to match the version of your Tcl/Tk installation.- Tcl/Tk recent man pages
Recent Tcl/Tk manuals on www.tcl.tk.
- ActiveState Tcl Home Page
Le développement de Tk/Tcl se déroule en grande partie au sein d’ActiveState.
- Tcl and the Tk Toolkit
Book by John Ousterhout, the inventor of Tcl.
- Practical Programming in Tcl and Tk
Le livre encyclopédique de Brent Welch.
24.1.1. Modules Tkinter¶
Most of the time, the Tkinter
module is all you really need, but a number
of additional modules are available as well. The Tk interface is located in a
binary module named _tkinter
. This module contains the low-level
interface to Tk, 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.
In addition to the Tk interface module, Tkinter
includes a number of
Python modules. The two most important modules are the Tkinter
module
itself, and a module called Tkconstants
. The former automatically imports
the latter, so to use Tkinter, all you need to do is to import one module:
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é.Modifié dans la version 2.4: The useTk parameter was added.
-
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 classeTk
, 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éé parTcl()
peut avoir une fenêtre de haut niveau créée (et le sous-système Tk initialisé) en appelant sa méthodeloadtk()
.Nouveau dans la version 2.4.
Parmi les modules qui savent gérer Tk, nous pouvons citer :
ScrolledText
Outil d’affichage de texte avec une barre de défilement verticale intégrée.
tkColorChooser
Boîte de dialogue permettant à l’utilisateur de choisir une couleur.
tkCommonDialog
Classe de base pour les boîtes de dialogue définies dans les autres modules listés ici.
tkFileDialog
Boîtes de dialogue standard permettant à l’utilisateur de spécifier un fichier à ouvrir ou à enregistrer.
tkFont
Utilitaires pour gérer les polices de caractères.
tkMessageBox
Accès aux boîtes de dialogue Tk standard.
tkSimpleDialog
Boîtes de dialogue simples et fonctions utilitaires.
Tkdnd
Drag-and-drop support for
Tkinter
. This is experimental and should become deprecated when it is replaced with the Tk DND.turtle
Tortue graphique dans une fenêtre Tk.
These have been renamed as well in Python 3; they were all made submodules of
the new tkinter
package.
24.1.2. 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 :
Tkinter a été écrit par Steen Lumholt et Guido van Rossum.
Tk a été écrit par John Ousterhout de Berkeley.
Ce guide de survie a été écrit par Matt Conway de l’Université de Virginie.
The html rendering, and some liberal editing, was produced from a FrameMaker version by 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.
24.1.2.1. 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.
When trying to answer questions of the form « how do I do blah », it is often best
to find out how to do « blah » in straight Tk, and then convert this back into the
corresponding Tkinter
call. Python programmers can often guess at the
correct Python command by looking at the Tk documentation. This means that in
order to use Tkinter, you will have to know a little bit about Tk. This document
can’t fulfill that role, so the best we can do is point you to the best
documentation that exists. Here are some hints:
The authors strongly suggest getting a copy of the Tk man pages. Specifically, the man pages in the
mann
directory are most useful. Theman3
man pages describe the C interface to the Tk library and thus are not especially helpful for script writers.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.py
is a last resort for most, but can be a good place to go when nothing else makes sense.
24.1.2.2. Un simple programme Hello World¶
from Tkinter import *
class Application(Frame):
def say_hi(self):
print "hi there, everyone!"
def createWidgets(self):
self.QUIT = Button(self)
self.QUIT["text"] = "QUIT"
self.QUIT["fg"] = "red"
self.QUIT["command"] = self.quit
self.QUIT.pack({"side": "left"})
self.hi_there = Button(self)
self.hi_there["text"] = "Hello",
self.hi_there["command"] = self.say_hi
self.hi_there.pack({"side": "left"})
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.createWidgets()
root = Tk()
app = Application(master=root)
app.mainloop()
root.destroy()
24.1.3. 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 »).
To make use of this reference material, there will be times when you will need
to know how to read short passages of Tk and how to identify the various parts
of a Tk command. (See section Correspondance entre Basic Tk et Tkinter for the
Tkinter
equivalents of what’s below.)
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.
24.1.4. 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")
In Tk, to perform an action on a widget, use the widget name as a command, and follow it with an action name, possibly with arguments (options). In Tkinter, you call methods on the class instance to invoke actions on the widget. The actions (methods) that a given widget can perform are listed in the Tkinter.py module.
.fred invoke =====> fred.invoke()
To give a widget to the packer (geometry manager), you call pack with optional
arguments. In Tkinter, the Pack class holds all this functionality, and the
various forms of the pack command are implemented as methods. All widgets in
Tkinter
are subclassed from the Packer, and so inherit all the packing
methods. See the Tix
module documentation for additional information on
the Form geometry manager.
pack .fred -side left =====> fred.pack(side = "left")
24.1.6. Guide pratique¶
24.1.6.1. 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 |
|
1 |
nom de l’option pour la recherche dans la base de données |
|
2 |
classe de l’option pour la recherche dans la base de données |
|
3 |
Valeur par défaut |
|
4 |
valeur actuelle |
|
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.
24.1.6.2. L’empaqueteur¶
L’empaqueteur est l’un des mécanismes de Tk pour la gestion de la disposition des éléments sur l’écran. Les gestionnaires de géométrie sont utilisés pour spécifier le positionnement relatif du positionnement des objets graphiques dans leur conteneur — leur constructeur mutuel. Contrairement au plus encombrant placeur (qui est utilisé moins souvent, et nous n’en parlons pas ici), l’empaqueteur prend les spécifications qualitatives de relation — above, to the left of, filling, etc — et calcule tout pour déterminer les coordonnées exactes du placement pour vous.
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)
24.1.6.3. 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
ou1
.- 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'
.
24.1.6.4. 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.
Unfortunately, in the current implementation of Tkinter
it is not
possible to hand over an arbitrary Python variable to a widget through a
variable
or textvariable
option. The only kinds of variables for which
this works are variables that are subclassed from a class called Variable,
defined in the Tkinter
module.
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 :
class App(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.entrythingy = Entry()
self.entrythingy.pack()
# here is the application variable
self.contents = 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
# and here we get a callback when the user hits return.
# we will have the program print out the value of the
# application variable when the user hits return
self.entrythingy.bind('<Key-Return>',
self.print_contents)
def print_contents(self, event):
print "hi. contents of entry is now ---->", \
self.contents.get()
24.1.6.5. Le gestionnaire de fenêtres¶
In Tk, there is a utility command, wm
, for interacting with the window
manager. Options to the wm
command allow you to control things like titles,
placement, icon bitmaps, and the like. In Tkinter
, these commands have
been implemented as methods on the Wm
class. Toplevel widgets are
subclassed from the Wm
class, and so can call the Wm
methods
directly.
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 :
from Tkinter import *
class App(Frame):
def __init__(self, master=None):
Frame.__init__(self, 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()
24.1.6.6. 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éfixeXC_
. 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
This is almost always the
set()
method of some scrollbar widget, but can be any widget method that takes a single argument. Refer to the fileDemo/tkinter/matt/canvas-with-scrollbars.py
in the Python source distribution for an example.- wrap
Doit être l’un d’eux :
"none"
,"char"
, ou"word"
.
24.1.6.7. 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ù :
- séquence
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 turnRed(self, event):
event.widget["activeforeground"] = "red"
self.button.bind("<Enter>", self.turnRed)
Notice how the widget field of the event is being accessed in the
turnRed()
callback. This field contains the widget that caught the X
event. The following table lists the other event fields you can access, and how
they are denoted in Tk, which can be useful when referring to the Tk man pages.
Tk Tkinter Event Field Tk Tkinter Event Field
-- ------------------- -- -------------------
%f focus %A char
%h height %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
24.1.6.8. Le paramètre index¶
A number of widgets require »index » parameters to be passed. These are used to point at a specific place in a Text widget, or to particular characters in an Entry widget, or to particular menu items in a Menu widget.
- Index des objets graphique de type Entrée (
index
,view index
, etc.) Entry widgets have options that refer to character positions in the text being displayed. You can use these
Tkinter
functions to access these special points in text widgets:- AtEnd()
refers to the last position in the text
- AtInsert()
refers to the point where the text cursor is
- AtSelFirst()
indicates the beginning point of the selected text
- AtSelLast()
denotes the last point of the selected text and finally
- At(x[, y])
refers to the character at pixel location x, y (with y not used in the case of a text entry widget, which contains a single line of text).
- 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 ;
the string
'active'
, which refers to the menu position that is currently under the cursor;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 avecmenu.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
ounone
peuvent être interprétés comme les littéraux ci-dessus, plutôt.
24.1.6.9. Images¶
Images of different formats can be created through the corresponding subclass
of Tkinter.Image
:
BitmapImage
for images in XBM format.PhotoImage
for images in PGM, PPM, GIF and PNG formats. The latter is supported starting with 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
The Pillow package adds support for formats such as BMP, JPEG, TIFF, and WebP, among others.
24.1.7. 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éthodefileno()
(comme un objet fichier ou connecteur), soit un descripteur de fichier de type entier. L’argumentmask
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.