Programmation GTK2 en Pascal/GtkEntry

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation GTK2 en Pascal

Présentation[modifier | modifier le wikicode]

Le contrôle GtkEntry permet de gérer une zone de texte d'une ligne que l'utilisateur peut modifier.

Hiérarchie[modifier | modifier le wikicode]

Hiérarchie
GObject
  └─GtkObject
      └─GtkWidget
          └─GtkEntry

Utilisation de base[modifier | modifier le wikicode]

Création[modifier | modifier le wikicode]

Pour créer un contrôle GtkEntry, nous avons à notre disposition une fonction simple d'utilisation :

function gtk_entry_new : PGtkWidget;

Récupération de la donnée saisie[modifier | modifier le wikicode]

Afin de récupérer le texte qui a été saisi par l'utilisateur, il faut utiliser cette fonction :

function gtk_entry_get_text(entry : PGtkEntry) : Pgchar;

Elle permet de récupérer le texte qui a été tapé par l'utilisateur dans le contrôle entry. La valeur de retour est de type PGChar. Il est inutile d'allouer de la mémoire pour la variable qui va recevoir le texte, et donc de ne surtout pas libérer la mémoire car cela rendrait votre application instable.

Afficher un message dans la zone de texte[modifier | modifier le wikicode]

Pour afficher un message dans une GtkEntry, la fonction est :

procedure gtk_entry_set_text(entry : PGtkEntry; text : Pgchar);

Le paramètre entry correspond bien sûr au GtkEntry dans lequel on veut insérer le texte text.

Limiter le nombre de caractères[modifier | modifier le wikicode]

Gtk+ nous offre la possibilité de limiter le nombre de caractères qu'un utilisateur peut saisir avec la fonction :

procedure gtk_entry_set_max_length(entry : PGtkEntry; max : gint);

Le paramètre max correspond bien sûr à limite que nous voulons fixer.

Il est à noter que le champ d'entrée peut-être créer directement avec une longueur maxi, on utilise alors :

function gtk_entry_new_with_max_length(max : gint) : PGtkWidget;

Programme exemple[modifier | modifier le wikicode]

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 « Entrée » à la fin de sa saisie (interception du signal « activate ») ou lorsqu'il cliquera sur le bouton (interception du signal « clicked »).

Voilà le fichier gtk024.pas :

program gtk024;

uses glib2, gtk2;

type
  TFenetrePrincipale = record
    pFenetre     : PGtkWidget;
    pVBox        : PGtkWidget;
    pChampEntree : PGtkWidget;
    pBouton      : PGtkWidget;
    pLabel       : PGtkWidget;
  end;
  PFenetrePrincipale = ^TFenetrePrincipale;

procedure OnBtnClick(APWidget : PGtkwidget; AData : pgpointer); cdecl;
var
  pFenPrinc : PFenetrePrincipale;
  Texte : PGChar;
begin
  // Récuperation des données de la fenêtre principale (qui sont dans AData)
  pFenPrinc := PFenetrePrincipale(AData);

  // Récuperation du texte contenu dans le GtkEntry
  Texte := gtk_entry_get_text(GTK_ENTRY(pFenPrinc^.pChampEntree));

  // Modification du texte contenu dans le GtkLabel */
  gtk_label_set_text(GTK_LABEL(pFenPrinc^.pLabel), Texte);
end;

var
  pFenPrinc : PFenetrePrincipale;
