Tkinter > les zones de saisies input (Entry)

Entry permet de saisir une seule ligne de texte. Pour plusieurs lignes, choisir Text

 

- La sélection est la région du texte sélectionné (surlignement).

- Le curseur d’insertion indique où le texte sera inséré. Il est affiché lorsque l’utilisateur clique sur le champ saisie. Il apparaît comme une ligne verticale qui clignote dans le composant. On peut régler son apparence.

- Les positions à l’intérieur du texte affiché dans le champs sont précisées à l’aide d’un index. Il y a plusieurs façons d’exprimer un index:

En utilisant un entier qui débute à 0 comme pour les chaînes de caractère de Python.

La constante ‘end’ qui se réfère à la position située après le texte.

La constante ‘insert’ qui se réfère à la position courante du curseur d’insertion.

La constante ‘anchor’ qui se réfère au premier caractère de la sélection courante, s’il y en a une.

Vous pouvez avoir besoin de récupérer le caractère qui se trouve à une position déterminée par la souris. Pour simplifier cela, vous pouvez utiliser un index à l’aide d’une chaîne de caractères de la forme ‘@n’ où n est la distance horizontale en pixels entre le côté gauche du champ de saisie et la souris. Un tel index déterminera le caractère situé à cette distance horizontale du côté gauche du champ de saisie.

MISE EN PLACE

Entry(fenetre_parente, **options)

 

Voir la description de config pour la liste des options.

 

import tkinter as tk
w = tk.Tk()
monChamps = tk.Entry(w, width=30)

VALEURS D’UN CHAMP

RÉCUPÉRER LA VALEUR D’UN CHAMP

s = monChamp.get()

 

You can also bind the entry widget to a StringVar instance, and set or get the entry text via that variable:

 

maVar = StringVar()
monChamp = Entry(w, textvariable=maVar)
monChamp.pack()
maVar.set("blabla")
s = maVar.get()

 

This example creates an Entry widget, and a Button that prints the current contents:

 

from Tkinter import *
w = Tk()
e = Entry(w)
e.pack()
e.focus_set()
def callback():
    print e.get()

b = Button(w, text="get", width=10, command=callback)
b.pack()
mainloop()

 

e = Entry(w, width=50)
e.pack()
text = e.get()

 

def makeentry(parent, caption, width=None, **options):
    Label(parent, text=caption).pack(side=LEFT)
    entry = Entry(parent, **options)
    if width:
        entry.config(width=width)
    entry.pack(side=LEFT)
    return entry

user = makeentry(parent, "User name:", 10)
password = makeentry(parent, "Password:", 10, show="*")

 

content = StringVar()
entry = Entry(parent, text=caption, textvariable=content)
text = content.get()
content.set(text)

VIDER UN CHAMP

delete(debut, fin=None)

 

Efface le/les caractères du debut (commence à 0) jusqu’à la fin (si renseigné, sinon, juste le caracatère à la position debut).

 

delete(0, END) pour effacer le texte en entier (END est un mot-variable à écrire tel quel qui signifie jusq’à la fin) :

 

e = Entry(master)
e.pack()
e.delete(0, END) 

INSÉRER / MODIFIER UN CHAMP

Pour insérer du texte dans un champ : insert - Pour remplacer du texte : delete + insert :

 

e = Entry(master)
e.pack()
e.delete(0, END)
e.insert(0, "bla bla")

MISE EN FORME

TEXTE

cursor= curseur

font= Widget font. The default is system specific.

foreground= ou fg= Text color

justify= alignement du texte dans le champs : LEFT (par défaut), CENTER ou RIGHT

show= Remplace chaque caractère du contenu par celui renseigné. Par exemple, pour les mots de passe : "*".

CHAMP

background= ou bg= couleur du fond

borderwidth= ou bd= épaisseurs de la bordure en pixels

relief= Border style. The default is SUNKEN. Other possible values are FLAT, RAISED, GROOVE, and RIDGE

takefocus= Indicates that the user can use the Tab key to move to this widget. (default is on).

