La saisie de données
1. Présentation
Nous allons maintenant voir comment permettre à l'utilisateur final de saisir des données, qu'il s'agisse de texte ou de valeur numérique. Nous allons utiliser pour cela le widget GtkEntry qui défini une zone de texte (une ligne) dans lequel l'utilisateur peut taper du texte ou alors dans lequel le programme peut afficher une information.1.1 Hiérarchie
GObject -> GtkObject -> GtkWidget -> GtkEntry2. Utilisation de base
2.1 Création d'une GtkEntry
Pour créer une GtkEntry, nous avons à notre disposition une classe simple d'utilisation :entry = gtk.Entry()
2.2 Récupération de la donnée saisie
Afin de récupérer le texte qui a été saisi par l'utilisateur, il faut utiliser cette méthode :texte = entry.get_text()
Elle permet de récupérer le texte qui a été tapé par l'utilisateur dans le GtkEntry entry.2.3 Afficher un message dans la zone de texte
Pour afficher un message dans une GtkEntry, la méthode est :entry.set_text(text)
2.4 Limiter le nombre de caractères
Gtk+ nous offre la possibilité de limiter le nombre de caractères qu'un utilisateur peut saisir avec la méthode :entry.set_max_length(max)
Le paramètre max correspond bien sûr à la limite que nous voulons fixer.2.5 Programme exemple
Comme exemple, nous allons créer une fenêtre comportant un GtkEntry, un GtkButton et un GtkLabel. Le but sera d'afficher le texte du GtkEntry dans le GtkLabel. Cette opération s'effectuera lorsque l'utilisateur appuie sur la touche ENTREE à la fin de sa saisie (interception du signal "activate") ou lorsqu'il cliquera sur le GtkButton (interception du signal "clicked").# -*- Encoding: Latin-1 -*-
import gtk
class App:
pass
def OnUpdate(entry, data):
# Fonction callback execute lors du signal "activate"
# Recuperation de data
app = data
# Recuperation du texte contenu dans le GtkEntry
texte = app.entry.get_text()
# Modification du texte contenu dans le GtkLabel
app.label.set_text(texte)
def main():
app = App()
app.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
app.window.set_title("Le widget GtkEntry")
app.window.set_default_size(320, 200)
app.window.connect("destroy", gtk.main_quit, None)
app.vbox = gtk.VBox(True, 0)
app.window.add(app.vbox)
# Creation du GtkEntry
app.entry = gtk.Entry()
# Insertion du GtkEntry dans la GtkVBox
app.vbox.pack_start(app.entry, True, False, 0)
app.button = gtk.Button("Copier")
app.vbox.pack_start(app.button, True, False, 0)
app.label = gtk.Label()
app.vbox.pack_start(app.label, True, False, 0)
# Connexion du signal "activate" du GtkEntry
app.entry.connect("activate", OnUpdate, app)
# Connexion du signal "clicked" du GtkButton
# La donnee supplementaire est la GtkVBox pVBox
app.button.connect("clicked", OnUpdate, app)
app.window.show_all()
gtk.main()
if __name__ == '__main__':
main()
Résultats :
3. Utiliser la fonction mot de passe
3.1 Visibilité du texte
Généralement, lorsque nous tapons un mot de passe, nous souhaitons que celui-ci reste secret. Le widget GtkEntry permet cela grâce à cette méthode :entry.set_visibility(visible)
Il suffit donc de mettre le paramètre visible à False pour cacher le texte qui sera entré.A l'inverse, pour savoir si le texte entré sera visible ou pas, il faut utiliser cette méthode :
visibility = entry.get_visibility()
La valeur de retour sera, bien sûr, égale à True si le texte est visible et à False dans le cas contraire.3.2 Le caractère affiché
Par défaut, lorsque l'on ajoute du texte à un GtkEntry qui a son paramètre visible à False, GTK+ remplacera toutes les lettres par des '*'. Pour modifier celui-ci, il faut utiliser cette méthode :entry.set_invisible_char(ch)
Le paramètre ch correspond au caractère de remplacement que nous souhaitons. Celui-ci est de type gunichar qui correspond à l'encodage UCS-4. Bien que l'affichage de GTK+ se fasse avec l'encodage UTF-8, cela ne pose aucun problème car cette fois-ci, la conversion est faite automatiquement.Et pour terminer, la méthode permettant de connaître le caractère de remplacement est :
caractere = entry.get_invisble_char()
3.3 Programme exemple
Cette fois, nous allons reprendre l'exemple précédent en activant le mode "mot de passe" et en limitant la saisie à huit caractères. Nous modifierons aussi le caractère de remplacement '*' par '$'. De plus, nous allons regrouper tout le codedans une classe et utiliser une méthode comme fonction de callback. De ce fait, nous aurons accès à toutes les variables
de l'instance, donc le paramètre data de la fonction de callback est ici inutile.
# -*- encoding: Latin-1 -*-
import gtk
class Main:
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Le widget GtkEntry")
self.window.set_default_size(320, 200)
self.window.connect("destroy", gtk.main_quit, None)
self.vbox = gtk.VBox(True, 0)
self.window.add(self.vbox)
# Creation du GtkEntry
self.entry = gtk.Entry()
# Limitation du nombre de caracteres
self.entry.set_max_length(8)
# Mode mot de passe
self.entry.set_visibility(False)
# Modification du caractere affiche
self.entry.set_invisible_char('$')
# Insertion du GtkEntry dans la GtkVBox
self.vbox.pack_start(self.entry, True, False, 0)
self.button = gtk.Button("Copier")
self.vbox.pack_start(self.button, True, False, 0)
self.label = gtk.Label()
self.vbox.pack_start(self.label, True, False, 0)
# Connexion du signal "activate" du GtkEntry
self.entry.connect("activate", self.OnUpdate, None)
# Connexion du signal "clicked" du GtkButton
# La donnee supplementaire est la GtkVBox pVBox
self.button.connect("clicked", self.OnUpdate, None)
self.window.show_all()
gtk.main()
def OnUpdate(self, entry, data):
# Fonction callback execute lors du signal "activate"
# Recuperation du texte contenu dans le GtkEntry
texte = self.entry.get_text()
# Modification du texte contenu dans le GtkLabel
self.label.set_text(texte)
if __name__ == "__main__":
Main()
Résultat