begin
  pFenPrinc := g_malloc(SizeOf(TFenetrePrincipale));

  gtk_init(@argc, @argv);
  pFenPrinc^.pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(pFenPrinc^.pFenetre), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(pFenPrinc^.pFenetre), 320, 200);
  gtk_container_set_border_width(GTK_CONTAINER(pFenPrinc^.pFenetre), 4);
  gtk_window_set_title(GTK_WINDOW(pFenPrinc^.pFenetre), 'Gtk024 : Champ de saisie');
  gtk_signal_connect(pGTKOBJECT(pFenPrinc^.pFenetre), 'destroy', GTK_SIGNAL_FUNC(@gtk_main_quit), NULL);

  pFenPrinc^.pVBox := gtk_vbox_new(TRUE, 0);
  gtk_container_add(GTK_CONTAINER(pFenPrinc^.pFenetre), pFenPrinc^.pVBox);

  // Création du GtkEntry 
  pFenPrinc^.pChampEntree := gtk_entry_new;
  gtk_box_pack_start(GTK_BOX(pFenPrinc^.pVBox), pFenPrinc^.pChampEntree, TRUE, FALSE, 0);
  g_signal_connect(pGTKOBJECT(pFenPrinc^.pChampEntree), 'activate', 
    GTK_SIGNAL_FUNC(@OnBtnClick), gpointer(pFenPrinc));

  pFenPrinc^.pBouton := gtk_button_new_with_label('Copier');
  gtk_box_pack_start(GTK_BOX(pFenPrinc^.pVBox), pFenPrinc^.pBouton, TRUE, FALSE, 0);
  g_signal_connect(pGTKOBJECT(pFenPrinc^.pBouton), 'clicked', 
    GTK_SIGNAL_FUNC(@OnBtnClick), gpointer(pFenPrinc));

  pFenPrinc^.pLabel := gtk_label_new(NULL);
  gtk_box_pack_start(GTK_BOX(pFenPrinc^.pVBox), pFenPrinc^.pLabel, TRUE, FALSE, 0);

  gtk_widget_show_all(pFenPrinc^.pFenetre);
  gtk_main;
  g_free(pFenPrinc);
end.

Voilà ce que donne l'exécution du programme gtk024 :

Programmation GTK2 en Pascal - gtk024-1.png

Après saisie d'un texte et clic sur le bouton :

Programmation GTK2 en Pascal - gtk024-2.png

La saisie d'un mot de passe[modifier | modifier le wikicode]

Visibilité du texte[modifier | modifier le wikicode]

Généralement, lorsque nous tapons un mot de passe, nous souhaitons que celui-ci reste secret. Le contrôle GtkEntry permet cela grâce à cette fonction :

procedure gtk_entry_set_visibility(entry : PGtkEntry; visible : gboolean);

Il suffit donc de mettre le paramètre visible à FALSE pour cacher le texte qui sera entré. À l'inverse, pour savoir si le texte entré sera visible ou pas, il faut utiliser cette fonction :

function gtk_entry_get_visibility(entry : PGtkEntry) : gboolean;

La valeur de retour sera, bien sûr, égale à TRUE si le texte est visible et à FALSE dans le cas contraire.

Le caractère affiché[modifier | modifier le wikicode]

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 fonction :

procedure gtk_entry_set_invisible_char(entry : PGtkEntry; ch : gunichar);

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. Il faudra utiliser la fonction g_utf8_get_char pour faire la conversion depuis l'utf-8, si c'est dans ce format qu'on sauvegarde les sources.

Et pour terminer, la fonction permettant de connaître le caractère de remplacement est :

function gtk_entry_get_invisible_char(entry : PGtkEntry) : gunichar;

Programme exemple[modifier | modifier le wikicode]

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 « € » (pour changer de « $ »).

Voilà la partie modifiée du fichier gtk025.pas (cf le fichier gtk024.pas pour avoir le code complet) :

 [...]
 // Création du GtkEntry 
 pFenPrinc^.pChampEntree := gtk_entry_new;
 // Limitation du nombre de caractères 
 gtk_entry_set_max_length(GTK_ENTRY(pFenPrinc^.pChampEntree), 8);
 // Mode mot de passe 
 gtk_entry_set_visibility(GTK_ENTRY(pFenPrinc^.pChampEntree), FALSE);
 // Modification du caractère affiché
 gtk_entry_set_invisible_char(GTK_ENTRY(pFenPrinc^.pChampEntree), g_utf8_get_char('€'));
 gtk_box_pack_start(GTK_BOX(pFenPrinc^.pVBox), pFenPrinc^.pChampEntree, TRUE, FALSE, 0);
 g_signal_connect(pGTKOBJECT(pFenPrinc^.pChampEntree), 'activate', 
   GTK_SIGNAL_FUNC(@OnBtnClick), gpointer(pFenPrinc));
 [...]

Voilà ce que donne l'exécution du programme gtk025 après saisie d'un texte et appui sur « entrée » :

Programmation GTK2 en Pascal - gtk025.png

Saisie de données : GtkEntry ~ GtkHScale ~ GtkVScale ~ GtkSpinButton