width= en caractères. Note : this controls the size on screen; it does not limit the number of characters that can be typed into the entry field. The default width is 20 caracteres.

 

disabledbackground= Background to use when the widget is disabled.

disabledforeground= Text color to use when the widget is disabled.

 

highlightbackground= Together with highlightcolor, this option controls how to draw the focus highlight border. used when the widget doesn’t have focus

highlightcolor= Same as highlightbackground, but is used when the widget has focus

highlightthickness= The width of the focus highlight border. Default is typically a few pixels, unless the system indicates focus by modifying the button itself

 

insertbackground= Color used for the insertion cursor

insertborderwidth= Width of the insertion cursor’s border. If this is set to a non-zero value, the cursor is drawn using the RAISED border style

insertofftime= - insertontime= Ensemble, ces options gèrent le clignotement du curseur (en millisecondes)

insertwidth= Width of the insertion cursor. Usually one or two pixels.

 

readonlybackground= The background color to use when the state is “readonly”. If omitted or blank, the standard background is used instead.

state= NORMAL,DISABLED, ou readonly (idem DISABLED, mais le contenu peut être sélectionné et copié). if set to DISABLED or “readonly”, calls to insert and delete are ignored.

 

invalidcommand= - invcmd= FIXME. No default.

SELECTION

exportselection= If true, selected text is automatically exported to the clipboard. Default is true.

selectbackground= Selection background color. The default is system and display specific.

selectborderwidth= Selection border width. The default is system specific.

selectforeground= Selection text color. The default is system specific.

OPTIONS

 

 

MÉTHODES

 

 

 

 

—

 

Quand je presse la touche "entrée" il ne se passe rien :

 

from tkinter import *
def get_entry(event):
    v = ligne_texte.get()
    print(v)
root = Tk()
ligne_texte = Entry(root, width=30)
ligne_texte.pack()
root.bind('<Return>', get_entry)
root.mainloop()

 

Il faut en faite lui dire qu’on s’attend à ce que l’utilisateur presse entrer : bind permet la liaison entre un événement (paramètre event) et la fonction d’appel. L’événement est l’appui sur la touche return qui sera lié à la fonction get_entry.

 

Voir aussi :

 

from tkinter import *
class Master(Frame):
    def __init__(self, master):
        Frame.__init__(self, master)
        self.text_entry = Entry(master, width=30)
        #packages here
        self.text_entry.pack()
        self.master.bind("<Return>", self.get_entry)
    def get_entry(self, event):
        v=self.text_entry.get()
        print(v)

#sortie de la classe

def test():
    root= Tk()
    master=Master(root)
    root.mainloop()

if __name__ == '__main__':
    test()

 

—

 

PLACEMENT D’UN CARACTÈRE :

Plusieurs façon de positionner un caractère :

- Par un index numérique : commence à 0. for example, (0, 5) corresponds to the first five characters in the entry widget.

- ANCHOR corresponds to the start of the selection, if any. You can use the select_from method to change this from the program.

- END corresponds to the position just after the last character in the entry widget. The range (0, END) corresponds to all characters in the widget.

- INSERT corresponds to the current position of the text cursor. You can use the icursor method to change this from the program.

- Coordonnées de la souris ("@x") :

"@%d" % x

 

where x is given in pixels relative to the left edge of the entry widget.

config(**options)

textvariable= Associates a Tkinter variable (usually a StringVar) to the contents of the entry field.

 

validate= Specifies when validation should be done. You can use “focus” to validate whenever the widget gets or loses the focus, “focusin” to validate only when it gets focus, “focusout” to validate when it loses focus, “key” on any modification, and ALL for all situations. Default is NONE (no validation).

validatecommand= - vcmd= A function or method to call to check if the contents is valid. The function should return a true value if the new contents is valid, or false if it isn’t. Note that this option is only used if the validate option is not NONE.

 

xscrollcommand= Used to connect an entry field to a horizontal scrollbar. This option should be set to the set method of the corresponding scrollbar.

 

 

get() Gets the current contents of the entry field. Returns a string.

