III. Description et réalisation d'un exemple▲
III-A. Chargement de la librairie GTK et notre premier widget : GtkWindow▲
Maintenant que PHP-GTK est installé et fonctionne sur votre poste, nous allons analyser pas à pas la structure du script d'exemple "hello.php" et créer le nôtre, qui aura pour nom "dvp.php". Pour ce faire, créez un répertoire "mes_tests" sous le répertoire PHP4, ouvrez votre EDI favori.
Le script "dvp.php" est très simple. Il créé une fenêtre, place un bouton dedans, affiche du texte et détruit la fenêtre lorsqu'on clique sur le bouton.
En premier lieu, il faut charger la librairie GTK de façon à disposer de ses différentes ressources, d'où les premières lignes suivantes dans le script hello.php :
<?php
if
(!
extension_loaded("
gtk
"
)) {
dl( "
php_gtk
.
"
.
PHP_SHLIB_SUFFIX);
}
?>
On peut également l'écrire sous cette forme :
<?php
if
(!
class_exists("
gtk
"
)) {
//
si
l'OS
est
windows,
chargement
de
la
php_gtk.dll
if
(strtoupper(substr(PHP_OS,
0
,
3
) =
=
"
WIN
"
)) {
dl("
php_gtk
.
dll
"
);
}
//
sinon
chargement
du
php_gtk.so
(linux,
mac
os)
else
{
dl("
php_gtk
.
so
"
);
}
}
?>
Cela nous rend indépendants de l'environnement sur lequel tourne notre script en testant l'OS, nous allons charger soit les extensions .dll (Win32) soit .so (Linux et MacOS).
Ensuite, nous créons un nouvel objet GTK. Nous appelons la classe GtkWindow grâce à l'opérateur new, ceci afin de produire un widget fenêtre qui sera notre container :
<?php
$window
=
&
new
GtkWindow();
$window
-
>
show_all();
Gtk:
:
main();
?>
Nous voyons que nous appelons l'objet GtkWindow par référence dans le constructeur (signe &).
Petit rappel concernant les références : une référence est un alias pointant directement une variable. Par exemple :
$a
=
1;
$b
=
&
$a
;
//
$b
a
maintenant
la
valeur
de
$a
$a
+
+
;
Echo $b
;
//
affiche
2,
soit
la
valeur
de
$a
incrémentée
de
1
Unset ($a
);
//
la
variable
$a
n'existe
plus
Echo $b
;
//
affiche
toujours
2,
contient
toujours
la
valeur
de
$a
à
l'origine.
On utilise également les références pour passer des paramètres aux fonctions (ce qui permet d'économiser le return dans la fonction et d'avoir plusieurs variables en retour de celle-ci) et pour faire référence aux objets.
Ici, on utilise le passage par référence pour l'objet GtkWindow, ainsi, quand on applique une fonction à $window, c'est comme si on l'appliquait directement à GtkWindow.
$window->show_all() permet simplement d'afficher la fenêtre ainsi que son contenu et Gtk::main() exécute la boucle principale.
Ces deux fonctions et le chargement de la librairie GTK seront systématiquement présents dans chacun de vos scripts.
Nous allons écrire ces trois lignes dans notre script dvp.php à la suite du chargement de la librairie GTK.
III-B. Ajout d'une fonction : destroy()▲
Si vous lancez ce script tel qu'il est (avec la ligne de commande C:\PHP4\php C:\PHP4\votre_rep\votre_script.php), vous obtiendrez une fenêtre grise et vide avec pour titre 'votre_script.php'.
Si vous essayez de fermer cette fenêtre avec la traditionnelle croix, vous remarquerez que la fenêtre disparaît mais le programme est toujours actif dans votre fenêtre de commande.
Vous n'avez alors pas d'autre choix que de fermer la fenêtre DOS ou de faire un ctrl+C pour arrêter le script.
Pour palier ce problème, nous allons ajouter une fonction qui s'exécutera lorsque nous cliquerons sur la croix de fermeture de la fenêtre :
<?php
function
destroy() {
Gtk:
:
main_quit();
}
?>
Rajoutons cette fonction entre le chargement de la librairie et la création de notre fenêtre.
Nous allons appeler cette fonction avec la méthode connect(). Cette méthode prend deux paramètres. Le premier est le rappel (événement) "destroy" qui émet le signal "destroy". Ce rappel fait partie des événements du "delete-event" de PHP-GTK. Au signal reçu, nous appellerons la fonction destroy() (qui est le deuxième paramètre de la méthode connect(), sans les parenthèses) qui s'exécutera, arrêtera la boucle principale, détruira le widget $window et fermera la fenêtre. Il est à noter qu'il n'est pas indispensable que la fonction appelée porte le même nom que le rappel. Nous aurions très bien pu l'appeler toto(), auquel cas nous l'aurions connectée de cette façon : $window->connect("destroy","toto").
On appelle cette fonction, directement après avoir créé la fenêtre :
<?php
$window
=
&
new
GtkWindow();
//
Appel
à
la
function
destroy()
$window
-
>
connect("
destroy
"
,
"
destroy
"
);
$window
-
>
show_all();
Gtk:
:
main();
?>
En exécutant le script, vous vous rendez compte que, cette fois, en cliquant sur la croix en haut à droite de la boîte de dialogue, le script est bien arrêté et vous récupérez la main dans la fenêtre de commande.
III-C. Aspect de notre fenêtre GtkWindow▲
Occupons-nous maintenant de l'aspect de la fenêtre. Nous lui ajoutons une bordure de 10 pixels avec la méthode set_border_width(). Si nous ajoutons un widget à cette fenêtre, il en prendra la superficie moins 10 pixels en hauteur et largeur.
<?php
$window
-
>
set_border_width(10
);
?>
Si nous mettons une bordure de 100 pixels et que nous lançons le script, nous voyons que la taille de la fenêtre a augmenté de façon à avoir une bordure de 100 pixels. La taille de la fenêtre est donc dynamique. Nous aurions très bien pu lui assigner une taille fixe grâce à la méthode set_default_size(largeur,hauteur) ainsi qu'un positionnement sur l'écran avec la méthode set_position(). Cette dernière méthode possède quatre différentes valeurs de GtkWindowPosition :
Valeur | Nom symbolique | Description |
---|---|---|
0 | GTK_WIN_POS_NONE | Laisse au système de fenêtrage de la machine définir la position automatiquement. Généralement, elle sera placée en haut à gauche de l'écran (Etat par défaut). |
1 | GTK_WIN_POS_CENTER | Place la fenêtre au centre de l'écran. |
2 | GTK_WIN_POS_MOUSE | Dessine la fenêtre à la pointe de la souris. Très utile pour le menus pop up ou autres widget similaires qui sont générés par un clic de souris. |
3 | GTK_WIN_POS_CENTER_ALWAYS | Place la fenêtre au centre de l'écran et garde en mémoire les coordonnées de sa position. Si vous l'agrandissez ou la déplacez, elle reprendra automatiquement sa place au centre. |
La méthode set_position() accepte la valeur ou le nom symbolique en paramètre. Prenez l'habitude de mettre le nom symbolique, qui est beaucoup plus parlant que la valeur. Nous venons de voir que le widget GtkWindow dispose de deux autres méthodes : set_default_size() et set_position(). En fait, il en possède beaucoup plus que cela. Nous le verrons dans un prochain tutoriel où nous nous amuserons à changer la couleur de fond de la fenêtre, changer la police de caractères, etc.
Nous n'incluons pas le set_default_size() et le set_position() dans notre script, mais rien ne vous empêche de jouer avec.
III-D. Ajout d'un bouton : GtkButton▲
Ajoutons maintenant un bouton à notre fenêtre. Il sera associé à une fonction qui affiche sa valeur, ferme l'application et affiche un message dans l'invite de commandes. Nous allons, encore une fois, utiliser la méthode connect() et ses deux paramètres, le rappel et la fonction. Le widget GtkButton possède cinq rappels différents qui envoient cinq signaux homonymes :
Rappel | Description |
---|---|
pressed() | Emet le signal "pressed" quand le bouton est pressé |
released() | Emet le signal "released" quand le bouton est libéré |
clicked() | Emet le signal "clicked" quand le bouton est cliqué |
enter() | Emet le signal "enter" quand le curseur est sur le bouton |
leave() | Emet le signal "leave" quand le curseur a quitté la région du bouton |
Nous allons utiliser le rappel clicked() et nous allons lier ce rappel à la fonction hello_dvp() que nous écrirons ultérieurement. Pour l'instant, créons le nouveau widget GtkButton. Connectons-lui un rappel, qui exécutera une fonction hello_dvp() grâce à la méthode connect(). Ajoutons notre bouton au container principal $window avec la méthode add().
Nous touchons là une partie très importante de PHP-GTK : la hiérarchie des containers. En effet, lorsque vous réaliserez des interfaces complexes (ex : zones de saisie avec textarea, scrollbar et différents boutons), il faudra parquer (avec la méthode pack_start() que nous verrons dans un prochain tutorial) ces différents widgets dans des containers qui seront inclus dans des containers et ainsi de suite, afin de n'en avoir plus qu'un seul à ajouter a notre fenêtre pricipale avec la méthode add().
Nous construirons les containers dans l'ordre : A B C D E. Nous parquerons (méthode pack_start()) dans l'ordre E D C dans B que nous ajouterons (méthode add()) dans le container principal A.
Puisque dans notre cas, nous n'avons qu'un seul widget (GtkButton) nous l'ajoutons, sans le parquer, dans notre fenêtre principale (GtkWindow).
<?php
if
(!
class_exists("
gtk
"
)) {
if
(strtoupper(substr(PHP_OS,
0
,
3
) =
=
"
WIN
"
)) {
dl("
php_gtk
.
dll
"
);
}
else
{
dl("
php_gtk
.
so
"
);
}
}
function
destroy() {
Gtk:
:
main_quit();
}
$window
=
&
new
GtkWindow();
$window
-
>
connect("
destroy
"
,
"
destroy
"
);
$window
-
>
set_border_width(10
);
//
Créé
un
nouvel
objet
bouton
$button
=
&
new
GtkButton("
Dvp
!
"
);
//
Associe
la
function
hello_dvp()
au
bouton
créé
$button
-
>
connect("
clicked
"
,
"
hello_dvp
"
);
//
Ajoute
le
bouton
dans
la
fenêtre
$window
-
>
add($button
);
$window
-
>
show_all();
Gtk:
:
main();
?>
III-E. Ajout de la fonction hello_dvp()▲
Ajoutons la fonction hello_dvp() que nous allons détailler maintenant. Nous devons déclarer notre variable $window comme globale car nous faisons appel à notre GtkWindow. Nous faisons un print() d'un texte qui apparaîtra dans la fenêtre d'invite de commandes. Un echo() aurait aussi fait l'affaire. Enfin, nous faisons un appel de la fonction destroy() liée à notre $window qui nous permettra de fermer la fenêtre principale et de terminer l'application.
Le meilleur moyen de débogage dans PHP-GTK est le echo() ou le print().
Ajoutons la fonction hello_dvp() dans le code :
<?php
function
hello_dvp() {
global
$window
;
//
Texte
affiché
dans
la
fenêtre
de
commande
print
"
Dvp
,
c
'
est
vraiment
bien
\n
"
;
//
Appel
à
la
fonction
destroy
qui
ferme
l'application
$window
-
>
destroy();
}
?>
III-F. Ajout d'un widget "tooltips" GtkTooltips▲
Pour finir, nous allons ajouter un label au survol du bouton qui affichera un commentaire. Pour cela, on créé un objet de type Tooltips (GtkTooltips), on lui assigne un délai d'affichage avec la méthode set_delay() (le temps est en millisecondes). Avec la méthode set_tip(), nous connectons ce Tooltip au widget sur lequel nous voulons voir cette bulle d'information apparaitre ($button) et le texte qui s'y trouvera visible. Enfin, nous le rendons visible avec la méthode enable().
<?php
//
Création
du
"widget"
Tooltips
$tt
=
&
new
GtkTooltips();
//
Délai
d'affichage
du
"widget"
$tt
-
>
set_delay(200
);
//
Contenu
du
"widget"
$tt
-
>
set_tip($button
,
"
Donnez
votre
avis
sur
le
site
de
dvp
.
.
.
"
,
"
"
);
//
Affichage
du
"widget"
$tt
-
>
enable();
?>
III-G. La version finale de notre script▲
Ce listing est donc la version finale de notre script :
<?php
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Chargement
de
la
librairie
GTK
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
if
(!
extension_loaded("
gtk
"
)) {
dl( "
php_gtk
.
"
.
PHP_SHLIB_SUFFIX);
}
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Fonction
appelée
quand
la
fenêtre
est
détruite
,
permet
de
quitter
le
programme
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
function
destroy() {
Gtk:
:
main_quit();
}
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Fonction
appelée
quand
le
bouton
est
cliqué
.
Affiche
le
message
dans
la
fenêtre
de
*
*
commande
et
détruit
la
boite
de
dialogue
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
function
hello_dvp() {
global
$window
;
print
"
Dvp
,
c
'
est
vraiment
bien
\n
"
;
$window
-
>
destroy();
}
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Créé
une
fenêtre
et
associe
différentes
functions
de
gestion
de
la
fenêtre
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
$window
=
&
new
GtkWindow();
$window
-
>
connect("
destroy
"
,
"
destroy
"
);
$window
-
>
set_border_width(10
);
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Créé
un
"
widget
"
de
type
bouton
et
assigne
la
function
hello
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
//
Créé
un
nouveau
"widget"
bouton
$button
=
&
new
GtkButton("
Dvp
!
"
);
//
Associe
la
function
hello
au
bouton
créé
$button
-
>
connect("
clicked
"
,
"
hello_dvp
"
);
//
Ajoute
le
bouton
dans
la
fenêtre
("container"
$window)
$window
-
>
add($button
);
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Créé
un
"
widget
"
de
type
Tooltips
et
assigne
un
contenu
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
//
Création
du
"widget"
Tooltips
$tt
=
&
new
GtkTooltips();
//
Délai
d'affichage
du
"widget"
$tt
-
>
set_delay(200
);
//
Contenu
du
"widget"
$tt
-
>
set_tip($button
,
"
Donnez
votre
avis
sur
le
site
de
dvp
.
.
.
"
,
"
"
);
//
Affichage
du
"widget"
$tt
-
>
enable();
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Montre
la
fenêtre
et
tous
ses
composants
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
$window
-
>
show_all();
/**
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Exécute
la
boucle
principale
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
Gtk:
:
main();
?>
Comme nous l'avons dit précédemment, nous pouvons utiliser la version pseudo objet de PHP 4 dont le listing se trouve en annexe V-A.
Nous pouvons maintenant lancer l'application avec la ligne de commande suivante :

Nous pouvons également faire un fichier dans lequel nous mettons cette ligne de commande, le sauvegarder sur le bureau avec l'extension .bat (win32). En double cliquant sur ce fichier, l'application se lancera.
Lors de l'exécution de l'application, nous voyons s'ouvrir notre fenêtre contenant notre bouton :

Si nous mettons notre curseur sur le bouton, notre bulle d'information (Tooltip) apparaît.

Si nous cliquons sur notre bouton "Dvp", nous recupérons bien en sortie "Dvp, c'est vraiment bien" dans notre fenêtre d'invite de commandes grâce à print(). De même, notre GtkWindow se ferme grâce à la fonction destroy() se trouvant dans notre hello_dvp().
