Chapitre 14
Un champs de saisie texte

Les widgets ”éditables”

Le widget éditable est la classe de base du widget entry dont l’objet est de gérer des chaînes de caractères courtes. Cette classe ne peut être instanciée (il n’y a pas de fonction new()) et fournit uniquement les fonctionnalités communes aux widgets textes. Tous les widgets qui éditent du texte vous permettent de sélectionner une région de texte avec :

$editable->select_region( $start, $end );
Ou le texte sélectionné est composé des caractères de la position  $start jusqu’à la position  $end non inclus. Si $end est négatif, alors il compte à rebours à partir de la fin du texte. Du texte peut être inséré à une certaine position en utilisant :
$editable->insert_text( $new_text, $position );
$new_text est la chaîne à insérer et $position la position où il faut placer le texte. Des caractères peuvent être effacés avec :
$editable->delete_text( $start, $pos );
Comme pour select_region, les caractères à effacer sont compris entre  $start et  $end. Vous pouvez récupérer des caractères avec :
$editable->get_chars( $start, $end );
Si vous avez sélectionné du texte, vous pouvez le couper et le placer dans le bloc note avec :
$editable->cut_clipboard();
Cela prend les caractères sélectionnés pour les placer dans le bloc note et les efface du widget éditable. Vous pouvez aussi copier le texte sélectionné dans le bloc note.
$editable->copy_clipboard();
Les caractères sont copiés dans le bloc note mais pas effacé du widget éditable. Le texte du bloc note peut être collé dans le widget éditable à l’endroit où se trouve le curseur :
$editable->paste_clipboard();
Pour effacer le texte sélectionné :
$editable->delete_selection();
La position du curseur peut être déclarée et retrouvée avec :
$editable->set_position( $position );  
$editable->get_position();
Les widgets éditables peuvent être en lecture seule ou bien éditable :
$editable->set_editable( $is_editable );
$is_editable est une valeur vraie ou fausse qui détermine si le widget éditable peut être édité ou non par l’utilisateur. Le widget éditable possède un grand nombre de signaux disponibles qui sont :

'changed'  
'insert-text'  
'delete-text'  
'activate'  
'set-editable'  
'move-cursor'  
'move-word'  
'move-page'  
'move-to-row'  
'move-to-column'  
'kill-char'  
'kill-word'  
'kill-line'  
'cut-clipboard'  
'copy-clipboard'  
'paste-clipboard'

L’utilisation de ces signaux devrait être évidente. Si vous avez une question sur leur utilisation, consulter la documentation GTK. Le seul commentaire que je ferais est que vous pouvez émettre le signal 'changed'  en appelant la fonction :

$editable->changed();

Le widget entrée

Le widget entrée permet de taper du texte dans une boîte d’une seule ligne. Le texte peut être placé avec des appels de fonctions qui déterminent si le nouveau texte doit remplacer, se placer devant ou après le contenu actuel du widget entrée. Pour créer un widget entrée :

$entry = Gtk::Entry->new();

Il existe plusieurs fonctions qui modifient le texte contenu dans le widget Entrée :

$entry->set_text( $text );  
$entry->append_text( $text );  
$entry->prepend_text( $text );
La fonction set_text() déclare le contenu du widget Entrée remplaçant le contenu présent. Les fonctions append_text() et  prepend_text() permettent de placer du texte après ou avant le contenu du widget.

Si vous utilisez une Entrée et que vous ne voulez pas que le texte entré soit visible, par exemple quand vous entrez un mot de passe, vous pouvez utiliser la fonction suivante qui prend comme argument une valeur vraie ou fausse:

$entry->set_visibility($visible );
Si nous voulons attraper le moment ou l’utilisateur a rentré du texte, nous pouvons connecter un signal 'activate' ou 'changed'. 'activate' se manifeste quand l’utilisateur appuie sur la touche ”Entrée” à l’intérieur du widget. 'changed' se manifeste quand le texte change, pour chaque caractère entré ou effacé.

Exemple

entry

# !/usr/bin/perl -w

use strict ;
use Gtk2 ’-init’ ;

# Variables convenables pour vrai et faux
use constant TRUE => 1 ;
use constant FALSE => 0 ;

my $window = Gtk2::Window->new( ”toplevel” ) ;
$window->set_default_size( 200 , 100 ) ;
$window->set_title( ”L’entrée texte” ) ;
$window->signal_connect( ”delete_event” , sub { Gtk2->main_quit() ; } ) ;

my $vbox = Gtk2::VBox->new( FALSE, 0 ) ;
$window->add( $vbox ) ;
$vbox->show() ;

my $entry = Gtk2::Entry->new() ;
$entry->signal_connect( ”activate” , \&enter_callback, $entry ) ;
$entry->set_text( ”Salut ” ) ;
$entry->append_text( ”à tous !” ) ;
$entry->select_region( 0 , length( $entry->get_text() ) ) ;
$vbox->pack_start( $entry, TRUE, TRUE, 0 ) ;
$entry->show() ;

my $hbox = Gtk2::HBox->new( FALSE, 0 ) ;
$vbox->add( $hbox ) ;
$hbox->show() ;

my $check1 = Gtk2::CheckButton->new( ”Editable” ) ;
$hbox->pack_start( $check1, TRUE, TRUE, 0 ) ;
$check1->signal_connect( ”toggled” , \&entry_toggle_editable, $entry ) ;
$check1->set_active( TRUE ) ;
$check1->show() ;

my $check2 = Gtk2::CheckButton->new( ”Visible” ) ;
$hbox->pack_start( $check2, TRUE, TRUE, 0 ) ;
$check2->signal_connect( ”toggled” , \&entry_toggle_visibility, $entry ) ;
$check2->set_active( TRUE ) ;
$check2->show() ;

my $button = Gtk2::Button->new_from_stock( ”gtk-close” ) ;
$button->signal_connect( ”clicked” , sub { Gtk2->main_quit() ; } ) ;
$vbox->pack_start( $button, TRUE, TRUE, 0 ) ;
$button->can_default( TRUE ) ;
$button->grab_default() ;
$button->show() ;

$window->show() ;

main Gtk2 ;


### Fonctions de rappels
sub enter_callback {
my ( $widget, $entry ) = @_ ;
my $entry_text = $entry->get_text() ;
print( ”L’entrée texte contient: $entry_text\n” ) ;
}

sub entry_toggle_editable {
my ( $checkbutton, $entry ) = @_ ;
$entry->set_editable( $checkbutton->get_active ) ;
}

sub entry_toggle_visibility {
my ( $checkbutton, $entry ) = @_ ;
$entry->set_visibility( $checkbutton->get_active ) ;
}