icursor(index) Moves the insertion cursor to the given index. This also sets the INSERT index.

index(index) Where to move the cursor. Gets the numerical position corresponding to the given index.

insert(index, string) Inserts text at the given index. Use insert(INSERT, text) to insert text at the cursor, insert(END, text) to append text to the widget.

index Where to insert the text. string The text to insert.

scan_dragto(x) Sets the scanning anchor for fast horizontal scrolling to the given mouse coordinate. x Current horizontal mouse position.

scan_mark(x) Scrolls the widget contents sideways according to the given mouse coordinate. The text is moved 10 times the distance between the scanning anchor and the new position. x Current horizontal mouse position.

select_adjust(index) - selection_adjust(index) Adjusts the selection to include also the given character. If index is already selected, do nothing.

select_clear() - selection_clear() Clears the selection.

select_from(index) - selection_from(index) Starts a new selection. This also sets the ANCHOR index.

select_present() - selection_present() Checks if text is selected. Returns A true value if some part of the text is selected.

select_range(start, end) - selection_range(start, end) Explicitly sets the selection range. Start must be smaller than end. Use selection_range(0, END) to select all text in the widget. start Start of selection range. end End of range.

select_to(index) - selection_to(index) Selects all text between ANCHOR and the given index.

xview(index) Makes sure the given index is visible. The entry view is scrolled if necessary.

xview_moveto(fraction) Adjusts the entry view so that the given offset is at the left edge of the canvas. Offset 0.0 is the beginning of the entry string, 1.0 the end.

xview_scroll(number, what) Scrolls the entry view horizontally by the given amount.

number Number of units - what What unit to use. This can be either “units” (characters) or “pages” (larger steps).

—

bd – (ou borderwidth) L’épaisseur de la bordure qui entoure la zone de saisie. Voir Les dimensions. Sa valeur est 2 pixels par défaut.

cursor – Pour indiquer le pointeur de souris à afficher lorsqu’on survole le bouton. Voir Le pointeur de la souris.

disabledbackground – La couleur d’arrière plan qui est utilisée lorsque le widget est dans l’état ‘disabled’.

disabledforeground – Couleur du texte lorsque le champ de saisie est dans l’état ‘disabled’.

exportselection – Par défaut, si vous sélectionnez du texte, il est automatiquement exporté vers le presse-papiers. Pour empêcher cela, utiliser exportselection=0.

font – Police de caractère utilisée pour le texte saisi dans le champ de saisi. Voir Les polices de caractères.

highlightbackground – Couleur de la ligne qui indique que le bouton n’a pas le focus. Voir Le focus: réception des saisies clavier.

highlightcolor – Couleur de ligne qui indique que le bouton a le focus.

highlightthickness – Épaisseur de la ligne de mise en valeur du focus.

insertbackground – Par défaut, le curseur d’insertion (qui indique l’endroit où le texte sera inséré) est noir. Précisez une autre couleur pour cette option si vous souhaitez la modifier. Voir Les couleurs.

insertborderwidth – Par défaut, le curseur d’insertion est un simple rectangle. Vous pouvez obtenir un effet de relief ‘raised’ (voir Les styles de relief) en configurant cette option avec la dimension de la bordure 3-d. Si vous faites cela, assurez-vous que l’option insertwidth vaut au moins le double de cette valeur.

insertofftime – Par défaut, le curseur d’insertion clignote. Vous pouvez configurer cette option avec une valeur en millisecondes pour préciser la durée de sa disparition dans le clignotement. La valeur par défaut est 300. Si vous utilisez insertofftime=0, le curseur ne clignotera plus du tout.

insertontime – Similaire à l’option insertofftime: durée de son apparition dans le clignotement. 600 millisecondes par défaut.

insertwidth – Normalement, le curseur d’insertion fait 2 pixels de large. Vous pouvez ajuster cela en indiquant une dimension arbitraire.

justify – Cette option contrôle l’alignement du texte lorsque celui-ci ne remplit pas complètement le champ de saisie. Les valeurs possibles sont ‘left’, ‘center’ et ‘right’.

