Ceci est un exemple de Gtk.TextView.
En appuyant sur « Entrée », nous créons une nouvelle ligne.
Mais il peut également y avoir un retour à la ligne si nous écrivons une longue phrase (la césure se fait entre deux mots).
Si nous avons un loooooooooooooooooooooooooooooooooooong
(long comme ça)
mot, une barre de défilement horizontale apparaît.
from gi.repository import Gtk
import sys
class MyWindow(Gtk.ApplicationWindow):
def __init__(self, app):
Gtk.Window.__init__(self, title="TextView Example", application=app)
self.set_default_size(300, 450)
# a scrollbar for the child widget (that is going to be the textview)
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_border_width(5)
# we scroll only if needed
scrolled_window.set_policy(
Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
# a text buffer (stores text)
buffer1 = Gtk.TextBuffer()
# a textview (displays the buffer)
textview = Gtk.TextView(buffer=buffer1)
# wrap the text, if needed, breaking lines in between words
textview.set_wrap_mode(Gtk.WrapMode.WORD)
# textview is scrolled
scrolled_window.add(textview)
self.add(scrolled_window)
class MyApplication(Gtk.Application):
def __init__(self):
Gtk.Application.__init__(self)
def do_activate(self):
win = MyWindow(self)
win.show_all()
def do_startup(self):
Gtk.Application.do_startup(self)
app = MyApplication()
exit_status = app.run(sys.argv)
sys.exit(exit_status)
Un Gtk.TextView affiche le texte stocké dans le tampon d'un Gtk.TextBuffer. Cependant, la plupart des manipulations de texte se font avec des itérateurs représentés par un Gtk.TextIter - une position entre deux caractères dans le tampon du texte. Les itérateurs ne restent pas valides indéfiniment ; à chaque fois que le tampon se trouve modifié d'une façon qui affecte son contenu, tous les itérateurs en cours deviennent non valides. À cause de cela, les itérateurs ne peuvent pas être utilisés pour préserver les positions en cas de modifications du tampon. Pour préserver une position, nous utilisons donc un marqueur Gtk.TextMark, qui peut être rendu visible avec visible(True). Un tampon de texte contient deux marqueurs intégrés : un marqueur « insert » (la position du curseur) et un marqueur « selection_bound » (limite de sélection).
Méthodes pour un élément graphique TextView :
L'élément graphique TextView est modifiable par défaut. Si vous préférez le contraire, utilisez set_editable(False). Si le tampon ne contient pas de texte modifiable, c'est une bonne idée d'utiliser set_cursor_visible(False) aussi.
La justification du texte est définie par set_justification(Gtk.Justification.JUSTIFICATION) où JUSTIFICATION est l'une des valeurs LEFT, RIGHT, CENTER, FILL.
La césure du texte est définie par set_wrap_mode(Gtk.WrapMode.WRAP) où WRAP est une des valeurs NONE (la zone de texte s'élargit), CHAR (fait la césure n'importe où le curseur peut apparaître), WORD (fait la césure entre deux mots), WORD_CHAR (fait la césure entre deux mots, mais si cela ne suffit pas, la fait entre deux caractères).
Méthodes pour un élément graphique TextBuffer :
La méthode get_insert() retourne le marqueur Gtk.TextMark qui représente le curseur, c'est-à-dire le point d'insertion.
La méthode get_selection_bound() renvoie le marqueur Gtk.TextMark qui représente les limites de la sélection.
La méthode set_text("du texte", longueur) où longueur est un nombre entier positif ou -1 définit le contenu du tampon comme étant les longueur premiers caractères du texte du texte. Si longueur est omis ou égal à -1, tout le texte est inséré. Le contenu du tampon, s'il existe, est détruit.
La méthode insert(iter, "du texte", longueur), où iter est un itérateur et longueur est un nombre entier positif ou -1, insère dans le tampon à l'endroit de iter les longueur premiers caractères du texte du texte. Si longueur est omis ou égal à -1, tout le texte est inséré.
La méthode insert_at_cursor("du texte", longueur) effectue la même action que insert(iter, "du texte", length), avec le curseur actuel comme iter.
La méthode create_mark("nom_marqueur", iter, left_gravity), où iter est un Gtk.TextIter et left_gravity une valeur booléenne, crée un marqueur Gtk.TextMark à l'emplacement de l'iter. Si la valeur de "nom_marqueur" est None, le marqueur est anonyme ; sinon, le marqueur peut être récupéré par son nom avec get_mark(). Si un marqueur possède la propriété left_gravity et que le texte est inséré à son emplacement actuel, alors le marqueur est déplacé à gauche du texte qui vient d'être inséré. Si la valeur left_gravity est omise, alors la valeur False est utilisée par défaut.
Pour indiquer qu'un morceau de texte du tampon doit être formatée spécifiquement, vous devez définir une étiquette contenant cette information de formatage et ensuite l'appliquer à la portion de texte en utilisant create_tag("nom etiquette", propriété) et apply_tag(tag, start_iter, end_iter), par exemple comme ceci :
etiquette = textbuffer.create_tag("fond_orange", background="orange")
textbuffer.apply_tag(etiquette, start_iter, end_iter)
Voici quelques styles les plus usuels appliqués à du texte :
Couleur d'arrière-plan (propriété « background »)
Couleur de premier plan (propriété « foreground »)
Souligné (propriété « underline »)
Gras (propriété « weight »)
Italique (propriété « style »)
Barré (propriété « strikethrough »)
Justifié (propriété « justification »)
Taille (propriétés « size » et « size-points »)
Césure (propriété « wrap-mode »)
Vous pouvez aussi supprimer par la suite certaines étiquettes en particulier avec remove_tag(), ou supprimer toutes celles d'une région donnée avec remove_all_tags().
Méthodes pour un élément graphique TextIter
La méthode forward_search(needle, flags, limit) effectue une recherche en avant de needle (cible). La recherche ne s'effectue pas au delà de l'itérateur Gtk.TextIter. Les flags (drapeaux) peuvent être définis comme l'un des éléments suivants, ou comme n'importe quelle combinaison de l'un d'eux, en les concaténant avec l'opérateur binaire OR | : 0 (la correspondance doit être exacte) ; Gtk.TextSearchFlags.VISIBLE_ONLY (la correspondance peut contenir du texte invisible intercalé dans la sélection) ; Gtk.TextSearchFlags.TEXT_ONLY (la correspondance peut contenir des pixbufs ou des éléments graphiques enfants mélangés dans la sélection) ; Gtk.TextSearchFlags.CASE_INSENSITIVE (la correspondance n'est pas sensible à la casse). La méthode renvoie un tuple contenant un Gtk.TextIter qui pointe vers le début et vers le premier caractère après la correspondance ; s'il n'y a pas de correspondance, elle renvoie la valeur None.
La méthode backward_search(needle, flags, limit) effectue les même actions que forward_search(), mais en arrière.
Dans cet exemple, les éléments suivants sont utilisés :
GtkTextView
GtkTextBuffer
GtkTextTag
GtkScrolledWindow
Standard Enumerations