Programmer rapidement en Gtk-Perl
Cette page, destinée aux débutants, montre par la pratique à travers des petits programmes simples comment utiliser les objets de base (boîtes de dialogue, boutons, affichage de texte, zones de dessin, ligne de saisie, tableaux, boutons radio, cases à cocher, etc.) pour concevoir rapidement une interface utilisateur en Gtk-Perl. Tous les programmes sont commentés et illustrés, et sont immédiatement réutilisables par un simple copier-coller.
Retour au sommaire de cette page
|
La
hiérarchie des objets GTK+
|
Voici pour commencer la hiérarchie simplifiée des objets de GTK+ .
Cette arborescence n'est pas complète, mais elle présente les objets de base de GTK+, suffisants pour faire une première application.
Object <--
Widget <-- Container <-- Bin <-- Window <-- Dialog
| | |
|
| +-
Frame
| |
|
| | +-
HandleBox
|
| |
|
| +- Item <-- MenuItem
|
| |
|
| +- Button <--
ToggleButton
|
|
|
|
|
+-
CheckButton
|
|
|
|
|
+-
RadioButton
|
|
|
+-
Box <-- VBox
|
|
|
|
|
+- HBox <-- StatusBar
|
|
| +-
ToolBar (barre
d'outils)
|
|
|
+-
Table
(grille)
|
|
|
+-
Notebook (onglets)
|
|
|
+-
MenuShell <-- Menu
|
|
|
+-
MenuBar
|
+-
Misc <-- Label
|
|
|
+- Image
|
|
|
+- Pixmap
|
+-
DrawingArea
|
+-
Editable <-- Text
|
|
|
+-
Entry <-- SpinButton
|
+-
Separator <-- HSeparator
|
|
| +-
VSeparator
|
+-
Range <-- Scale <-- HScale
|
|
|
|
|
+- VScale
|
|
|
+- ScrollBar <-- HScrollBar
|
|
|
+-
HScrollBar
|
+-
Progress <-- ProgressBar
Retour au sommaire de cette page
|
Un
premier programme en Gtk-Perl
|
Ce premier programme de base en Gtk-Perl crée et affiche à l'écran une fenêtre vide.
Voici le code source en Perl :
#!/usr/bin/perl
-w
##############################################################################
#
Programme de base affichant une fenêtre vide #
##############################################################################
# Liste des
modules utilises :
use Gtk;
init Gtk;
# Declaration
des variables :
my $window;
# Creation
de la fenetre :
$window = Gtk::Window->new( 'toplevel' );
# Configuration
de la fenetre :
$window->set_usize( 320, 200 );
$window->set_title( "Programme de base en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Affichage
de la fanetre :
$window->show();
# Lancement
de la boucle principale de Gtk+ :
main Gtk;
# En principe
le programme ne passe jamais par la :
exit( 0 );
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Et voici le résultat de ce programme de base :
Retour au sommaire de cette page
|
Bonjour
le monde !
|
Ce second programme va rajouter un texte dans la fenêtre précédente. Pour commencer, voici le résultat du programme :
Et voici maintenant le programme source qui a créé la fenêtre ci-dessus :
#!/usr/bin/perl
-w
##############################################################################
#
A f f i c h a g e
d ' u n
m e s s a g e #
##############################################################################
#------------------------------------------------------------------------------
# Liste des modules utilises :
use Gtk;
init Gtk;
#------------------------------------------------------------------------------
# Creation de la fenetre :
my $window = Gtk::Window->new( 'toplevel' );
#------------------------------------------------------------------------------
# Creation du message (qui est un objet Label) :
my $texte = Gtk::Label->new("Bonjour le monde !");
#------------------------------------------------------------------------------
# Configuration de la fenetre :
$window->set_usize( 320, 200 );
$window->set_title( "Affichage d'un message en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
#------------------------------------------------------------------------------
# Rend le texte visible :
$texte->show();
#------------------------------------------------------------------------------
# Ajoute le texte dans la fenetre :
$window->add($texte);
#------------------------------------------------------------------------------
# Affichage de la fanetre :
$window->show();
#------------------------------------------------------------------------------
# Lancement de la boucle principale de Gtk+ :
main Gtk;
#------------------------------------------------------------------------------
# En principe le programme ne passe jamais par la :
exit( 0 );
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Une
fenêtre avec 3 boutons
|
Nous allons maintenant créer une fenêtre avec 3 boutons. Pour insérer les boutons dans la fenêtre nous allons utiliser l'objet VBox, qui alignera verticalement les boutons.
Voici le résultat du programme :
Et voici le programme source qui a créé la fenêtre ci-dessus :
#!/usr/bin/perl
-w
##############################################################################
#
3
b o u t o n s
d a n s
u n e
f e n ê t r e #
##############################################################################
# Liste des
modules utilises :
use Gtk;
init Gtk;
#------------------------------------------------------------------------------
# Creation de la fenetre :
my $window = Gtk::Window->new( 'toplevel' );
#------------------------------------------------------------------------------
# Creation du conteneur :
my $boite = Gtk::VBox->new( 1 , 10 );
#------------------------------------------------------------------------------
# Creation des boutons :
my $bouton_1 = Gtk::Button->new("Afficher Bonjour");
my $bouton_2 = Gtk::Button->new("Afficher Au Revoir");
my $bouton_3 = Gtk::Button->new("Quitter");
#------------------------------------------------------------------------------
# Configuration de la fenetre :
$window->set_usize( 320, 200 );
$window->set_title( "Une fenetre et 3 boutons en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Definit l'espace vide entre les elements visuels et le bord de la fenetre
:
$window->border_width( 30 );
#------------------------------------------------------------------------------
# Connexion des fonctions de rappels aux boutons :
$bouton_1->signal_connect( "clicked", \&bonjour );
$bouton_2->signal_connect( "clicked", \&au_revoir );
$bouton_3->signal_connect( "clicked", \&quitter );
#------------------------------------------------------------------------------
# Rend les boutons visibles :
$bouton_1->show();
$bouton_2->show();
$bouton_3->show();
#------------------------------------------------------------------------------
# Ajoute les boutons au conteneur $boite :
$boite->add($bouton_1);
$boite->add($bouton_2);
$boite->add($bouton_3);
#------------------------------------------------------------------------------
# Rend le conteneur visible :
$boite->show;
#------------------------------------------------------------------------------
# Ajoute le conteneur a la fenetre :
$window->add( $boite );
#------------------------------------------------------------------------------
# Affichage de la fanetre :
$window->show();
#------------------------------------------------------------------------------
# Lancement de la boucle principale de Gtk+ :
main Gtk;
#------------------------------------------------------------------------------
# En principe le programme ne passe jamais par la :
exit( 0 );
###############################################################################
# Definition des fonctions de rappels des boutons :
sub bonjour
{
print "Bonjour !\n";
return 0;
}
#------------------------------------------------------------------------------
sub au_revoir
{
print "Au revoir !\n";
return 0;
}
#------------------------------------------------------------------------------
sub quitter
{
Gtk->exit( 0 );
return 0;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Utilisation
d'une zone de dessin
|
En GTK+, une zone de dessin est un objet DrawingArea, qui permet de dessiner dans une fenêtre des pixels, des droites, des aires, ou tout autre objet géométrique, de forme et de couleur variées.
Voici par exemple une zone de dessin DrawingArea, sur laquelle on a dessiné 4 éléments :
- un peigne jaune (dessiné pixel par pixel, ou point par point)
- une ligne rouge
- un rectangle vert, PLEIN
- un rectangle blanc, VIDE
De plus, la couleur du fond de cette zone de dessin est bleue :
Voyons comment réaliser de tel graphiques, en utilisant l'objet DrawingArea de GTK, à travers le programme suivant commenté :
#!/usr/bin/perl
-w
##############################################################################
# U t i l i s a t i o n
d ' u n e
z o n e
d e
d e s s i n #
##############################################################################
use Gtk;
use strict;
init Gtk;
# Creation
et configuration de la fenetre :
my $window = Gtk::Window->new( 'toplevel' );
$window->set_usize( 320, 200 );
$window->set_title( "Zone de dessin en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Creation
de la zone de dessin (objet DrawingArea) :
my $drawing_area = Gtk::DrawingArea->new();
# Connecte
la fonction de rappel "dessiner" la zone de dessin :
$drawing_area->signal_connect( 'configure_event', \&dessiner
);
$drawing_area->signal_connect( 'expose_event', \&dessiner );
# Rend la
zone de dessin visible :
$drawing_area->show();
# Ajoute la
zone de dessin dans la fenetre :
$window->add( $drawing_area );
# Rend la
fenetre visible :
$window->show();
# Lance la
boucle principale de GTK+ :
main Gtk;
# En principe
le programme ne passe jamais par la :
exit(
0 );
################################################################################################
# Fonction de rappel :
sub dessiner
{
#
Declaration des variables locales :
my
$zone_de_dessin = $drawing_area->window;
my
$i;
my
$j;
#--------------------------------------------------------------------------
#
Configuration de la couleur du fond de la zone de dessin :
#
On recupere le contexte graphique de la zone de dessin :
my
$gc = Gtk::Gdk::GC->new($zone_de_dessin);
#
On modifie les 3 composantes de la couleur du contexte graphique :
$gc->{
'red' } = 0;
$gc->{
'green' } = 0;
$gc->{
'blue' } = 50000;
#
Utilise le nouveau contexte graphique comme couleur du fond de la zone de dessin
:
$zone_de_dessin->set_background(
$zone_de_dessin->get_colormap()->color_alloc( $gc ) );
#--------------------------------------------------------------------------
#
On modifie a nouveau les 3 composantes de la couleur du contexte graphique :
$gc->{
'red' } = 65535;
$gc->{
'green' } = 65535;
$gc->{
'blue' } = 0;
#
Utilise le nouveau contexte graphique comme couleur de premier plan de la zone
de dessin :
$gc->set_foreground($zone_de_dessin->get_colormap()->color_alloc($gc));
#
Dessin du peigne jaune, pixel par pixel :
for
($j=0;$j<8;$j++)
{
for
($i=0;$i<60;$i++)
{
$zone_de_dessin->draw_point(
$gc, 10+$i+10*$j, 30+$i );
}
}
#--------------------------------------------------------------------------
#
On modifie a nouveau les 3 composantes de la couleur du contexte graphique :
$gc->{
'red' } = 65535;
$gc->{
'green' } = 0;
$gc->{
'blue' } = 0;
#
Utilise le nouveau contexte graphique comme couleur de premier plan de la zone
de dessin :
$gc->set_foreground($zone_de_dessin->get_colormap()->color_alloc($gc));
#
Dessine la ligne rouge :
$zone_de_dessin->draw_line(
$gc,20,180,130,120);
#--------------------------------------------------------------------------
#
On modifie a nouveau les 3 composantes de la couleur du contexte graphique :
$gc->{
'red' } = 0;
$gc->{
'green' } = 65535;
$gc->{
'blue' } = 0;
#
Utilise le nouveau contexte graphique comme couleur de premier plan de la zone
de dessin :
$gc->set_foreground($zone_de_dessin->get_colormap()->color_alloc($gc));
#
Dessine le rectangle vert PLEIN (second parametre de draw_rectangle = 1 = VRAI)
$zone_de_dessin->draw_rectangle(
$gc,1,150,20,130,60);
#--------------------------------------------------------------------------
#
On modifie a nouveau les 3 composantes de la couleur du contexte graphique :
$gc->{
'red' } = 65535;
$gc->{
'green' } = 65535;
$gc->{
'blue' } = 65535;
#
Utilise le nouveau contexte graphique comme couleur de premier plan de la zone
de dessin :
$gc->set_foreground($zone_de_dessin->get_colormap()->color_alloc($gc));
#
Dessine le rectangle blanc VIDE (second parametre de draw_rectangle = 0 = FAUX)
$zone_de_dessin->draw_rectangle(
$gc,0,150,110,130,70);
################################################################################################
return
1;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Affichage
d'une mire de couleurs
|
En application de la zone de dessin DrawingArea, le programme suivant allume tous les pixels de l'aire graphique un par un, et affiche ainsi une mire de couleurs en 16 millions de couleurs :
Et voici le programme en Perl qui a dessiné cette superbe mire de couleurs :
#!/usr/bin/perl
-w
##############################################################################
# A f f i c h a g e d ' u n e
m i r e d e c
o u l e u r s # ##############################################################################
use Gtk;
use strict;
init Gtk;
# Creation et configuration
de la fenetre :
my $window = Gtk::Window->new ('toplevel');
$window->set_usize (320, 200);
$window->set_title ("Mire de couleurs en GTK-Perl");
$window->signal_connect ('destroy', sub { Gtk->exit (0);});
# Creation de la
zone de dessin (objet DrawingArea) :
my $drawing_area = Gtk::DrawingArea->new ();
# Connecte la fonction
de rappel "dessiner" la zone de dessin :
$drawing_area->signal_connect ('configure_event', \&dessiner);
$drawing_area->signal_connect ('expose_event', \&dessiner);
# Rend la zone de
dessin visible :
$drawing_area->show ();
# Ajoute la zone
de dessin dans la fenetre :
$window->add ($drawing_area);
# Rend la fenetre
visible :
$window->show ();
# Lance la boucle
principale de GTK+ (affichage de la fenetre a l'ecran) :
main Gtk;
# En
principe le programme ne passe jamais par la :
exit
(0);
################################################################################################
# Fonction de rappel :
################################################################################################
sub dessiner
{
# Declaration des variables
locales :
my $zone_de_dessin = $drawing_area->window;
my $x;
my $y;
#--------------------------------------------------------------------------
# On recupere le contexte graphique
de la zone de dessin :
my $gc = Gtk::Gdk::GC->new
($zone_de_dessin);
# On modifie les 3 composantes
de la couleur du contexte graphique :
$gc->{'red'} = 0;
$gc->{'green'} = 0;
$gc->{'blue'} = 0;
# Utilise le nouveau contexte
graphique comme couleur du fond de la zone de dessin :
$zone_de_dessin->set_background
($zone_de_dessin->get_colormap()->color_alloc ($gc));
# Allume tous les pixels 1 par
1 :
for($x=0;$x<320;$x++)
{
for($y=0;$y<200;$y++)
{
#
On modifie les 3 composantes de la couleur du contexte graphique :
$gc->{'red'}
= 200*$x;
$gc->{'green'}
= 300*$y;
$gc->{'blue'}
= 200*(320-$x);
#
Utilise le nouveau contexte graphique dans la zone de dessin :
$gc->set_foreground
($zone_de_dessin->get_colormap()->color_alloc ($gc));
#
Allume le pixel aux coordonnees $x et $y :
$zone_de_dessin->draw_point(
$gc, $x, $y );
}
}
return
1;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Conteneurs
et contenus
|
Pour insérer un objet dans une application GTK+, l'objet doit être placé dans un conteneur. Comme le montre la hiérarchie des objets de GTK+, il existe 2 grandes familles de conteneurs :
- les objets Container
- les objets Bin
Les objets Container peuvent contenir plusieurs objets. Les 4 principaux objets Container sont :
- VBox
- HBox
- Table
- Notebook
Les objets Bin ne peuvent contenir qu'un seul objet. Les principaux objets Bin sont :
- Window
- Dialog
- Frame
- Button
Comment faire dans ces conditions pour mettre plusieurs objets dans une fenetre, alors que l'objet Window est dérivé de Bin ? La solution est de mettre 1 objet Container dans la fenêtre (par exemple une VBox), puis de placer plusieurs objets dans ce Container.
Un premier exemple a déjà été donné dans le programme affichant une fenêtre avec 3 boutons :
Fenêtre n°1
Dans cette fenêtre n°1, les boutons ne sont en fait pas placés directement sur la fenetre : ils sont placés dans une boîte (objet VBox), puis cette boîte est placée sur la fenêtre. On peut alors résumer la structure de cette fenêtre n°1 en disant :
" les boutons sont placés dans une boite, qui est placée sur la fenêtre "
Ce que nous écrirons désormais :
boutons --> boite --> fenetre
Nous appellerons ceci la structure d'empilement des objets dans la fenêtre. Cette structure décrit la manière dont les objets sont empilés entre eux pour former l'application.
ATTENTION : la structure d'empilement des objets dans le fenêtre n'a rien à voir avec la hiérarchie des objets de GTK+.
Remarque : les objets VBox, HBox, et Table sont totalement invisibles dans la fenêtre de l'application. Leur but est de permettre de placer plusieurs objets dans un conteneur dérivé de Bin, qui ne peut contenir qu'un seul objet.
Imaginons maintenant que nous voulions ajouter un cadre (objet Frame) autour des 3 boutons de la fenêtre n°1, dans le but d'obtenir la fenêtre n°2 ci-dessous :
Fenêtre n°2
Comme Frame est un objet dérivé de Bin, il ne peut contenir qu'un seul objet : on ne peut pas placer les 3 boutons directement dans le cadre. On va donc utiliser un objet VBox (une boîte) entre les boutons et le cadre.
La structure d'empilement des objets de la fenêtre n°2 est la suivante :
bouton_1 --+
|
bouton_2 --+--> boite --> cadre --> fenetre
|
bouton_3 --+
Cette structure d'empilement signifie :
"Les boutons sont placés dans une boite, qui est placée dans un cadre, qui est placé dans la fenêtre"
Rappel : la boite (objet VBox) est invisible sur la fenêtre n°2.
L'écriture du programme qui crée la fenêtre n°2 va reprendre la structure d'empilement des objets. Dans ce programme, nous allons créer les 4 objets (les boutons, la boite, le cadre, et la fenêtre), en commençant par l'objet de plus haut niveau (les boutons) et en finissant par l'objet de plus bas niveau (la fenêtre). Nous alons donc, dans l'ordre :
- préparer les boutons
- préparer la boîte, puis y insérer les boutons
- préparer le cadre, puis y insérer la boîte
- préparer la fenêtre, puis y insérer le cadre
- lancer la boucle principale de GTK+
Pour chacun des 4 objets créés (les boutons, la boite, le cadre, et la fenêtre), nous allons effectuer les 4 actions suivantes :
- créer l'objet (appel de la méthode new de la classe)
- configurer l'objet (taille, connexion des fonctions de rappels, etc.)
- ajouter dans l'objet, l'objet de niveau supérieur précédemment préparé (méthode add de l'objet)
- rendre l'objet visible (méthode show de l'objet)
Et voici maintenant le code source en Perl qui a généré la fenêtre n°2 :
#!/usr/bin/perl
-w
###############################################################################
# E m p i
l e m e n t d
e s
o b j e t s d
a n s
u n e
f e n e t r e #
###############################################################################
# Liste des modules
utilises :
use Gtk;
use strict;
init Gtk;
###############################################################################
# boutons ---> boite ---> cadre --->
fenetre #
###############################################################################
# Creation des boutons
:
my $bouton_1 = Gtk::Button->new("Bouton 1");
my $bouton_2 = Gtk::Button->new("Bouton 2");
my $bouton_3 = Gtk::Button->new("Bouton 3");
# Configuration
des boutons :
# (connexion des fonctions de rappels aux boutons)
$bouton_1->signal_connect( "clicked", \&bouton_1 );
$bouton_2->signal_connect( "clicked", \&bouton_2);
$bouton_3->signal_connect( "clicked", \&bouton_3);
# Rend les boutons
visibles :
$bouton_1->show();
$bouton_2->show();
$bouton_3->show();
###############################################################################
# boutons ---> boite
---> cadre ---> fenetre #
###############################################################################
# Creation de la
boite :
my $boite = Gtk::VBox->new(1,10);
# Configuration
de la boite :
$boite->border_width(20);
# Ajoute les boutons
dans la boite :
$boite->add($bouton_1);
$boite->add($bouton_2);
$boite->add($bouton_3);
# Rend la boite
visible :
$boite->show;
###############################################################################
# boutons ---> boite ---> cadre
---> fenetre #
###############################################################################
# Creation du cadre
:
my $cadre = Gtk::Frame->new("Mon cadre");
# Configuration
du cadre :
$cadre->border_width(20);
# Ajoute la boite
$boite dans le cadre $cadre :
$cadre->add($boite);
# Rend le cadre
visible :
$cadre->show;
###############################################################################
# boutons
---> boite ---> cadre ---> fenetre #
###############################################################################
# Creation de la
fenetre :
my $fenetre = Gtk::Window->new( 'toplevel' );
# Configuration
de la fenetre :
$fenetre->set_usize( 320, 200 );
$fenetre->set_title( "Une fenetre et 3 boutons en GTK-Perl" );
$fenetre->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Ajoute le cadre
$cadre dans la fenetre $fenetre :
$fenetre->add( $cadre );
# Rend la fenetre
visible :
$fenetre->show();
###############################################################################
# Lance la boucle principale de Gtk+ (affichage de la fenetre a l'ecran) :
main Gtk;
###############################################################################
# En principe le
programme ne passe jamais par la :
exit( 0 );
###############################################################################
# Definition
des
fonctions
de
rappels
des
boutons #
###############################################################################
sub bouton_1
{
print "Bouton 1\n";
return 0;
}
###############################################################################
sub bouton_2
{
print "Bouton 2\n";
return 0;
}
###############################################################################
sub bouton_3
{
print "Le bouton 3 quitte l'application\n";
Gtk->exit( 0 );
return 0;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Utilisation
des tableaux
|
Un tableau (objet Table de GTK) permet d'organiser la répartition des objets dans une fenêtre.
La fenêtre suivante par exemple contient un tableau à 4 cellules (un tableau 2x2). Un cadre a été placé dans chaque cellule, et un bouton dans chaque cadre :
La structure d'empilement des objets de la fenêtre ci-dessus est la suivante :
bouton_1 --->
cadre_1 ---\
\
bouton_2 ---> cadre_2 -----\
+---> tableau --->
fenetre
bouton_3 ---> cadre_3 -----/
/
bouton_4 ---> cadre_4 ---/
Et voivi le code qui a permis de générer cette fenêtre (les boutons ne servant qu'à illustrer l'utilisation des cellules du tableau, aucune fonction de rappel n'a été écrite dans ce programme) :
#!/usr/bin/perl
-w
# Liste des modules utilises :
use Gtk;
use strict;
init Gtk;
###############################################################################
# boutons ---> cadres ---> tableau
---> fenetre #
###############################################################################
# Creation des boutons
:
my $bouton_1 = Gtk::Button->new("Bouton 1");
my $bouton_2 = Gtk::Button->new("Bouton 2");
my $bouton_3 = Gtk::Button->new("Bouton 3");
my $bouton_4 = Gtk::Button->new("Bouton 4");
# Definit l'espace
vide AUTOUR des boutons :
$bouton_1->border_width(20);
$bouton_2->border_width(20);
$bouton_3->border_width(20);
$bouton_4->border_width(20);
# Rend les boutons
visibles :
$bouton_1->show();
$bouton_2->show();
$bouton_3->show();
$bouton_4->show();
###############################################################################
# boutons ---> cadres
---> tableau ---> fenetre #
###############################################################################
# Creation des cadres
:
my $cadre_1 = Gtk::Frame->new("Cadre 1");
my $cadre_2 = Gtk::Frame->new("Cadre 2");
my $cadre_3 = Gtk::Frame->new("Cadre 3");
my $cadre_4 = Gtk::Frame->new("Cadre 4");
# Definit l'espace
vide AUTOUR des cadres :
$cadre_1->border_width(20);
$cadre_2->border_width(20);
$cadre_3->border_width(20);
$cadre_4->border_width(20);
# Ajoute les boutons
dans les cadres :
$cadre_1->add($bouton_1);
$cadre_2->add($bouton_2);
$cadre_3->add($bouton_3);
$cadre_4->add($bouton_4);
# Rend les cadres
visibles :
$cadre_1->show;
$cadre_2->show;
$cadre_3->show;
$cadre_4->show;
###############################################################################
# boutons ---> cadres ---> tableau
---> fenetre #
###############################################################################
# Creation du tableau
:
my $tableau = Gtk::Table->new(2,2,0);
# Les séparations entre les lignes et les colonnes du tableau sont numérotées ainsi :
# 0 1 2
#
# 0 +---------+---------+
# | | |
# | | |
# | | |
# 1 +---------+---------+
# | | |
# | | |
# | | |
# 2 +---------+---------+
# La méthode
attach_defaults de la classe Table utilise ces numérotations
# pour insérer un objet dans une cellule.
# Par exemple ci-dessous,
le cadre_3 est placé dans la cellule dont la colonne
# est entre le 0 et le 1 et dont la ligne est entre le 1 et le 2 :
# Place chaque cadre
dans une cellule du tableau :
$tableau->attach_defaults( $cadre_1, 0, 1, 0, 1 );
$tableau->attach_defaults( $cadre_2, 1, 2, 0, 1 );
$tableau->attach_defaults( $cadre_3, 0, 1, 1, 2 );
$tableau->attach_defaults( $cadre_4, 1, 2, 1, 2 );
# Après ces 4 appels de la méthode attach_defaults, voici la
# position de chaque cadre dans les cellules du tableau :
# 0 1 2
#
# 0 +---------+---------+
# | | |
# | cadre
1 | cadre
2 |
# | | |
# 1 +---------+---------+
# | | |
# | cadre
3 | cadre
4 |
# | | |
# 2 +---------+---------+
# Rend le tableau
visible :
$tableau->show();
###############################################################################
# boutons ---> cadres ---> tableau
---> fenetre #
###############################################################################
# Creation de la
fenetre :
my $fenetre = Gtk::Window->new( 'toplevel' );
# Configuration
de la fenetre :
$fenetre->set_usize( 500, 300 );
$fenetre->set_title( "Un tableau avec 4 cellules en GTK-Perl" );
$fenetre->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Ajoute le tableau
dans la fenetre :
$fenetre->add( $tableau );
# Rend la fenetre
visible :
$fenetre->show();
###############################################################################
# Lance de la boucle
principale de Gtk+ (affichage de la fenetre a l'ecran) :
main Gtk;
# En principe le
programme ne passe jamais par la :
exit( 0 );
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Voyons maintenant un autre exemple d'utilisation de l'objet Table :
Cette fois le tableau a toujours 4 cellules (dimension 2x2), mais le cadre 3 utilise les deux cellules de la colonne de droite.
La structure d'empilement des objets de la fenêtre ci-dessus est la suivante :
bouton_1
---> cadre_1 ---+
|
|
label --->
cadre_2 ---+---> tableau ---> fenetre
bouton_2 ---+ |
| |
bouton_3 ---+---> boite ---> cadre_3 ---+
|
bouton_4 ---+
On remarque qu'une boite (objet VBox, invisible sur la fenêtre) a été utilisée pour placer les 3 boutons dans le cadre 3.
Et voivi le code qui a permis de générer cette fenêtre (les boutons ne servant qu'à illustrer l'utilisation des cellules du tableau, aucune fonction de rappel n'a été écrite dans ce programme) :
#!/usr/bin/perl
-w
##############################################################################
# U t i l i s a t i o n d ' u n
t a b l e a u #
##############################################################################
# Liste des modules utilises :
use Gtk;
use strict;
init Gtk;
###############################################################################
# Creation
des boutons :
my $bouton_1 = Gtk::Button->new("Bouton 1");
my $bouton_2 = Gtk::Button->new("Bouton 2");
my $bouton_3 = Gtk::Button->new("Bouton 3");
my $bouton_4 = Gtk::Button->new("Bouton 4");
# Defini l'espace
vide AUTOUR des boutons :
$bouton_1->border_width(20);
$bouton_2->border_width(10);
$bouton_3->border_width(10);
$bouton_4->border_width(10);
# Rend les
boutons visibles :
$bouton_1->show();
$bouton_2->show();
$bouton_3->show();
$bouton_4->show();
###############################################################################
# Creation
du label :
my $label = Gtk::Label->new("Ceci est un Label");
# Rend le
label visible :
$label->show();
###############################################################################
# Creation
de la boite :
my $boite = Gtk::VBox->new(1,10);
# Configuration
de la boite :
$boite->border_width(20);
# Ajoute les
boutons dans la boite :
$boite->add($bouton_2);
$boite->add($bouton_3);
$boite->add($bouton_4);
# Rend la
boite visible :
$boite->show;
###############################################################################
# Creation
des cadres :
my $cadre_1 = Gtk::Frame->new("Cadre 1");
my $cadre_2 = Gtk::Frame->new("Cadre 2");
my $cadre_3 = Gtk::Frame->new("Cadre 3");
# Defini l'espace
vide AUTOUR des cadres :
$cadre_1->border_width(20);
$cadre_2->border_width(20);
$cadre_3->border_width(20);
# Ajoute les
boutons dans les cadres :
$cadre_1->add($bouton_1);
$cadre_2->add($label);
$cadre_3->add($boite);
# Rend les
cadres visibles :
$cadre_1->show;
$cadre_2->show;
$cadre_3->show;
###############################################################################
# Creation
du tableau :
my $tableau = Gtk::Table->new(2,2,0);
# Les séparations entre les lignes et les colonnes du tableau sont numérotées ainsi :
# 0 1 2
#
# 0 +---------+---------+
# | | |
# | | |
# | | |
# 1 +---------+---------+
# | | |
# | | |
# | | |
# 2 +---------+---------+
# Place chaque
cadre dans une cellule du tableau :
$tableau->attach_defaults( $cadre_1, 0, 1, 0, 1 );
$tableau->attach_defaults( $cadre_2, 0, 1, 1, 2 );
$tableau->attach_defaults( $cadre_3, 1, 2, 0, 2 );
# Après ces
3 appels de la méthode attach_defaults, voici la
# position de chaque cadre dans les cellules du tableau :
# 0 1 2
#
# 0 +---------+---------+
# | | |
# | cadre
1 | |
# | | |
# 1 +---------+ cadre
3 |
# | | |
# | cadre
2 | |
# | | |
# 2 +---------+---------+
# Rend le
tableau visible :
$tableau->show();
###############################################################################
# Creation
de la fenetre :
my $fenetre = Gtk::Window->new( 'toplevel' );
# Configuration
de la fenetre :
$fenetre->set_usize( 500, 300 );
$fenetre->set_title( "Un tableau avec 4 cellules en GTK-Perl" );
$fenetre->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
# Ajoute le
tableau dans la fenetre :
$fenetre->add( $tableau );
# Rend la
fenetre visible :
$fenetre->show();
###############################################################################
# Lancement
de la boucle principale de Gtk+ (affichage de la fenetre) :
main Gtk;
###############################################################################
# En principe
le programme ne passe jamais par la :
exit( 0 );
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Boutons
radio et cases à cocher
|
Le programme suivant montre comment utiliser les boutons radio et les cases à cocher. Il propose 3 cases à cocher et 3 boutons radio, puis affiche l'état de chacun d'entre eux lorsqu'on appuie sur le bouton "valider" :
#!/usr/bin/perl
-w
###############################################################################
#Programme modele en Gtk-Perl utilisant des boutons radio et des cases a cocher
# Realise par Jean-Christophe MICHEL le 28 septembre 2003
###############################################################################
# Liste des modules utilises :
use Gtk;
init Gtk;
##############################################################################
#
Creation des cases a cocher :
my $case_a_cocher_1 = Gtk::CheckButton->new("Case 1");
my $case_a_cocher_2 = Gtk::CheckButton->new("Case 2");
my $case_a_cocher_3 = Gtk::CheckButton->new("Case 3");
#
Rend les cases a cocher visibles :
$case_a_cocher_1->show();
$case_a_cocher_2->show();
$case_a_cocher_3->show();
##############################################################################
#
Creation des boutons radio :
my $bouton_radio_1 = Gtk::RadioButton->new("Radio 1");
my $bouton_radio_2 = Gtk::RadioButton->new("Radio 2",$bouton_radio_1);
my $bouton_radio_3 = Gtk::RadioButton->new("Radio 3",$bouton_radio_2);
#
Rend les boutons radio visibles :
$bouton_radio_1->show();
$bouton_radio_2->show();
$bouton_radio_3->show();
##############################################################################
#
Creation du bouton :
my $bouton = Gtk::Button->new("Valider");
#
Configuration du bouton :
# (connexion des fonctions de rappels aux boutons)
$bouton->signal_connect(
"clicked", \&analyser_case_et_radio );
#
Rend le bouton visible :
$bouton->show();
##############################################################################
#
Creation des labels :
my $label_1 = Gtk::Label->new("Resultats :");
my $label_2 = Gtk::Label->new("---");
#
Rend les labels visibles :
$label_1->show();
$label_2->show();
##############################################################################
#
Creation de la boite :
my $boite = Gtk::VBox->new(1,10);
#
Ajoute les cases a cocher dans la boite :
$boite->add($case_a_cocher_1);
$boite->add($case_a_cocher_2);
$boite->add($case_a_cocher_3);
#
Ajoute les boutons radio dans la boite :
$boite->add($bouton_radio_1);
$boite->add($bouton_radio_2);
$boite->add($bouton_radio_3);
#
Ajoute le bouton dans la boite :
$boite->add($bouton);
#
Ajoute les labels dans la boite :
$boite->add($label_1);
$boite->add($label_2);
#
Rend la boite visible :
$boite->show();
##############################################################################
#
Creation de la fenetre :
$window = Gtk::Window->new( 'toplevel' );
# Configuration de la fenetre :
$window->set_usize( 320, 300 );
$window->set_title( "Programme de base en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
#
Ajoute la boite dans la fenetre :
$window->add($boite);
#
Rend la fanetre visible :
$window->show();
##############################################################################
# Lancement de la boucle principale de Gtk+ :
main Gtk;
##############################################################################
# En principe le programme ne passe jamais par la :
exit( 0 );
##############################################################################
sub analyser_case_et_radio
{
my $message;
# Décodage des cases à cocher :
if ($case_a_cocher_1->active)
{
$message=$message."case 1 ";
}
if ($case_a_cocher_2->active)
{
$message=$message."case 2 ";
}
if ($case_a_cocher_3->active)
{
$message=$message."case 3 ";
}
# Décodage des boutons radio :
if ($bouton_radio_1->active)
{
$message=$message."radio 1 ";
}
if ($bouton_radio_2->active)
{
$message=$message."radio 2 ";
}
if ($bouton_radio_3->active)
{
$message=$message."radio 3 ";
}
$label_2->set_text($message);
return 0;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Retour au sommaire de cette page
|
Ligne
de saisie
|
L'objet Entry de Gtk+ est une ligne de saisie permettant à l'utilisateur d'entrer un message textuel sur une seule ligne. Le programme suivant montre comment l'utiliser :
#!/usr/bin/perl
-w
###############################################################################
# Programme modele en Gtk-Perl utilisant une ligne de saisie (objet Entry)
# Realise par Jean-Christophe MICHEL le 28 septembre 2003
###############################################################################
# Liste des modules utilises :
use Gtk;
init Gtk;
##############################################################################
#
Creation de la ligne de saisie :
my $ligne_de_saisie = Gtk::Entry->new(50);
# Rend la ligne de saisie visible :
$ligne_de_saisie->show();
##############################################################################
#
Creation du bouton :
my $bouton = Gtk::Button->new("Valider");
# Configuration du bouton :
# (connexion des fonctions de rappels aux boutons)
$bouton->signal_connect( "clicked", \&afficher_resultat );
# Rend le bouton visible :
$bouton->show();
##############################################################################
#
Creation des labels :
my $label_1 = Gtk::Label->new("Entrez un mot :");
my $label_2 = Gtk::Label->new("---");
# Rend les labels visibles :
$label_1->show();
$label_2->show();
##############################################################################
#
Creation de la boite :
my $boite = Gtk::VBox->new(1,10);
#
Ajoute un label dans la boite :
$boite->add($label_1);
#
Ajoute la ligne de saisie dans la boite :
$boite->add($ligne_de_saisie);
#
Ajoute le bouton dans la boite :
$boite->add($bouton);
#
Ajoute l'autre label dans la boite :
$boite->add($label_2);
#
Rend la boite visible :
$boite->show();
##############################################################################
# Creation de la fenetre :
$window = Gtk::Window->new( 'toplevel' );
##############################################################################
# Configuration de la fenetre :
$window->set_usize( 300, 150 );
$window->set_title( "Ligne de saisie en GTK-Perl" );
$window->signal_connect( 'destroy', sub { Gtk->exit( 0 ); } );
#
Ajoute la boite dans la fenetre :
$window->add($boite);
#
Rend la fanetre visible :
$window->show();
##############################################################################
# Lancement de la boucle principale de Gtk+ :
main Gtk;
##############################################################################
#
En principe le programme ne passe jamais par la :
exit( 0 );
##############################################################################
sub afficher_resultat
{
my $message="Vous avez saisie : ";
# Récupère
le message entré sur la ligne de saisie :
$message=$message.$ligne_de_saisie->get_text();
$label_2->set_text($message);
return
0;
}
##############################################################################
# F i n
d u p r o g r a m m e #
##############################################################################
Voilà, avec tout ça vous pouvez désormais construire pour vos applications de véritables interfaces graphiques professionnelles en Gtk-Perl.