Programmation GTK2 en Pascal/GtkEntry

Programmation GTK2 en Pascal

Introduction Pré-requis Logiciels nécessaires Installation sous Linux Installation sous Windows Installation sous Mac/OS Une application minimale Les bases La notion d'objet La gestion des évènements Le placement des contrôles Les contrôles (widgets) Gtk Les fenêtres Les conteneurs Les visuels Les boutons La saisie de données Les listes déroulantes Les menus Les décorations La barre d'outils Les sélections Les zones de texte Les listes et arbres La Glib : objets et fonctions Dessiner avec le Gdk Conclusion Bibliographie

Présentation

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

Hiérarchie

Hiérarchie

GObject └─GtkObject └─GtkWidget └─GtkEntry

Utilisation de base

Création

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

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

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

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

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 :

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

La saisie d'un mot de passe

Visibilité du texte

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é

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

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

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