Apprendre à utiliser le module Python PyGTK 2.0

Vous pouvez récupérer le nombre de lignes d'un TextBuffer avec la méthode :

  nombre_lignes = bufferdetexte.get_line_count()

De la même manière, vous pouvez obtenir le nombre de caractères présents dans le TextBuffer :

  nombre_caract = bufferdetexte.get_char_count()

Lorsque le contenu du TextBuffer est modifié, le drapeau de modification est levé. L'état de ce drapeau peut être obtenu à l'aide de la méthode :

  modif = bufferdetexte.get_modified()

Si le programme sauvegarde le contenu du buffer, la méthode suivante peut réinitialiser le drapeau de modification :

  bufferdetexte.set_modified(choix)

On utilise les TextIterTextIterTextIterTextIter : les itérateurs de texte pour spécifier une position entre deux caractères d'un TextBuffer. Les méthodes du TextBuffer qui manipulent du texte s'en servent pour indiquer à quelle position elles doivent s'appliquer. Les TextIterTextIterTextIter : les itérateurs de texte possèdent de nombreuses méthodes qui seront décrites dans la section TextIterTextIter : les itérateurs de texte.

Les méthodes de TextBuffer basiques pour créer des TextIterTextIter : les itérateurs de texte sont :

  iter = bufferdetexte.get_iter_at_offset(n)

  iter = bufferdetexte.get_iter_at_line(x)

  iter = bufferdetexte.get_iter_at_line_offset(x, n)

  iter = bufferdetexte.get_iter_at_mark(marque)

get_iter_at_offset() crée un itérateur juste après le n^e caractère à partir du début du TextBuffer.

get_iter_at_line() crée un itérateur juste avant le premier caractère de la x^e ligne.

get_iter_at_line_offset() crée un itérateur juste après le n^e caractère de la x^e ligne.

get_iter_at_mark() crée un itérateur à la même position que la TextMarkTextMark : les marques de texte marque.

Le méthode qui suit crée un ou plusieurs TextIterTextIter : les itérateurs de texte à des emplacements spécifiques du buffer :

  iterdebut = bufferdetexte.get_start_iter()

  iterfin = bufferdetexte.get_end_iter()

  iterdebut, iterfin = bufferdetexte.get_bounds()

  debut, fin = bufferdetexte.get_selection_bounds()

get_start_iter() crée un itérateur juste avant le premier caractère du buffer.

get_end_iter() crée un itérateur juste après le dernier caractère du buffer.

get_bounds() crée un tuple de deux itérateurs respectivement situés juste avant le premier caractère et juste après le dernier caractère du buffer.

get_selection_bounds() crée un tuple de deux itérateurs aux mêmes positions que les marques insert et selection_bound du buffer.

Le texte contenu par un TextBuffer peut être défini avec la méthode suivante :

  bufferdetexte.set_text(texte)

Cette méthode remplace le contenu actuel de bufferdetexte par texte.

La méthode la plus générale pour insérer des caractères dans un TextBuffer est :

  bufferdetexte.insert(iter, texte)

où l'on insère le texte texte à l'emplacement de bufferdetexte spécifié par iter.

Si vous souhaitez simuler une insertion de texte par un utilisateur interactif, faites appel à la méthode suivante :

  resultat = bufferdetexte.insert_interactive(iter, texte, defaut_editable)

qui insérera texte dans le buffer, à la position spécifiée par iter, mais seulement si cette position est éditable (c'est-à-dire si elle ne porte pas de balise mentionnant que le texte est non éditable) et que la valeur de defaut_editable est TRUE. Le résultat indique si le texte a été inséré.

L'argument defaut_editable précise si un texte peut être édité dans le cas où il ne porte pas de balise le spécifiant ; defaut_editable est généralement déterminé par un appel à la méthode get_editable() du TextViewTextView : la zone de texte.

D'autres méthodes existent pour insérer du texte :

  bufferdetexte.insert_at_cursor(texte)

  resultat = bufferdetexte.insert_at_cursor_interactive(texte, defaut_editable)

  bufferdetexte.insert_range(iter, debut, fin)

  resultat = bufferdetexte.insert_range_interactive(iter, debut, fin, defaut_editable)

insert_at_cursor() est une méthode pratique pour insérer du texte à l'emplacement courant du curseur (insert).

insert_range() copie le texte, les pixbufs et les balises compris entre les itérateurs debut et fin d'un TextBuffer (si ce TextBuffer n'est pas bufferdetexte, la table des balises doit être la même), puis colle le tout dans bufferdetexte à l'emplacement indiqué par iter.