readonlybackground – La couleur de fond utilisée lorsque le widget est dans l’état ‘readonly’.

relief – Sert à indiquer le relief utilisé pour dessiner le contour du champ de saisie. Voir Les styles de relief. La valeur par défaut est ‘sunken’.

selectbackground – La couleur de fond utilisée pour mettre en valeur le texte sélectionné. Voir Les couleurs.

selectborderwidth – La largeur de la bordure qui entoure le texte sélectionné. 1 pixel par défaut.

selectforeground – La couleur du texte sélectionné.

show – Normalement, le texte que l’utilisateur saisi apparaît dans la zone de saisie. Pour une saisie de type mot de passe, indiquer le caractère de remplacement à afficher, souvent show=’*’.

state – Utilisez cette option pour désactiver le champ de saisie de telle sorte que l’utilisateur ne puisse plus y insérer de texte.``state=’disabled’`` pour le désactiver, state=’normal’ pour le réactiver. Votre programme peut savoir si la souris survole le champ de saisie en interrogeant cette option qui devrait alors avoir la valeur ‘active’.

takefocus – Par défaut, le widget sera visité par le focus lorsque l’utilisateur utilisera la touche Tab. Configurez cette option avec la valeur 0 pour retirer le widget de la «traversée du focus». Pour plus d’informations sur le focus, voir Le focus: réception des saisies clavier.

textvariable – Pour pouvoir récupérer le texte courant du champ de saisie, vous devez configurer cette option avec une instance de StringVar; voir Les variables de contrôle: Les valeurs sous les widgets. Vous pouvez alors récupérer ou modifier le texte en utilisant les méthodes get() ou set() de cette variable de contrôle StringVar.

validate – Vous pouvez utiliser cette option pour indiquer que le champ de saisie utilise une fonction de validation qui sera appelée automatiquement à certains instants. Voir Gérer la validation.

validatecommand – Une fonction de validation pour le champ de saisie. Voir Gérer la validation.

width – La taille du champ de saisie mesurée en nombre de caractères. La valeur par défaut est 20. Pour les polices de caractères à chasse variable (fontes proportionnelles), la taille du champ de saisie s’obtient en multipliant la moyenne de la largeur des caractères de la fonte multipliée par la valeur de cette option.

xscrollcommand – Si vous vous attendez à ce que les utilisateurs saisissent plus de texte que la partie visible du champ de saisie ne peut en contenir, vous pouvez lier votre champ de saisie à une barre de défilement Scrollbar. Configurez alors cette option avec la méthode set() de la barre de défilement. Pour plus d’information, voir Défilement du contenu d’un champ de saisie.

 

Les méthodes disponibles pour les champs de saisie Entry incluent:

delete(first, last=None) Supprime les caractères de la position first jusqu’à, mais sans inclure, la position last. Si le deuxième argument est omis, seul le caractère à la position first est supprimé.

get() Retourne le texte que contient le champ de saisie lors de son appel.

icursor(index) Déplace le curseur d’insertion juste avant le caractère ayant la position index.

index(index) Fait défiler le contenu du champ de saisie de telle sorte que le caractère de position index soit à la première position visible à gauche. N’a pas d’effet si le texte tient tout entier dans le champ de saisie.

insert(index, s) Insère la chaîne de caractères s juste avant le caractère situé à la position index.

scan_dragto(x) Voir la méthode scan_mark ci-dessous.

scan_mark(x) Utilisez cette méthode pour initialiser le défilement rapide du contenu d’un champ de saisie munie d’une barre de défilement horizontale.

Pour réaliser cela, lier l’événement «bouton de la souris enfoncé» à un gestionnaire d’événement qui appelera scan_mark(x), où x représente la position horizontale courante de la souris. Ensuite, lier l’événement ‘<Motion>’ (déplacement de la souris) à un gestionnaire qui appelera scan_dragto(x), où x représente la position horizontale courante de la souris. La méthode scan_dragto fait défiler le contenu du champ de saisie de manière continue et à un rythme proportionnel à la distance (horizontale) entre la position lors de l’appel de scan_mark et la position courante.

