Vous êtes à peu près ici : Accueil  »   tutoriel PyGTK  »   PyGTK : sommaire

13.2. TextView : la zone de texte

Il n'y a qu'une fonction pour créer un nouveau widget TextView.

  textview = gtk.TextView(buffer=None)

Le fait de créer une TextView entraîne aussi la création d'un TextBuffer et d'une TextTagTable par défaut qui lui seront associés. Si vous souhaitez utiliser un TextBuffer existant pour votre TextView, spécifiez-le dans la méthode ci-dessus. Pour changer le TextBuffer utilisé par une TextView, utilisez la méthode suivante :

  textview.set_buffer(buffer)

Utilisez la méthode suivante pour obtenir une référence au TextBuffer d'une TextView :

  buffer = textview.get_buffer()

Le widget TextView n'a pas de barres de défilement pour ajuster la vue quand le texte dépasse de la fenêtre. Pour lui en donner, vous devez placer votre TextView dans une ScrolledWindow (pas encore traduit) .

Vous pouvez utiliser une TextView pour permettre à l'utilisateur d'éditer un texte ou bien pour afficher plusieurs lignes d'un texte en lecture seule. Pour passer d'un mode à l'autre, faites appel à la méthode suivante :

  textview.set_editable(choix)

L'argument choix prend la valeur TRUE ou FALSE pour préciser si l'utilisateur est autorisé à éditer le contenu du widget TextView ou non. Le mode d'édition de la TextView peut être modifié pour des portions de texte du TextBuffer par l'intermédiaire des TextTag.

On retrouve le mode d'édition courant avec la méthode suivante :

  edition = textview.get_editable()

Lorsque la TextView n'est pas éditable, vous devriez probablement masquer le curseur en utilisant cette méthode :

  textview.set_cursor_visible(choix)

L'argument choix prend la valeur TRUE ou FALSE pour préciser si le curseur doit être visible.

Le widget TextView peut ajuster la largeur du texte à la fenêtre d'affichage grâce au retour à la ligne automatique. Cette option n'est pas activée par défaut mais peut l'être à tout moment grâce à la méthode qui suit :

  textview.set_wrap_mode(choix)

Cette méthode vous permet d'indiquer si la coupure du retour à la ligne automatique doit s'effectuer après le dernier caractère de la ligne, ou bien si ce dernier doit préserver l'intégrité des mots. L'argument choix est à choisir parmi :

  gtk.WRAP_NONE    # pas de retour à la ligne automatique
  gtk.WRAP_CHAR    # couper après le dernier caractère de la ligne
  gtk.WRAP_WORD    # couper après le dernier mot de la ligne

L'alignement par défaut du texte peut être défini et récupéré avec les méthodes :

  textview.set_justification(alignement)
  alignement = textview.get_justification()

alignement peut être :

  gtk.JUSTIFY_LEFT      # aligné à gauche
  gtk.JUSTIFY_RIGHT     # aligné à droite
  gtk.JUSTIFY_CENTER    # centré

Remarque

Le texte sera aligné à gauche (JUSTIFY_LEFT) si le retour à la ligne automatique est désactivé (WRAP_NONE). L'alignement par défaut peut toutefois être modifié avec des TextTag dans le TextBuffer correspondant.

Parmi les autres attributs de texte, la marge gauche, la marge droite, les tabulations et l'indentation des paragraphes peuvent être définis et récupérés avec les méthodes suivantes :

  textview.set_left_margin(marge_gauche)
  marge_gauche = textview.get_left_margin()
  
  textview.set_right_margin(marge_droite)
  marge_droite = textview.get_right_margin()
  
  textview.set_indent(indentation)
  indentation = textview.get_indent()
  
  textview.set_pixels_above_lines(pixels_au_dessus_de_la_ligne)
  pixels_au_dessus_de_la_ligne = textview.get_pixels_above_lines()
  
  textview.set_pixels_below_lines(pixels_au_dessous_de_la_ligne)
  pixels_au_dessous_de_la_ligne = textview.get_pixels_below_lines()
  
  textview.set_pixels_inside_wrap(pixels_retour_a_la_ligne)
  pixels_retour_a_la_ligne = textview.get_pixels_inside_wrap()
  
  textview.set_tabs(tabulations)
  tabulations = textview.get_tabs()

