gtk_tut_fr.txt

gtk是linux一款强大的夸平台的图形化开发工具

  Didacticiel
  Ian Main, [e-mail]
  January 24, 1998.

  11..  IInnttrroodduuccttiioonn

  GTK (GIMP Toolkit) a d'abord delopppour re une boe outils pour GIMP
  (General Image Manipulation Program).  GTK est construit sur GDK (GIMP
  Drawing Kit) qui est, avant tout, une encapsulation des fonctions
  Xlib. On l'appelle GIMP toolkit car il fut cr pour delopper GIMP, mais
  il est dormais utilisdans plusieurs projets de logiciels libres. Les
  auteurs sont :

  +o  Peter Mattis   [e-mail]

  +o  Spencer Kimball [e-mail]

  +o  Josh MacDonald [e-mail]


  GTK est essentiellement une interface de programmation (API) orient
  objet.  Bien qu'il soit entiement rit en C, il est implanten utilisant
  la notion de classes et de fonctions de rappel (pointeurs de
  fonctions).

  Un troisie composant, appelglib, remplace certains appels standard et
  comporte quelques fonctions supplentaires pour ger les listes chas,
  etc. Les fonctions de remplacement sont utiliss pour accrore la
  portabilitde GTK car certaines de ces fonctions, comme g_strerror(),
  ne sont pas disponibles ou ne sont pas standard sur d'autres Unix.
  D'autres comportent des amiorations par rapport aux versions de la
  libc : g_malloc(), par exemple, facilite le duggage.


  Ce didacticiel tente de drire du mieux possible GTK, mais il n'est pas
  exhaustif. Il suppose une bonne connaissance du langage C, et de la
  fan de crr des programmes C. Il serait tr prieux au lecteur d'avoir d
  une expience de la programmation X, mais cela n'est pas nessaire. Si
  l'apprentissage de GTK marque vos duts dans l'approche des widgets,
  n'hitez pas faire des commentaires sur ce didacticiel et sur les
  probles qu'il vous a pos  Il y a aussi une API C++ pour GTK (GTK--),
  si vous prez utiliser ce langage, consultez plut la documentation qui
  la concerne. Une encapsulation en Objective C et des liaisons Guile
  sont alement disponibles, mais ne seront pas abords ici.

  J'apprierais beaucoup avoir un ho des probles que vous avez
  rencontrpour apprendre GTK partir de ce document. De plus, toute
  suggestion sur son amioration est la bienvenue.


  22..  BBiieenn dduutteerr

  La premie chose faire est, bien s, de ruper les sources de GTK et de
  les installer. Vous pouvez en obtenir la dernie version sur
  ftp.gimp.org dans le rertoire /pub/gtk. D'autres sources
  d'informations se trouvent sur http://www.gimp.org/gtk. GTK utilise
  _a_u_t_o_c_o_n_f de GNU pour se configurer. Lorsque vous l'aurez darr tapez
  _._/_c_o_n_f_i_g_u_r_e _-_-_h_e_l_p pour consulter la liste des options.

  Pour commencer notre introduction GTK, nous duterons avec le programme
  le plus simple qui soit. Celui-ci crra une fenre de 200x200 pixels et
  ne pourra se terminer qu'en le tuant partir du shell.




  #include <gtk/gtk.h>

  int main (int argc, char *argv[])
  {
      GtkWidget *window;

      gtk_init (&argc, &argv);

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_widget_show (window);

      gtk_main ();

      return 0;
  }




  Tous les programmes inclueront idemment le fichier gtk/gtk.h qui dlare
  les variables, fonctions, structures, etc. qui seront utiliss par
  votre application GTK.

  La ligne  :



       gtk_init (&argc, &argv);




  appelle la fonction _g_t_k___i_n_i_t_(_g_i_n_t _*_a_r_g_c_, _g_c_h_a_r _*_*_*_a_r_g_v_) qui sera appel
  dans toutes les applications GTK. Cette fonction configure certaines
  choses pour nous, comme l'aspect visuel et les couleurs par daut, puis
  appelle _g_d_k___i_n_i_t_(_g_i_n_t _*_a_r_g_c_, _g_c_h_a_r _*_*_*_a_r_g_v_).  Cette dernie initialise
  la bibliothue pour qu'elle puisse re utilis, configure les
  gestionnaires de signaux par daut et vifie les paramres pass notre
  application via la ligne de commande en recherchant l'un des
  suivants :


  +o  --display

  +o  --debug-level

  +o  --no-xshm

  +o  --sync

  +o  --show-events

  +o  --no-show-events

  Elle les supprime alors de la liste des paramres, en laissant tout ce
  qu'elle ne reconna pas pour que notre application l'analyse ou
  l'ignore. Ceci cr un ensemble de paramres standards accept par toutes
  les applications GTK.

  Les deux lignes de code suivantes crnt et affichent une fenre.



         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
         gtk_widget_show (window);

  Le paramre GTK_WINDOW_TOPLEVEL prise que l'on veut que la fenre cre
  suive l'aspect et le placement dinis par le gestionnaire de fenres.
  Plut que de crr une fenre de 0x0, une fenre sans fenre fille est de
  200x200 par daut : on peut ainsi la manipuler facilement.

  La fonction _g_t_k___w_i_d_g_e_t___s_h_o_w_(_) informe GTK que l'on a configurle widget
  et qu'il peut l'afficher.

  La ligne suivante lance la boucle principale de traitement de GTK.



       gtk_main ();




  _g_t_k___m_a_i_n_(_) est un autre appel que vous verrez dans toute application
  GTK. Lorsque le contre atteind ce point, GTK se met en attente d'
  ements X (click sur un bouton, ou appui d'une touche, par exemple), de
  timeouts ou d'entrs-sorties fichier. Dans notre exemple simple,
  cependant, les ements sont ignor.



  22..11..  BBoonnjjoouurr ttoouutt llee mmoonnddee eenn GGTTKK

  OK, rivons un programme avec un widget (bouton). C'est le classique
  Bonjour tout le monde la sauce GTK.





































  #include <gtk/gtk.h>

      /* fonction de rappel. Dans cet exemple, les paramres sont ignor...
       *  Les fonctions de rappel sont daills plus loin. */

  void hello (GtkWidget *widget, gpointer data)
  {
      g_print ("Bonjour tout le monde.\n");
  }

  gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
  {
      g_print ("le signal delete_event est survenu.\n");

      /* Si l'on renvoit TRUE dans le gestionnaire du signal "delete_event",
       * GTK ettra le signal "destroy". Retourner FALSE signifie que l'on
       * ne veut pas que la fenre soit druite.
       * Utilispour faire apparare des boes de dialogue du type
       * es-vous s de vouloir quitter ? */

      /* Remplacez FALSE par TRUE et la fenre principale sera druite par
       * un signal delete_event  */

      return (FALSE);
  }

  /* Autre fonction de rappel */

  void destroy (GtkWidget *widget, gpointer data)
  {
      gtk_main_quit ();
  }

  int main (int argc, char *argv[])
  {
      /* GtkWidget est le type pour dlarer les widgets. */

      GtkWidget *window;
      GtkWidget *button;

      /* Cette fonction est appel dans toutes les applications GTK.
       * Les paramres pass en ligne de commande sont analys et
       * retourn l'application. */

      gtk_init (&argc, &argv);

      /* Crtion d'une nouvelle fenre. */

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      /* Lorsque la fenre reit le signal "delete_event"
       * (envoypar le gestionnaire de fenres en utilisant l'option
       * close ou la barre de titre), on lui demande d'appeler la
       * fonction delete_event() dinie plus haut. La donn pass en
       * paramre la fonction de rappel est NULL et est ignordans le
       * rappel. */

      gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                          GTK_SIGNAL_FUNC (delete_event), NULL);

      /* Ici, on connecte l'enement "destroy" un gestionnaire de signal.
       * Cet ement arrive lorsqu'on appelle gtk_widget_destroy() sur la
       * fenre, ou si l'on retourne TRUE dans le rappel "delete_event". */

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
                          GTK_SIGNAL_FUNC (destroy), NULL);
      /* Configuration de la largeur du contour de la fenre. */

      gtk_container_border_width (GTK_CONTAINER (window), 10);

      /* Crtion d'un nouveau bouton portant le label
       * "Bonjour tout le monde". */

      button = gtk_button_new_with_label ("Bonjour tout le monde");

      /* Quand le bouton recevra le signal "clicked", il appellera la
       * fonction hello() dinie plus haut en lui passant NULL en paramre. */

      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (hello), NULL);

      /* Ceci provoquera la destruction de la fenre par appel de la
       * fonction gtk_widget_destroy(window) lors du signal "clicked".
       * Le signal de destruction pourrait venir de l ou du
       * gestionnaire de fenres. */

      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                                 GTK_SIGNAL_FUNC (gtk_widget_destroy),
                                 GTK_OBJECT (window));

      /* Insertion du bouton dans la fenre (container gtk). */

      gtk_container_add (GTK_CONTAINER (window), button);

      /* L'ape finale consiste afficher ce nouveau widget... */

      gtk_widget_show (button);

      /* ... et la fenre. */

      gtk_widget_show (window);

      /* Toutes les applications GTK doivent avoir un gtk_main().
       * Le doulement du programme se termine let attend qu'un
       * ement survienne (touche press ou ement souris). */

      gtk_main ();

      return 0;
  }





  22..22..  CCoommppiillaattiioonn ddee BBoonnjjoouurr ttoouutt llee mmoonnddee ..XXSS 55 22..22.. CCoommppiillaattiioonn ddee
  BBoonnjjoouurr ttoouutt llee mmoonnddee ..XXEE

  Supposons que vous avez sauvegardle code prent dans un fichier
  nomm_b_o_n_j_o_u_r_._c, pour le compiler tapez la commande suivante :



       gcc -Wall -g bonjour.c -o bonjour_monde -L/usr/X11R6/lib \
           -lgtk -lgdk -lglib -lXext -lX11 -lm




  Les bibliothues invoqus ci-dessus doivent toutes re dans vos chemins
  de recherche par daut, sinon, ajoutez -L<library directory> pour que
  _g_c_c recherche dans ces rertoires les bibliothues nessaires. Sur mon
  syste Debian GNU/Linux, par exemple, je dois ajouter -L/usr/X11R6/lib
  pour qu'il trouve les bibliothues X11 (NdT : et c'est pareil sur mon
  syste Red Hat Linux...).

  L'ordre des bibliothues est important. L'iteur de liens doit connare
  les fonctions d'une bibliothue dont il a besoin avant de les traiter.

  Si vous compilez en utilisant des bibliothues statiques, l'ordre dans
  lequel vous listez les bibliothues devient tr important. L'exemple
  donnci-dessus devrait fonctionner dans tous les cas.

  Les bibliothues que l'on utilise sont :

  +o  La bibliothue glib (-lglib), qui contient diverses fonctions. Seule
     _g___p_r_i_n_t_(_) est utilis dans cet exemple. GTK est construit au dessus
     de _g_l_i_b et vous aurez donc toujours besoin de celle-ci. Voir la
     section concernant ``glib'' pour plus de dails.


  +o  La bibliothue GDK (-lgdk), l'enveloppe de Xlib.

  +o  La bibliothue GTK (-lgtk), la bibliothue des widgets, construite au
     dessus de GDK.

  +o  La bibliothue Xlib (-lX11 utilis par GDK.

  +o  La bibliothue Xext (-lXext). Cette dernie contient le code pour les
     pixmaps en moire partag et les autres extensions X.

  +o  La bibliothue mathatique (-lm).  Elle est utilis pour diffentes
     raisons par GTK.


  22..33..  TThhrriiee ddeess ssiiggnnaauuxx eett ddeess rraappppeellss

  Avant de voir en dail le programme Bonjour tout le monde  nous
  parlerons d'abord des ements et des fonctions de rappel.  GTK est
  dirigpar les ements, ce qui signifie qu'il restera inactif dans
  _g_t_k___m_a_i_n jusqu'ce qu'un ement survienne et que le contre soit passla
  fonction appropri.

  Ce passage du contre est rlisen utilisant le concept de signal
  Lorsqu'un ement survient, comme l'appui sur un bouton, le signal
  approprisera is par le widget qui a press C'est de cette fan que GTK
  rlise la plupart de son travail. Pour qu'un bouton rlise une action,
  on configure un gestionnaire de signal pour capturer ces signaux et
  appeler la fonction aduate.  Ceci est fait en utilisant une fonction
  comme :



       gint gtk_signal_connect (GtkObject *object,
                                gchar *name,
                                GtkSignalFunc func,
                                gpointer func_data);




  Ole premier paramre est le widget qui ettra le signal, et le deuxie
  est le nom du signal que l'on souhaite intercepter. Le troisie paramre
  est la fonction que l'on veut appeler quand le signal est captur et le
  quatrie sont les donns que l'on souhaite passer cette fonction.

  La fonction spifi par le troisie paramre s'appelle une fonction de
  rappel et doit re de la forme :
       void callback_func(GtkWidget *widget, gpointer *callback_data);




  Ole premier paramre sera un pointeur vers le widget qui a is le
  signal, et le second un pointeur vers les donns passs par le dernier
  paramre de la fonction _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t_(_) drite plus haut.

  Un autre appel utilisdans l'exemple Bonjour tout le monde est :