select_adjust(index) Cette méthode sert à ajuster la sélection pour être sûr qu’elle contient le caractère situé à la position précisée par index. Si la sélection contient déjà le caractère, rien ne se produit. Autrement, la sélection est étendue à partir de sa position courante (s’il y en a une) pour inclure la position ayant l’index indiqué.

select_clear() Éfface la sélection (sans supprimer son contenu). N’a pas d’effet si il n’y a aucune sélection courante.

select_from(index) Positionne l’index de l’ancre de sélection, ‘anchor’, à la position du caractère sélectionné par index et sélectionne ce caractère.

select_present() Retourne True s’il y a une sélection, False autrement.

select_range(start, end) Pour régler la sélection depuis l’application. Sélectionne le texte de la position start jusqu’à, mais sans inclure, la position end. la position start doit être avant la position end.

Pour sélectionner tout le texte du champ de saisie e, utiliser e.select_range(0,’end’).

select_to(index) Sélection tout le texte à partir de la position ‘anchor’ jusqu’à, mais sans inclure, le caractère de position index.

xview(index) Fait défiler le texte de telle sorte que le caractère de position index soit situé au début du champ de saisie. Cette méthode est très utile dans la liaison entre un champ de saisie et une barre de défilement. Voir Défilement du contenu d’un champ de saisie.

xview_moveto(f) Positionne le texte dans le champ de saisie de telle sorte que le caractère situé à la position relative f (par rapport à l’intégralité du texte) soit positionné sur le bord gauche du champ. L’argument f doit appartenir à l’intervalle [0;1], où 0 signifie tout à gauche et 1 tout à droite.

xview_scroll(nb, quoi) Sert à faire défiler le contenu du champ de saisie horizontalement. L’argument quoi est soit ‘units’, pour indiquer un défilement caractères par caractères, ‘page’ pour un défilement par largeur du champ de saisie. Si l’argument nb est positif, le défilement se fait de la gauche vers la droite, s’il est négatif, le défilement se fait de la droite vers la gauche. Par exemple, pour un champ de saisie e, e.xview_scroll(-1,’pages’) fera bouger le texte d’une «page» vers la droite et e.xview_scroll(4, ‘units’) le fait défiler de 4 caractères vers la gauche.

Faire défiler le contenu d’un champ

Il faut ajouter un peu de code afin d’adapter la fonction de rappel d’une barre de défilement Scrollbar aux méthodes fournies par le champ. Voici quelques fragments de code qui illustrent un tel réglage. Premièrement, la création et la liaison de la barre de défilement et du champ de saisie:

 

saisi = Entry(root, width=10)
saisi.grid(row=0, sticky='ew')
saisiDefil = Scrollbar(root, orient='horizontal', command=defilGest)
saisiDefil.grid(row=1, sticky='ew')
saisi['xscrollcommand'] = saisiDefil.set

 

Ensuite, la définition de la fonction de rappel du code précédent:

 

def defilGest(L):
    op, deCombien = L[0], L[1]

    if op == 'scroll':
        units = L[2]
        saisi.xview_scroll(deCombien, units)
    elif op == 'moveto':
        saisi.xview_moveto(deCombien)

VALIDATION D’UN CHAMP

Pour vérifier le contenu d’un champ lors d’une validattion :

 

- Écrire une fonction de rappel qui vérifie le contenu du champ de saisie et retourne True s’il est considéré comme valide, ou False sinon. Si la fonction de rappel retourne False, les tentatives de l’utilisateur pour modifier le contenu du champ de saisie seront refusées et le texte restera inchangé.

 

- Enregistrez cette fonction de rappel: cela consiste à produire un «emballage Tcl» autour de votre fonction Python.Supposez que votre fonction de rappel soit estOk. Pour pouvoir associer cette fonction au champ de saisie, vous devez utilisez la méthode universelle (valable pour tout widget) register(estOk). Cette méthode crée «l’emballage Tcl» voulu et retourne une chaîne de caractères que tkinter peut utiliser pour appeler votre fonction.

 

