Initiation à PHP-GTK 1

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ée 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 bibliothèque 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();
?>

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.

Nous allons écrire ces trois lignes dans notre script dvp.php à la suite du chargement de la bibliothèque GTK.

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 pallier 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
fonction destroy() {
    Gtk::main_quit();
}
?>

Rajoutons cette fonction entre le chargement de la bibliothèque 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 fonction 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 boite de dialogue, le script est bien arrêté et vous récupérez la main dans la fenêtre de commande.

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 :

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.

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 commande. 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 :

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 tutoriel) 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 à notre fenêtre principale 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"); }
}
 
fonction destroy() {
    Gtk::main_quit();
}
 
$window = &new GtkWindow();
$window->connect("destroy", "destroy");
$window->set_border_width(10);
 
//Crée un nouvel objet bouton
$button = &new GtkButton("Dvp!");
 
//Associe la fonction 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();
 
?>

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 commande. 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.

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();
}
?>

Pour finir, nous allons ajouter un label au survol du bouton qui affichera un commentaire. Pour cela, on crée 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 apparaître ($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();
?>

Ce listing est donc la version finale de notre script :

<?php
/*********************************
* Chargement de la bibliothèque 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 *
*********************************************************************************/
fonction 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 fonctions de gestion de la fenêtre *
*****************************************************************************/
$window = &new GtkWindow();
$window->connect("destroy", "destroy");
$window->set_border_width(10);
 
/***************************************************************
* Crée un "widget" de type bouton et assigne la fonction hello *
***************************************************************/
//Crée un nouveau "widget" bouton
$button = &new GtkButton("Dvp!");
//Associe la fonction 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 :

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 récupé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().