Les versions interactives de ces méthodes opèrent de la même manière à la différence qu'elles n'insèrent la copie que si l'emplacement est éditable.

Enfin, on peut insérer du texte et lui appliquer des balises en même temps par l'intermédiaire des méthodes :

  bufferdetexte.insert_with_tags(iter, texte, balise1, balise2, ...)
  
  bufferdetexte.insert_with_tags_by_name(iter, texte, nom_balise1, nom_balise2, ...)

insert_with_tags() insère le texte dans le bufferdetexte, à l'emplacement spécifié par l'iter, et lui applique les balises données.

insert_with_tags_by_name() fait la même chose, mais permet de spécifier les balises en les nommant.

On peut effacer du texte d'un buffer avec les méthodes :

  bufferdetexte.delete(debut, fin)
  
  resultat = bufferdetexte.delete_interactive(debut, fin, defaut_editable)

delete() supprime le texte compris entre les TextIterTextIter : les itérateurs de texte debut et fin de bufferdetexte.

delete_interactive() supprime tout texte éditable (déterminé comme tel par les balises de texte applicables et par l'argument defaut_editable) compris entre debut et fin.

Vous pouvez récupérer une copie du texte d'un TextBuffer grâce aux méthodes :

  texte = bufferdetexte.get_text(debut, fin, include_hidden_chars=TRUE)

  texte = bufferdetexte.get_slice(debut, fin, include_hidden_chars=TRUE)

get_text() retourne une copie du texte du buffer compris entre debut et fin ; le texte non affiché est exclu si include_hidden_chars vaut FALSE. Les caractères représentant des images incrustées ou des widgets sont exclus.

get_slice() est identique à get_text() à la différence que le texte qu'elle retourne inclut un caractère 0xFFFC pour chaque image incrustée ou widget.

Les TextMarkTextMark : les marques de texte sont similaires aux TextIterTextIter : les itérateurs de texte en ceci qu'elles spécifient une position entre deux caractères d'un TextBuffer. Cependant, les TextMarkTextMarkTextMarkTextMark : les marques de texte maintiennent leur information de position même après modification du buffer. Les méthodes des TextMarkTextMarkTextMark : les marques de texte seront décrites plus loin dans la section TextMarkTextMark : les marques de texte.

Un buffer de texte contient deux marques inhérentes : la marque insert (insertion) et la marque selection_bound (fin de sélection). La marque insert est la position par défaut pour l'insertion de texte (le curseur). La marque selection_bound se combine avec la marque insert pour définir une sélection.

On peut retrouver ces deux marques en faisant appel aux méthodes suivantes :

  marque_insert = bufferdetexte.get_insert()

  marque_selectionbound = bufferdetexte.get_selection_bound()

Les marques insert et selection_bound peuvent être placées simultanément à une position grâce à la méthode :

  bufferdetexte.place_cursor(emplacement)

emplacement est un TextIterTextIter : les itérateurs de texte qui indique la position. La méthode place_cursor() est nécessaire pour éviter de créer temporairement une sélection si les marques ont été déplacées individuellement.

On crée des TextMarkTextMark : les marques de texte avec la méthode :

  marque = bufferdetexte.create_mark(nom_marque, emplacement, left_gravity=FALSE)

où nom_marque est le nom assigné à la marque créée (None pour une marque anonyme), emplacement est l'itérateur de texte indiquant la position de la marque dans le buffer, et left_gravity indique la situation de la marque après que du texte y aura été inséré (gauche si TRUE, droite si FALSE).

Une marque peut être déplacée dans le buffer avec les méthodes :

  bufferdetexte.move_mark(marque, emplacement)

  bufferdetexte.move_mark_by_name(nom_marque, emplacement)

marque désigne la marque à déplacer. nom_marque spécifie le nom de la marque à déplacer. emplacement est un itérateur de texte indiquant la nouvelle position.

On peut supprimer une marque d'un buffer avec les méthodes :

  bufferdetexte.delete_mark(marque)

  bufferdetexte.delete_mark_by_name(nom_marque)

On peut récupérer une marque par son nom avec la méthode :

  marque = bufferdetexte.get_mark(nom_marque)

Les TextTagLes TextTag contiennent un ou plusieurs attributs (comme les couleurs d'arrière-plan et de premier plan, la police, la possibilité d'édition) que l'on peut appliquer à une ou plusieurs portions du texte d'un buffer. Les attributs pouvant être spécifiés par une TextTagTextTagLes TextTag seront décrits dans la section TextTagLes TextTag.

La méthode suivante crée une TextTagLes TextTag avec des attributs et l'installe dans la TextTagTableLa TextTagTable d'un TextBuffer :

  balise = bufferdetexte.create_tag(name=None, attribut1=valeur1, attribut2=valeur2, ...)

name est soit une chaine de caractères spécifiant le nom de la balise, soit None si la balise est anonyme. Les couples "attribut-valeur" déterminent les attributs de la balise. Reportez-vous à la section TextTagTextTagLes TextTag pour des informations concernant les attributs qui peuvent être définis par les propriétés d'une TextTagLes TextTag.

Une balise peut être appliquée à une portion du texte d'un buffer par la méthode suivante :

  bufferdetexte.apply_tag(balise, debut, fin)

  bufferdetexte.apply_tag_by_name(nom_balise, debut, fin)

où balise est la balise à appliquer au texte, nom_balise le nom de la balise, et debut et fin des itérateurs de texte qui indiquent la portion de texte à laquelle la balise doit être appliquée.

On peut retirer une balise d'une portion de texte en utilisant les méthodes suivantes :

  bufferdetexte.remove_tag(balise, debut, fin)

  bufferdetexte.remove_tag_by_name(nom_balise, debut, fin)

Pour retirer toutes les balises d'une portion de texte, on utilisera :

  bufferdetexte.remove_all_tags(debut, fin)

En plus du texte, un TextBuffer peut contenir des images pixbuf et un point d'ancrage pour widgets. Ce point d'ancrage sert à ajouter un widget à une TextViewTextViewTextView : la zone de texte. Un widget différent peut être ajouté dans chaque TextViewTextView : la zone de texte qui affiche un buffer contenant un point d'ancrage.

On peut insérer une image pixbuf avec la méthode suivante :

  bufferdetexte.insert_pixbuf(iter, pixbuf)

dans laquelle iter précise l'emplacement du buffer où insérer l'image pixbuf. Cette image comptera pour un caractère et sera représentée par le caractère Unicode "0xFFFC" dans le texte retourné par la méthode get_slice() (il ne figurera pas dans celui retourné par get_text()).

On peut insérer un widget GTK+ dans une TextViewTextView : la zone de texte, ` un emplacement du buffer spécifié par un TextChildAnchor (point d'ancrage pour enfant). Tout comme une image pixbuf, le TextChildAnchor comptera pour un caractère représenté par "0xFFFC".

Le moyen le plus commode de créer et d'insérer un TextChildAnchor est la méthode suivante :

  ancrage = bufferdetexte.create_child_anchor(iter)

où iter est l'emplacement destiné à recevoir le point d'ancrage.

Mais on peut aussi créer et insérer le TextChildAnchor en deux temps ainsi :

  ancrage = gtk.TextChildAnchor()

  bufferdetexte.insert_child_anchor(iter, ancrage)

Puis l'on peut ajouter le widget à la TextViewTextView : la zone de texte, au point d'ancrage, grâce à la méthode suivante :

  zonedetexte.add_child_at_anchor(widget_enfant, ancrage)

La méthode qui suit permet de récupérer la liste des widgets attachés à un point d'ancrage :

  liste_widgets = ancrage.get_widgets()

On peut également ajouter un widget à une TextViewTextView : la zone de texte en utilisant cette méthode :

  zonedetexte.add_child_in_window(widget_enfant, fenêtre, position_x, position_y)

où le widget_enfant sera placé dans la fenêtre fenêtre à la positon spécifiée par position_x et position_y. fenêtre indique laquelle des fenêtres qui composent la TextViewTextView : la zone de texte doit recevoir le widget enfant :

  gtk.TEXT_WINDOW_TOP       # fenêtre supérieure
  gtk.TEXT_WINDOW_BOTTOM    # fenêtre inférieure
  gtk.TEXT_WINDOW_LEFT      # fenêtre de gauche
  gtk.TEXT_WINDOW_RIGHT     # fenêtre de droite
  gtk.TEXT_WINDOW_TEXT      # fenêtre du texte
  gtk.TEXT_WINDOW_WIDGET    # fenêtre du widget

On peut récupérer le TextBuffer qui contient le TextIter iter avec la méthode :

  buffer = iter.get_buffer()

Les méthodes suivantes permettent de récupérer la localisation du TextIter iter dans le TextBufferTextBuffer : le buffer de texte :

  num_car = iter.get_offset()            # renvoie la position de iter en partant du début du buffer

  num_ligne = iter.get_line()            # renvoie le numéro de la ligne de iter

  num_car_ligne = iter.get_line_offset()    # renvoie la position de iter en partant du début de la ligne

  nbr_car_ligne = iter.get_chars_in_line()    # renvoie le nombre de caractères dans la ligne de iter

Le PangoLanguage utilisé à un emplacement du buffer portant un itérateur peut s'obtenir avec la méthode suivante :

  langage = iter.get_language()

Plus généralement, on fera appel à la méthode qui suit pour récupérer les attributs d'un texte à une position portant un TextIter :

  resultat = iter.get_attributes(valeurs)

La variable resultat indiquera si les valeurs fournies en argument (qui doivent être des objets TextAttributes) ont été modifiées. On obtient ces valeurs par l'intermédiaire de la méthode de TextViewTextView : la zone de texte suivante :

  valeurs = zonedetexte.get_default_attributes()

où zonedetexte est la TextViewTextView : la zone de texte en question.

On peut accéder aux attributs suivants à partir d'un objet TextAttributes (non implémenté dans PyGTK <= 1.99.15) :

Il est possible de dupliquer un TextIter grâce à la méthode :

  copie_iter = iter.copy()

On peut récupérer différentes quantités de texte et d'objets de TextBufferTextBuffer : le buffer de texte en utilisant les méthodes suivantes :

  caract = iter.get_char()            # renvoie le caractère qui suit iter (ou 0 si l'on est à la fin du buffer)

  texte = debut.get_slice(fin)            # renvoie le texte compris entre les itérateurs debut et fin

  texte = debut.get_text(fin)            # renvoie le texte compris entre les itérateurs debut et fin

  pixbuf = iter.get_pixbuf()            # renvoie l'image pixbuf située à l'itérateur iter (ou None)

  ancrage = iter.get_child_anchor()        # renvoie le point d'ancrage situé à l'itérateur iter(ou None)

  liste_marques = iter.get_marks()        # renvoie une liste de marques

  liste_balises = iter.get_toggled_tags()    # renvoie une liste de balises activées ou désactivées

  liste_balises = iter.get_tags()        # renvoie une liste de balises par priorités

Les méthodes suivantes permettent de vérifier certaines caractéristiques des balises se trouvant à une position de TextIter :

  resultat = iter.begins_tag(tag=None)    # renvoie TRUE si tag s'active à l'emplacement iter

  resultat = iter.ends_tag(tag=None)    # renvoie TRUE si tag se désactive à l'emplacement iter

  resultat = iter.toggles_tag(tag=None)    # renvoie TRUE si tag s'active ou se désactive à l'emplacement iter

  resultat = iter.has_tag(tag)        # renvoie TRUE si la portion de texte contenant iter est balisée par tag

Ces méthodes renvoient TRUE si la balise tag à la position iter remplit la condition. Si l'argument tag vaut None aux trois premières méthodes, le résultat sera TRUE si n'importe quelle balise remplit la condition à la position iter.

Les deux méthodes qui suivent indiquent si le texte situé à la position spécifiée par le TextIter est éditable ou accepte une insertion de texte :

  resultat = iter.editable()

  resultat = iter.can_insert(defaut_editable)

La méthode editable() indique si l'itérateur iter se situe dans une portion de texte éditable. La méthode can_insert() indique si l'on peut insérer du texte à l'emplacement spécifié par iter, en prenant en compte la possibilité d'édition par défaut de la TextViewTextView : la zone de texte, du TextBufferTextBuffer : le buffer de texte et des balises applicables. L'argument defaut_editable est généralement déterminé par un appel à la méthode de TextViewTextView : la zone de texte :

  defaut_editable = zonedetexte.get_editable()

où zonedetexte est la TextViewTextView : la zone de texte.

On peut savoir si deux TextIter sont équivalents grâce à la méthode :

  egalite = iter1.equal(iter2)

La méthode suivante permet de comparer deux TextIter :

  resultat = iterA.compare(iterB)

resultat aura pour valeur : -1 si iterA est inférieur à iterB ; 0 si iterA égale iterB ; et 1 si iterA est supérieur à iterB.

Pour savoir si un TextIter se trouve entre deux TextIter donnés, utilisez la méthode :

  resultat = iter.in_range(debut, fin)

resultat vaudra TRUE si iter est situé entre debut et fin. Attention, debut et fin doivent être donnés dans l'ordre croissant ! Ceci peut être assuré par la méthode :

  iterA.order(iterB)

qui réorganise les positions des TextIter de sorte que iterA soit avant iterB.

On peut déterminer la position d'un TextIter par rapport au texte d'un TextBufferTextBuffer : le buffer de texte grâce aux méthodes suivantes :

  resultat = iter.starts_word()            # iter commence un mot

  resultat = iter.ends_word()            # iter termine un mot

  resultat = iter.inside_word()            # iter est à l'intérieur d'un mot

  resultat = iter.starts_sentence()        # iter commence une phrase

  resultat = iter.ends_sentence()        # iter termine une phrase

  resultat = iter.inside_sentence()        # iter est à l'intérieur d'une phrase

  resultat = starts_line()            # iter commence une ligne

  resultat = iter.ends_line()            # iter termine une ligne

resultat renvoie TRUE si le TextIter est à la position donnée. La définition de "mot" et "phrase" dépend du langage utilisé à la position du TextIter. Quant à la ligne, il s'agit d'un ensemble de phrases s'apparentant à un paragraphe.

La méthode suivante permet de déterminer si un TextIter se situe au début ou à la fin du TextBufferTextBuffer : le buffer de texte :

  resultat = iter.is_start()

  resultat = iter.is_end()

resultat vaudra TRUE si le TextIter est situé au début ou à la fin du TextBufferTextBuffer : le buffer de texte.

Du fait qu'un TextBufferTextBuffer : le buffer de texte peut contenir des groupes de caractères s'affichant comme une seule position de curseur (par exemple, un retour chariot + saut de ligne, ou une lettre + marque d'accent), il est possible qu'un TextIter soit à un emplacement ne représentant pas une position de curseur possible. Dans un tel cas, la méthode suivante renverrait FALSE :

  resultat = iter.is_cursor_position()

On peut déplacer les TextIter dans un TextBufferTextBuffer : le buffer de texte par sauts de différents éléments de texte. La définition de ces éléments de texte est fixée par le PangoLanguage utilisé à l'emplacement du TextIter. Les méthodes basiques sont :

  resultat = iter.forward_char()            # avancer d'un caractère

  resultat = iter.backward_char()            # reculer d'un caractère

  resultat = iter.forward_word_end()            # avancer à la fin du mot

  resultat = iter.backward_word_start()            # reculer au début du mot

  resultat = iter.forward_sentence_end()        # avancer à la fin de la phrase

  resultat = iter.backward_sentence_start()        # reculer à au début de la phrase

  resultat = iter.forward_line()            # avancer au début de la prochaine ligne

  resultat = iter.backward_line()            # reculer au début de la ligne précédente

  resultat = iter.forward_to_line_end()            # avancer à la fin de la ligne

  resultat = iter.forward_cursor_position()        # avancer à la prochaine position de curseur

  resultat = iter.backward_cursor_position()        # reculer à la position de curseur précédente

resultat vaut TRUE si le TextIter a été déplacé et FALSE s'il se trouve au début ou à la fin du TextBufferTextBuffer : le buffer de texte.

Toutes les méthodes ci-dessus (hormis forward_to_line_end()) ont un équivalent avec argument. Ce dernier est un nombre (positif ou négatif) indiquant de combien d'unités doit se déplacer le TextIter :

  resultat = iter.forward_chars(combien)

  resultat = iter.backward_chars(combien)

  resultat = iter.forward_word_ends(combien)

  resultat = iter.backward_word_starts(combien)

  resultat = iter.forward_sentence_ends(combien)

  resultat = iter.backward_sentence_starts(combien)

  resultat = iter.forward_lines(combien)

  resultat = iter.backward_lines(combien)

  resultat = iter.forward_cursor_positions(combien)

  resultat = iter.backward_cursor_positions(combien)

Un TextIter peut être déplacé à un emplacement spécifique du TextBufferTextBuffer : le buffer de texte avec les méthodes suivantes :

  iter.set_offset(n)        # déplace iter juste après le nième caractère du buffer

  iter.set_line(x)        # déplace iter au début de la xi ligne

  iter.set_line_offset(n)    # déplace iter juste après le nième caractère de sa ligne

  iter.forward_to_end()        # déplace iter à la dernière position du buffer

Un TextIter peut également être déplacé vers un emplacement où une balise s'active ou se désactive, et ce, grâce à la méthode suivante :

  resultat = iter.forward_to_tag_toggle(balise)

  resultat = iter.backward_to_tag_toggle(balise)

resultat vaudra TRUE si le TextIter a été déplacé vers une nouvelle position où balise s'active ou se désactive. Si balise vaut None, la méthode déplacera TextIter vers la prochaine position où n'importe quelle balise s'active ou se désactive.

La méthode suivante permet de rechercher une chaine de caractères dans un TextBufferTextBuffer : le buffer de texte :

  debut_resultat, fin_resultat = iter.forward_search(chaine, drapeaux, limit=None)

  debut_resultat, fin_resultat = iter.backward_search(chaine, drapeaux, limit=None)

La méthode renvoie un tuple contenant deux TextIter. Ces derniers indiquent respectivement la position du premier caractère du résultat et celle du premier caractère suivant ce résultat. chaine est la chaine de caractères à localiser. Les drapeaux modifient les paramètres de la recherche ; ils peuvent prendre comme valeurs :

  gtk.TEXT_SEARCH_VISIBLE_ONLY        # les caractères invisibles seront ignorés

  gtk.TEXT_SEARCH_TEXT_ONLY        # les images pixbuf et les points d'ancrage seront ignorés

limit est un TextIter facultatif qui limite la recherche au texte le précédant.

Les TextTag peuvent porter un nom ou bien être anonymes. On crée une TextTag en utilisant la fonction :

  balise = gtk.TextTag(name=None)

Si aucun name (nom) n'est donné ou s'il vaut None, la balise sera anonyme. Il peut être plus commode de créer des TextTag avec la méthode de TextBufferTextBuffer : le buffer de texte create_tag(), celle-ci permettant aussi de spécifier les attributs de la balise et de l'ajouter à la table des balises du buffer (cf. la section TextBufferTextBuffer : le buffer de texte)

Les attributs que peut porter une TextTag sont :

On peut définir les attributs d'une balise avec la méthode :

  balise.set_property(nom_attr, valeur)

dans laquelle nom_attr est une chaine contenant le nom de l'attribut et valeur la valeur qui doit lui être affectée.

De la même manière, on peut récupérer la valeur de l'attribut avec la méthode :

  valeur = balise.get_property(nom_attr)

Du fait qu'une balise ne contient pas forcément tous les attributs précédemment cités, un certain nombre de propriétés booléennes ont été créées, qui permettent simplement de savoir si la balise est porteuse ou pas de tel attribut :

Pour récupérer un attribut d'une balise, vous devez donc d'abord vérifier s'il est bien défini dans cette balise. Par exemple, pour obtenir un attribut valide d'alignement, vous pourriez procéder comme suit :

  if balise.get_property("justification_set"):
    alignement = balise.get_property("justification")

Par défaut, la priorité des balises correspond à l'ordre dans lequel elles sont ajoutées à la TextTagTableLa TextTagTable. La balise qui a la plus haute priorité prend l'avantage dans le cas où plusieurs tentent de définir le même attribut pour une portion de texte. La priorité se récupère et se définit avec les méthodes suivantes :

  priorite = balise.get_priority()

  balise.set_priority(priorite)

La priorité d'une balise doit être comprise entre 0 et la taille de la TextTagTableLa TextTagTable moins 1.

Par défaut, une TextTagTable est créée avec la création d'un TextBufferTextBuffer : le buffer de texte. Mais elle peut tout aussi bien être créée par la fonction :

  table = TextTagTable()

On ajoute une TextTagLes TextTag a une TextTagTable avec la méthode :

  table.add(balise)

La balise ne doit pas déjà être dans la table et ne doit pas porter le même nom qu'une balise s'y trouvant déjà.

On peut chercher une TextTagLes TextTag dans une TextTagTable en utilisant la méthode :

  balise = table.lookup(nom)

La méthode renvoie la balise qui porte ce nom dans la table, ou None si aucune balise ne porte ce nom.

On peut retirer une TextTagLes TextTag d'une TextTagTable avec la méthode :

  table.remove(balise)

Enfin, la taille d'une TextTagTable peut être récupérée par :

  taille_table = table.get_size()