Les zones de texte
1. Présentation
Nous avons appris à saisir une ligne tapée par l'utilisateur grâce à gtk.Entry mais comment fait-on pour saisir plusieurs lignes (comme le font les traitements de texte, etc.). Et bien nous utilisons non pas un mais trois widgets !- gtk.TextBuffer? : ce widget non-graphique sert à stocker les données. C'est tout simplement un buffer !
- gtk.TextView? : ce widget sert à afficher le contenu d'un gtk.TextBuffer?. Il s'occupe de tout ce qui est graphique : il gère les évènements de l'utilisateur, les insertions de caractères, etc.
- gtk.TextIter? : ce widget non-graphique désigne une position dans gtk.TextBuffer?. Il permet de manipuler gtk.TextBuffer?.
1.1 Hiérarchie
gobject.GObject -> gtk.Object -> gtk.Widget -> gtk.Container -> gtk.TextView?gobject.GObject -> gtk.TextBuffer?
gtk.TextIter?
2. Utilisation de base
2.1 Création
Pour créer un gtk.TextView?, nous devons utiliser ce constructeur :text_view = gtk.TextView?(buffer = None)
Si on ne passe pas de paramèètre, ce constructeur crée un gtk.TextView? vierge, c'est-à-dire qu'elle s'occupe de la création du gtk.TextBuffer? qui sera utilisée pour l'affichage. Mais on peut aussi définir à l'avance le gtk.TextBuffer? qui sera utilisé (qu'il soit vide ou non) pour l'affichage à l'aide du paramètre buffer.Maintenant que notre gtk.TextView? est créée, il ne reste plus qu'à l'insérer dans un container pour l'afficher.
2.2 Accéder au contenu de gtk.TextBuffer?
Dans un premier temps, avant de pouvoir accéder au contenu d'un gtk.TextBuffer?, il faut avoir une référence sur cet élément. Si lors de la création du gtk.TextView? nous avons spécifié un gtk.TextBuffer? déjà existant, il n'y a aucun problème, par contre si nous avons utiliser le constructeur sans paramètre, il va falloir récupérer la référence du gtk.TextBuffer? avec cette méthode :text_buffer = text_view.get_buffer()
Maintenant nous pouvons récupérer le texte du gtk.TextBuffer? avec cette méthode :text_buffer.get_text(start, end, include_hidden_chars=True)
Les paramètres start et end marquent respectivement le début et la fin du texte que l'on veut récupérer. Et le dernier paramètre include_hidden_chars permet de définir si l'on veut ou pas récupérer les caractères invisibles (par exemple les gtk.TextTag? ou les gtk.TextMark?). Par défaut, ce paramètre est défini à True.Comme nous pouvons le voir d'après la méthode précédente, nous allons utiliser des gtk.TextIter? pour délimiter le texte que nous voulons récupérer. Les gtk.TextIter? donne en fait la position donnée, à un moment donné, du curseur, d'un caractère ou autre dans le buffer. Il faut cependant faire attention que dès que le gtk.TextBuffer? est modifié, un gtk.TextIter? pointé à un endroit précis du gtk.TextBuffer? n'est plus valide même si sa position n'a théoriquement pas changé.
Nous allons terminer par étudier deux méthodes permettant d'obtenir le gtk.TextIter? marquant le début et la fin d'un gtk.TextBuffer? :
get_start_iter()
get_end_iter()
La première méthode permet d'obtenir le gtk.TextIter? marquant le début du gtk.TextBuffer? et la deuxième méthode celui permettant d'en marquer la fin.2.3 Programme exemple
Nous allons créer une fenêtre contenant un gtk.TextView? et un gtk.Button. Lorsque l'on clique sur le gtk.Button, l'intégralité du gtk.TextView? est alors affiché dans une gtk.Dialog.
# -*- encoding: utf-8 -*-
import pygtk
pygtk.require('2.0')
import gtk
def main():
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_default_size(320, 200)
window.set_title('gtk.TextView')
window.connect('destroy', gtk.main_quit, 0)
box = gtk.VBox(spacing=5)
window.add(box)
text_view = gtk.TextView()
box.pack_start(text_view)
button = gtk.Button('Afficher')
box.pack_start(button, False, False)
button.connect('clicked', on_show, text_view)
window.show_all()
gtk.main()
def on_show(button, text_view):
# On récupère le buffer
text_buffer = text_view.get_buffer()
# On récupère l'origine du buffer
start_iter = text_buffer.get_start_iter()
# On récupère la fin du buffer
end_iter = text_buffer.get_end_iter()
# On copie le contenu du buffer dans une variable
str_buffer = text_buffer.get_text(start_iter, end_iter)
# On affiche le texte dans une boite de dialogue
dialog = gtk.MessageDialog(flags = gtk.DIALOG_MODAL,
type = gtk.MESSAGE_INFO,
buttons = gtk.BUTTONS_OK,
message_format = 'Votre texte : ' + str_buffer)
dialog.run()
dialog.destroy()
if __name__ == '__main__':
main()
Résultat
3. Afficher le contenu d'un fichier
Maintenant, nous allons utiliser ce que nous avons vu dans les deux précédents chapitres afin de créer une application ouvrant un fichier et affichant son contenu.3.1 Construction de l'application
Dans un premier temps, nous allons utiliser le widget gtk.ScrolledWindow? pour y insérer notre gtk.TextView?, puis nous allons demander à l'utilisateur de choisir un nom de fichier à l'aide du widget gtk.FileChooser?.Une fois le nom du fichier connu, nous allons utiliser des méthodes de Python pour ouvrir et lire le contenu du fichier. Cela ce fait à l'aide des méthodes suivantes :
str_buffer = '' file = open(filename) for line in file.readlines(): str_buffer += file.readlines() file.close()
Le paramètre filename est le nom du fichier à ouvrir. On récupère ainsi un objet fichier. La méthode readlines de cet objet fichier permet de récupérer une liste de toutes les lignes du fichier. On va donc parcourir cette liste et ajouter une à une les lignes dans notre buffer. Une fois cette opération terminée, il ne faudra bien sûr pas oublier de fermer le fichier.
Nous allons ensuite vider le contenu du gtk.TextBuffer? à l'aide de cette méthode :
text_buffer.delete(start, end)
Et pour finir nous allons ajouter notre texte dans le buffer avec cette méthode :text_buffer.insert(iter, text)
Le paramètre text est le texte que nous allons ajouter à notre gtk.TextBuffer? à la position donnée par le paramètre iter.3.2 Programme exemple
# -*- encoding: utf-8 -*-
import pygtk
pygtk.require('2.0')
import gtk
def main():
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_default_size(480, 480)
window.set_title('gtk.TextView')
window.connect('destroy', gtk.main_quit, 0)
box = gtk.VBox(spacing=5)
window.add(box)
scrolled = gtk.ScrolledWindow()
box.pack_start(scrolled, padding = 5)
text_view = gtk.TextView()
scrolled.add(text_view)
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
button = gtk.Button(stock = gtk.STOCK_OPEN)
box.pack_start(button, False, False)
button.connect('clicked', on_open, text_view)
window.show_all()
gtk.main()
def on_open(button, text_view):
str_buffer = ''
# Création de la fenêtre de sélection
file_chooser = gtk.FileChooserDialog('Ouvrir...',
buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
# On limite les actions à cette fenêtre
file_chooser.set_modal(True)
# Affichage fenêtre
if file_chooser.run() == gtk.RESPONSE_OK:
# Récupération du chemin
filename = file_chooser.get_filename()
file = open(filename)
for line in file.readlines():
str_buffer += line
file.close()
file_chooser.destroy()
# Récupération du buffer
text_buffer = text_view.get_buffer()
# Suppression des données du buffer
start_iter = text_buffer.get_start_iter()
end_iter = text_buffer.get_end_iter()
text_buffer.delete(start_iter, end_iter)
# Affichage du fichier
start_iter = text_buffer.get_start_iter()
text_buffer.insert(start_iter, str_buffer)
if __name__ == '__main__':
main()
Résultat