- Lorsque vous appelez le constructeur du champ de saisie Entry, utilisez son option validatecommand pour préciser votre fonction de validation (par l’intermédiaire de la chaîne retournée par register()), et utilisez son option validate pour préciser les circonstances de l’appel de la fonction de validation. Les valeurs de ces options sont discutées avec plus de détails ci-dessous.

Voici les valeurs admissibles pour l’option validate et leur signification.

 

‘focus’ La validation est déclenchée à chaque fois que le champ de saisie obtient ou perd le focus (voir Le focus: réception des saisies clavier).

‘focusin’ Elle est déclenchée lorsque le champ de saisie obtient le focus.

‘focusout’ Elle est déclenchée lorsque le champ de saisie perd le focus.

‘key’ Elle est déclenchée à chaque fois que l’appui sur une touche modifie le contenu.

‘all’ Lorsque l’une quelconque des situations précédentes a lieu.

‘none’ Désactive la validation. C’est la valeur par défaut de l’option. Notez que c’est la chaîne de caractère ‘none’, non la valeur spéciale de Python None.

 

La valeur de l’option validatecommand dépend des arguments que vous souhaitez voir transmis à la fonction de validation.

 

- Peut-être que la seule chose dont à besoin votre fonction de validation est le texte qui apparaît actuellement dans le champ de saisie. Si c’est le cas, elle peut utiliser la méthode get() de la variable de contrôle qui a servi à configuer l’option textvariable du champ de saisie.Dans ce cas, il suffit d’indiquer validatecommand=f, où f est le nom de votre fonction de validation.

 

- Tkinter peut aussi fournir un certain nombre d’informations à votre fonction de validation. Si vous souhaitez utiliser cela, lors de l’appel du constructeur du champ de saisie, utilisez l’option validatecommand=(f, s1, s2, …), où f est le nom «enregistré» de votre fonction de rappel (avec la méthode register(), voir plus loin pour un exemple), et chaque élément si additionnel un code de substitution. Pour chaque code de substitution fourni, la fonction de rappel reçoit un argument positionnel qui contient la valeur appropriée.

 

Voici les codes de substitution possibles.

 

‘%d’ Code d’action: 0 pour une tentative de suppression, 1 pour une tentative d’insertion ou -1 si l’appel a eu lieu par gain ou perte du focus, ou par modification de la variable de contrôle textvariable.

‘%i’ Lorque l’utilisateur tente d’insérer ou de supprimer du texte, cet argument sera la position (index) du début (cas d’une sélection) de l’insertion ou suppression. Si l’appel a eu lieu par gain ou perte de focus, ou par modification de la variable de contrôle textvariable, l’argument vaut -1.

‘%P’ La valeur que le texte aurait si la modification avait lieu.

‘%s’ Le texte du champ de saisie avant le changement.

‘%S’ Si l’appel est du à une insertion ou une suppression, l’argument sera le texte à insérer ou à supprimer.

‘%v’ The current value of the widget’s validate option.

‘%V’ La raison de l’appel, parmi: ‘focusin’, ‘focusout’, ‘key’, ou ‘forced’ si la variable de contrôle textvariable a été modifiée.

‘%W’ Le nom du champ de saisie.

 

Voici un petit exemple. Supposez que vous souhaitiez que votre fonction de validation reçoive le ‘%d’ pour déterminer les circonstances de son appel; ‘%i’ pour déterminer où l’ajout ou la suppression doit avoir lieu; et ‘%S’ pour déterminer ce qui doit être inséré ou supprimé. Votre fonction pourrait ressembler à cela:

 

def estOK(pourquoi, ou, quoi):
 ...

 

Ensuite, vous utilisez la méthode universelle register() pour «emballer» cette fonction. Nous supposons que w est un widget arbitraire:

 

okCommand = w.register(estOK)

 

Pour activer cette fonction de rappel, vous aurez besoin d’utiliser ces deux options du constructeur Entry:

 