marge_gauche, marge_droite, indentation, pixels_au_dessus_de_la_ligne, pixels_au_dessous_de_la_ligne et pixels_retour_a_la_ligne doivent être indiqués en pixels. Ces valeurs par défaut peuvent être modifiées en employant des TextTag dans le TextBuffer correspondant. tabs doit être un pango.TabArray.

Le programme d'exemple textview-basic.py illustre l'utilisation basique du widget TextView :

Figure 13.1. Exemple basique de TextView

exemple textview simple

Le code source du programme est le suivant :

     1   #!/usr/bin/env python
     2   
     3   # exemple textview-basic.py
     4     
     5   import pygtk
     6   pygtk.require('2.0')
     7   import gtk
     8   
     9   class ExempleTextView:
    10       def change_editable(self, case, textview):
    11           textview.set_editable(case.get_active())
    12   
    13       def change_curseur_visible(self, case, textview):
    14           textview.set_cursor_visible(case.get_active())
    15   
    16       def change_marge_gauche(self, case, textview):
    17           if case.get_active():
    18               textview.set_left_margin(50)
    19           else:
    20               textview.set_left_margin(0)
    21   
    22       def change_marge_droite(self, case, textview):
    23           if case.get_active():
    24               textview.set_right_margin(50)
    25           else:
    26                textview.set_right_margin(0)
    27   
    28       def change_retour_ligne(self, boutonradio, textview, val):
    29           if boutonradio.get_active():
    30               textview.set_wrap_mode(val)
    31   
    32       def change_alignement(self, boutonradio, textview, val):
    33           if boutonradio.get_active():
    34               textview.set_justification(val)
    35   
    36       def fermer_application(self, widget):
    37           gtk.main_quit()
    38   
    39       def __init__(self):
    40           fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
    41           fenetre.set_resizable(True)
    42           fenetre.connect("destroy", self.fermer_application)
    43           fenetre.set_title("Exemple de widget TextView simple")
    44           fenetre.set_border_width(0)
    45   
    46           boite1 = gtk.VBox(False, 0)
    47           fenetre.add(boite1)
    48           boite1.show()
    49   
    50           boite2 = gtk.VBox(False, 10)
    51           boite2.set_border_width(10)
    52           boite1.pack_start(boite2, True, True, 0)
    53           boite2.show()
    54   
    55           fd = gtk.ScrolledWindow()
    56           fd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
    57           textview = gtk.TextView()
    58           buffertexte = textview.get_buffer()
    59           fd.add(textview)
    60           fd.show()
    61           textview.show()
    62   
    63           boite2.pack_start(fd)
    64           # Chargement du fichier textview-basic.py dans la fenetre
    65           fichier = open("textview-basic.py", "r")
    66   
    67           if fichier:
    68               chaine = fichier.read()
    69               fichier.close()
    70               buffertexte.set_text(chaine)
    71   
    72           boiteH = gtk.HButtonBox()
    73           boite2.pack_start(boiteH, False, False, 0)
    74           boiteH.show()
    75   
    76           boiteV = gtk.VBox()
    77           boiteV.show()
    78           boiteH.pack_start(boiteV, False, False, 0)
    79           # case a cocher pour autoriser l'edition du texte
    80           case = gtk.CheckButton("Editable")
    81           boiteV.pack_start(case, False, False, 0)
    82           case.connect("toggled", self.change_editable, textview)
    83           case.set_active(True)
    84           case.show()
    85           # case a cocher pour afficher le curseur
    86           case = gtk.CheckButton("Curseur visible")
    87           boiteV.pack_start(case, False, False, 0)
    88           case.connect("toggled", self.change_curseur_visible, textview)
    89           case.set_active(True)
    90           case.show()
    91           # case a cocher pour afficher une marge gauche
    92           case = gtk.CheckButton("Marge gauche")
    93           boiteV.pack_start(case, False, False, 0)
    94           case.connect("toggled", self.change_marge_gauche, textview)
    95           case.set_active(False)
    96           case.show()
    97           # case a cocher pour afficher une marge droite
    98           case = gtk.CheckButton("Marge droite")
    99           boiteV.pack_start(case, False, False, 0)
   100           case.connect("toggled", self.change_marge_droite, textview)
   101           case.set_active(False)
   102           case.show()
   103           # boutons radio pour definir le type de retour a la ligne automatique
   104           boiteV = gtk.VBox()
   105           boiteV.show()
   106           boiteH.pack_start(boiteV, False, False, 0)
   107           radio = gtk.RadioButton(None, "WRAP__NONE")
   108           boiteV.pack_start(radio, False, True, 0)
   109           radio.connect("toggled", self.change_retour_ligne, textview, gtk.WRAP_NONE)
   110           radio.set_active(True)
   111           radio.show()
   112           radio = gtk.RadioButton(radio, "WRAP__CHAR")
   113           boiteV.pack_start(radio, False, True, 0)
   114           radio.connect("toggled", self.change_retour_ligne, textview, gtk.WRAP_CHAR)
   115           radio.show()
   116           radio = gtk.RadioButton(radio, "WRAP__WORD")
   117           boiteV.pack_start(radio, False, True, 0)
   118           radio.connect("toggled", self.change_retour_ligne, textview, gtk.WRAP_WORD)
   119           radio.show()
   120   
   121           # boutons radio pour definir l'alignement
   122           boiteV = gtk.VBox()
   123           boiteV.show()
   124           boiteH.pack_start(boiteV, False, False, 0)
   125           radio = gtk.RadioButton(None, "JUSTIFY__LEFT")
   126           boiteV.pack_start(radio, False, True, 0)
   127           radio.connect("toggled", self.change_alignement, textview,
   128                         gtk.JUSTIFY_LEFT)
   129           radio.set_active(True)
   130           radio.show()
   131           radio = gtk.RadioButton(radio, "JUSTIFY__RIGHT")
   132           boiteV.pack_start(radio, False, True, 0)
   133           radio.connect("toggled", self.change_alignement, textview,
   134                         gtk.JUSTIFY_RIGHT)
   135           radio.show()
   136           radio = gtk.RadioButton(radio, "JUSTIFY__CENTER")
   137           boiteV.pack_start(radio, False, True, 0)
   138           radio.connect("toggled", self.change_alignement, textview,
   139                         gtk.JUSTIFY_CENTER)
   140           radio.show()
   141   
   142           separateur = gtk.HSeparator()
   143           boite1.pack_start(separateur, False, True, 0)
   144           separateur.show()
   145   
   146           boite2 = gtk.VBox(False, 10)
   147           boite2.set_border_width(10)
   148           boite1.pack_start(boite2, False, True, 0)
   149           boite2.show()
   150   
   151           bouton = gtk.Button("Fermer")
   152           bouton.connect("clicked", self.fermer_application)
   153           boite2.pack_start(bouton, True, True, 0)
   154           bouton.set_flags(gtk.CAN_DEFAULT)
   155           bouton.grab_default()
   156           bouton.show()
   157           fenetre.show()
   158   
   159   def main():
   160       gtk.main()
   161       return 0
   162   
   163   if __name__ == "__main__":
   164       ExempleTextView()
   165       main()

Aux lignes 10 à 34, on définit les fonctions de rappel des cases à cocher et des boutons radio, que l'on utlisera pour changer les attributs par défaut de la TextView. Aux lignes 55 à 63, on crée une ScrolledWindowpour contenir la TextView. La ScrolledWindow est placée dans une VBox avec les cases à cocher et les boutons radio créés aux lignes 72 à 140. Le TextBuffer associé à la TextView est chargé avec le contenu du fichier source aux lignes 64 à 70.