saisi = Entry(root, validate='all',
  validatecommand=(okCommand, '%d', '%i', '%S'), ...)

 

Supposez que le champ de saisie contienne actuellement la chaîne ‘abcdefg’, et que l’utilisateur sélectionne ‘cde’ puis appuie sur la touche Retour Arrière. Il s’ensuivrait l’appel estOK(0,2,’cde’): 0 pour indiquer la suppression, 2 pour la position avant le ‘c’ et ‘cde’ pour la chaîne à détruire. Si estOK() retourne True, le nouveau texte est ‘abfg’; sinon, le texte est inchangé.

Le widget Entry possède aussi une option invalidcommand qui sert à préciser une fonction de rappel qui est appelée à chaque fois que la fonction de validation retourne False. Cette commande peut modifier le texte du champ de saisie en utilisant la méthode set() de la variable de contrôle qui a servi à configurer l’option textvariable. Le réglage de cette option fonctionne de la même façon que celle de l’option validatecommand. Vous devez utiliser la méthode universelle register() pour envelopper votre fonction; cette méthode retourne le nom de la fonction enveloppée sous la forme d’une chaîne de caractères. Ensuite, passez cette valeur à l’option invalidcommand soit directement, soit comme le premier élément d’un tuple qui contient les codes de substitution qui vous intéressent.

Spinbox Widget

Spinbox widget is a variant of the standard Tkinter Entry widget, which can be used to select from a fixed number of values.

The Spinbox widget can be used instead of an ordinary Entry, in cases where the user only has a limited number of ordered values to choose from.

Note that the spinbox widget is only available Python 2.3 and later, when linked against Tk 8.4 or later. Also note that several Tk spinbox methods appears to be missing from the Tkinter bindings in Python 2.3.

Patterns

The spinbox behaves pretty much like an ordinary Entry widget. The main difference is that you can specify what values to allow, either as a range, or using a tuple.

from Tkinter import *
master = Tk()
w = Spinbox(master, from_=0, to=10)
w.pack()
mainloop()

You can specify a set of values instead of a range:

w = Spinbox(values=(1, 2, 4, 8))
w.pack()

Reference

Spinbox(master=None, **options) (class) [#]

A spinbox widget.

master Parent widget.

**options Widget options. See the description of the config method for a list of available options.

bbox(index) [#]

Returns the bounding box of a given character.

config(**options) [#]

Modifies one or more widget options. If no options are given, the method returns a dictionary containing all current option values.

**options Widget options.

activebackground= Default is system specific. (activeBackground/Background)

background= Default is system specific. (background/Background)

bd= Same as borderwidth.

bg= Same as background.

borderwidth= Widget border width. The default is system specific, but is usually a few pixels. (borderWidth/BorderWidth)

buttonbackground= Button background color. Default is system specific. (Button.background/Background)

buttoncursor= Cursor to use when the mouse pointer is moved over the button part of this widget. No default value. (Button.cursor/Cursor)

buttondownrelief= The border style to use for the up button. Default is RAISED. (Button.relief/Relief)

buttonuprelief= The border style to use for the down button. Default is RAISED. (Button.relief/Relief)

command= A function or method that should be called when a button is pressed. No default value. (command/Command)

cursor= The cursor to use when the mouse pointer is moved over the entry part of this widget. Default is a text insertion cursor (usually XTERM). (cursor/Cursor)

disabledbackground= The background color to use when the widget is disabled. The default is system specific. (disabledBackground/DisabledBackground)

disabledforeground= The text color to use when the widget is disabled. The default is system specific. (disabledForeground/DisabledForeground)

exportselection= Default is True. (exportSelection/ExportSelection)

fg= Same as foreground.

font= The font to use in this widget. Default is system specific. (font/Font)

foreground= Text color. Default is system specific. (foreground/Foreground)

format= Format string. No default value. (format/Format)

from= The minimum value. Used together with to to limit the spinbox range.

Note that from is a reserved Python keyword. To use this as a keyword argument, add an underscore (from_). (from/From)

highlightbackground= Default is system specific. (highlightBackground/HighlightBackground)

highlightcolor= Default is system specific. (highlightColor/HighlightColor)

highlightthickness= No default value. (highlightThickness/HighlightThickness)

increment= Default is 1.0. (increment/Increment)

insertbackground= Color used for the insertion cursor. (insertBackground/Foreground)

insertborderwidth= Width of the insertion cursor’s border. If this is set to a non-zero value, the cursor is drawn using the RAISED border style. (insertBorderWidth/BorderWidth)

insertofftime= Together with insertontime, this option controls cursor blinking. Both values are given in milliseconds. (insertOffTime/OffTime)

insertontime= See insertofftime. (insertOnTime/OnTime)

insertwidth= Width of the insertion cursor. Usually one or two pixels. (insertWidth/InsertWidth)

invalidcommand= No default value. (invalidCommand/InvalidCommand)

invcmd= Same as invalidcommand.

justify= Default is LEFT. (justify/Justify)

readonlybackground= Default is system specific. (readonlyBackground/ReadonlyBackground)

relief= Default is SUNKEN. (relief/Relief)

repeatdelay= Together with repeatinterval, this option controls button auto-repeat. Both values are given in milliseconds. (repeatDelay/RepeatDelay)

repeatinterval= See repeatdelay. (repeatInterval/RepeatInterval)

selectbackground= Default is system specific. (selectBackground/Foreground)

selectborderwidth= No default value. (selectBorderWidth/BorderWidth)

selectforeground= Default is system specific. (selectForeground/Background)

state= One of NORMAL, DISABLED, or “readonly”. Default is NORMAL. (state/State)

takefocus= Indicates that the user can use the Tab key to move to this widget. Default is an empty string, which means that the entry widget accepts focus only if it has any keyboard bindings (default is on, in other words). (takeFocus/TakeFocus)

textvariable= No default value. (textVariable/Variable)

to= See from. (to/To)

validate= Validation mode. Default is NONE. (validate/Validate)

validatecommand= Validation callback. No default value. (validateCommand/ValidateCommand)

values= A tuple containing valid values for this widget. Overrides from/to/increment. (values/Values)

vcmd= Same as validatecommand.

width= Widget width, in character units. Default is 20. (width/Width)

wrap= If true, the up and down buttons will wrap around. (wrap/Wrap)

xscrollcommand=

Used to connect a spinbox field to a horizontal scrollbar. This option should be set to the set method of the corresponding scrollbar. (xScrollCommand/ScrollCommand)

delete(first, last=None) [#]

Deletes one or more characters from the spinbox.

get() [#]

Returns the current contents of the spinbox.

Returns:

The widget contents, as a string.

icursor(index) [#]

Moves the insertion cursor to the given index. This also sets the INSERT index.

index

Where to move the cursor.

identify(x, y) [#]

Identifies the widget element at the given location.

Returns:

One of “none”, “buttondown”, “buttonup”, or “entry”.

index(index) [#]

Gets the numerical position corresponding to the given index.

index

An index.

Returns:

The corresponding numerical index.

insert(index, text) [#]

Inserts text at the given index. Use insert(INSERT, text) to insert text at the cursor, insert(END, text) to append text to the spinbox.

index

Where to insert the text.

string

The text to insert.

invoke(element) [#]

Invokes a spinbox button.

element

What button to invoke. Must be one of “buttonup” or “buttondown”.

scan_dragto(x) [#]

Sets the scanning anchor for fast horizontal scrolling to the given mouse coordinate.

x

Current horizontal mouse position.

scan_mark(x) [#]

Scrolls the widget contents sideways according to the given mouse coordinate. The text is moved 10 times the distance between the scanning anchor and the new position.

x

Current horizontal mouse position.

selection_adjust(index) [#]

Adjusts the selection to include also the given character. If index is already selected, do nothing.

index

The index.

selection_clear() [#]

Clears the selection.

selection_element(element=None) [#]

Selects an element. If no element is specified, this method returns the current element.

 

—