gtk_tut_fr.txt

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

       gint gtk_signal_connect_object (GtkObject *object,
                                       gchar  *name,
                                       GtkSignalFunc func,
                                       GtkObject *slot_object);




  _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t___o_b_j_e_c_t_(_) est la me chose que _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t_(_)
  sauf que la fonction de rappel utilise un seul paramre : un pointeur
  vers un objet GTK. Lorsqu'on utilise cette fonction pour connecter des
  signaux, le rappel doit re de cette forme :



       void callback_func (GtkObject *object);




  Ol'objet est d'ordinaire un widget. En gal, on ne configure pas de
  rappels pour _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t___o_b_j_e_c_t. D'habitude, ceux-ci sont
  utilis pour appeler une fonction GTK acceptant un simple widget ou
  objet comme paramre, comme dans notre exemple.

  La raison pour laquelle il y a deux fonctions pour connecter les
  signaux est simplement de permettre aux fonctions de rappel d'avoir un
  nombre diffent de paramres. De nombreuses fonctions de la bibliothue
  GTK n'acceptent qu'un simple pointeur vers un _G_t_k_W_i_d_g_e_t comme paramre
  et vous pouvez donc  utiliser _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t___o_b_j_e_c_t_(_) pour celles-
  ci, tandis que pour vos fonctions vous pouvez avoir besoin d'avoir de
  fournir plus de donns aux fonctions de rappel.


  22..44..  BBoonnjjoouurr ttoouutt llee mmoonnddee ppaass ppaass

  Maintenant que nous connaissons la thrie, clarifions un peu en
  progressant travers le programme Bonjour tout le monde

  Voici la fonction de rappel appel lorsque le bouton est clicked  Dans
  notre exemple, on ignore le widget et les donns mais il n'est pas
  difficile de faire quelque chose avec. Le prochain exemple utilisera
  le paramre des donns pour nous dire quel bouton a press



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



  Cette fonction de rappel est un peu spiale. L'ement "delete_event"
  survient lorsque le gestionnaire de fenres l'envoie l'application. On
  doit choisir ce qu'il faut faire de cesements. On peut les ignorer,
  leur donner une ronse, ou simplement quitter l'application.

  La valeur que l'on retourne dans cette fonction de rappel permet GTK
  de savoir ce qu'il a faire. En retournant FALSE, on l'informe que l'on
  ne veut pas que le signal "destroy" soit is, afin de laisser notre
  application tourner. En retournant TRUE, on lui demande d'ettre
  "destroy" qui appellera son tour notre gestionnaire du signal
  "destroy".



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

           return (FALSE);
       }





  Voici une autre fonction de rappel qui ne fait que quitter
  l'application en appelant _g_t_k___m_a_i_n___q_u_i_t_(_).  Il n'y a pas grand chose
  de plus dire car elle est plut triviale :



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




  Je suppose que vous connaissez la fonction _m_a_i_n_(_)... oui, comme les
  autres programmes C, toutes les applications GTK en ont une.




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




  La partie qui suit dlare deux pointeurs sur des structures de type
  _G_t_k_W_i_d_g_e_t.  Ceux-ci sont utilis plus loin pour crr une fenre et un
  bouton.



           GtkWidget *window;
           GtkWidget *button;




  Et revoici notre _g_t_k___i_n_i_t.  Comme premment, il initialise le toolkit
  et analyse les paramres de la ligne de commande. Il supprime chaque
  paramre reconnu de la liste et modifie _a_r_g_c et _a_r_g_v pour faire comme
  si ces paramres n'avaient jamais exist laissant notre application
  analyser les paramres restants.



           gtk_init (&argc, &argv);




  Crtion d'une nouvelle fenre. C'est plut classique. La moire est allou
  pour une structure _G_t_k_W_i_d_g_e_t et _w_i_n_d_o_w pointe donc sur celle-ci. Cela
  configure une nouvelle fenre, mais celle-ci ne sera pas affich tant
  que l'on n'a pas appel_g_t_k___w_i_d_g_e_t___s_h_o_w_(_w_i_n_d_o_w_) vers la fin de notre
  programme.



           window = gtk_window_new (GTK_WINDOW_TOPLEVEL);




  Voici maintenant un exemple de connexion d'un gestionnaire de signal
  un objet : la fenre. Le signal "destroy" est captur Il est is
  lorsqu'on utilise le gestionnaire de fenres pour tuer la fenre (et que
  l'on retourne TRUE dans le gestionnaire "delete_event"), ou lorsqu'on
  utilise l'appel _g_t_k___w_i_d_g_e_t___d_e_s_t_r_o_y_(_) en lui passant le widget _w_i_n_d_o_w
  comme objet druire.  Ici, on appelle juste la fonction _d_e_s_t_r_o_y_(_) dinie
  ci-dessus avec le paramre NULL, ce qui quitte GTK pour nous.

  GTK_OBJECT et GTK_SIGNAL_FUNC sont des macros qui rlisent les
  conversions et les vifications de types pour nous. Elles rendent aussi
  le code plus lisible.



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




  La fonction suivante sert configurer un attribut d'un objet container.
  Elle configure simplement la fenre pour qu'elle ait une zone vide
  autour d'elle de 10 pixels de large oaucun widget ne pourra se
  trouver. Il existe d'autres fonctions similaires que nous verrons dans
  la section sur la ``Configuration des attributs des widgets''

  nouveau, GTK_CONTAINER est une macro rlisant la conversion de type.


           gtk_container_border_width (GTK_CONTAINER (window), 10);




  Cet appel cr un nouveau bouton. Il alloue l'espace moire pour une
  nouvelle structure GtkWidget, l'initialise et fait pointer _b_u_t_t_o_n vers
  elle. Ce bouton portera le label Bonjour tout le monde lorsqu'il sera
  affich



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

  Maintenant, prenons ce bouton et faisons lui faire quelque chose
  d'utile. On lui attache un gestionnaire de signal pour que, lorsqu'il
  ettra le signal "clicked", notre fonction _h_e_l_l_o_(_) soit appel. On
  ignore les paramres et on ne passe donc que la valeur NULL la fonction
  de rappel _h_e_l_l_o_(_).  idemment, le signal "clicked" est is lorsqu'on
  clique sur le bouton avec la souris.



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




  On utilisera aussi ce bouton pour quitter notre programme, ce qui
  permettra d'illustrer la fan dont le signal "destroy" peut venir soit
  du gestionnaire de fenres, soit de notre programme. Quand le bouton
  est "clicked" comme cela est drit plus haut, il appelle d'abord la
  fonction de rappel _h_e_l_l_o_(_) puis celle-ci dans l'ordre dans lequel
  elles sont configurs. On peut avoir autant de fonctions de rappel que
  l'on dire, elles seront exuts selon leur ordre de connexion. Puisque
  la fonction _g_t_k___w_i_d_g_e_t___d_e_s_t_r_o_y_(_) n'accepte que _G_t_k_W_i_d_g_e_t _*_w_i_d_g_e_t comme
  paramre, on utilise ici la fonction _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t___o_b_j_e_c_t_(_) la
  place de _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t_(_).



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




  Voici un appel de placement, qui sera expliquen dail plus tard, mais
  qui est plut facile comprendre. Il indique simplement GTK que le
  bouton doit re placdans la fenre oil s'affichera.



        gtk_container_add (GTK_CONTAINER (window), button);




  Maintenant, nous avons tout configurcomme on le souhaitait : les
  gestionnaires de signaux sont en place et le bouton est mis dans la
  fenre oil doit se trouver. On demande alors GTK de montrer les widgets
  l'ran. Le widget _w_i_n_d_o_w est affichen dernier afin que la fenre entie
  surgisse d'un coup plut que voir d'abord la fenre s'afficher puis
  ensuite le bouton apparare l'intieur. Il faut dire qu'avec des
  exemples simples comme celui-ci, vous ne ferez pas la diffence.



           gtk_widget_show(button);

           gtk_widget_show (window);




  Bien s, on appelle _g_t_k___m_a_i_n_(_) qui attendra les ements venant du
  serveur X et demandera aux widgets d'ettre les signaux lorsque ces
  ements surviendront.
           gtk_main ();




  Enfin, le _r_e_t_u_r_n final. Il est exutlorsque _g_t_k___q_u_i_t_(_) est appel


           return 0;




  Lorsque l'on clique sur un bouton GTK, le widget et un signal
  "clicked". Afin de pouvoir utiliser cette information, notre programme
  configure un gestionnaire pour capturer ce signal. Ce gestionnaire
  appelle la fonction de notre choix. Dans notre exemple, lorsque le
  bouton que l'on a cr est "clicked", la fonction _h_e_l_l_o_(_) est appel avec
  le paramre NULL, puis le gestionnaire suivant de ce signal est son
  tour appel Il appelle la fonction _g_t_k___w_i_d_g_e_t___d_e_s_t_r_o_y_(_) en lui passant
  le widget _w_i_n_d_o_w comme paramre, ce qui provoque la destruction de
  celui-ci. Ceci force la fenre envoyer un signal "destroy", qui est
  capturson tour et appelle notre fonction de rappel _d_e_s_t_r_o_y_(_) qui ferme
  simplement GTK.

  Une autre fan de procer consiste utiliser le gestionnaire de fenres
  pour druire la fenre. Cela provoquera l'ission du signal
  "delete_event" qui sera pris en charge par notre gestionnaire
  _d_e_l_e_t_e___e_v_e_n_t_(_). S'il retourne FALSE, la fenre restera telle quelle et
  rien ne se passera. Retourner TRUE forcera GTK ettre le signal
  "destroy" qui, bien s, appelera la fonction de rappel _d_e_s_t_r_o_y_(_)
  provoquant la sortie du GTK.


  On remarquera que ces signaux ne sont pas les mes que les signaux
  systes Unix et ne sont pas implant en utilisant ceux-ci, bien que la
  terminologie employ soit presque identique.



  33..  CCoonnttiinnuuoonnss


  33..11..  TTyyppeess ddee ddoonnnnss

  Vous avez probablement notcertaines choses qui nessitent des
  explications dans les exemples prents. les _g_i_n_t, _g_c_h_a_r, etc. que vous
  avez pu voir sont des redinitions de _i_n_t et _c_h_a_r, respectivement. Leur
  raison d're est de s'affranchir des dendances ennuyeuses concernant la
  taille des types de donns simples lorsqu'on rlise des calculs. Un bon
  exemple est _g_i_n_t_3_2 qui dignera un entier codsur 32 bits pour toutes
  les plateformes, que ce soit une station Alpha 64 bits ou un PC i386
  32 bits. Les redinitions de type sont tr simples et intuitives. Elles
  sont toutes drites dans le fichier _g_l_i_b_/_g_l_i_b_._h (qui est inclus par
  _g_t_k_._h).

  On notera aussi la possibilitd'utiliser un _G_t_k_W_i_d_g_e_t lorsque la
  fonction attend un _G_t_k_O_b_j_e_c_t. GTK posse une architecture orient objet,
  et un widget est un objet.


  33..22..  CCoommpplleennttss ssuurr lleess ggeessttiioonnnnaaiirreess ddee ssiiggnnaauuxx

  Regardons nouveau la dlaration de _g_t_k___s_i_g_n_a_l___c_o_n_n_e_c_t.


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




  Vous avez remarquque le valeur de retour est de type _g_i_n_t ? Il s'agit
  d'un marqueur qui identifie votre fonction de rappel. Comme on le
  disait plus haut, on peut avoir autant de fonctions de rappel que l'on
  a besoin, par signal et par objet, et chacune sera exut son tour, dans
  l'ordre dans lequel elle a attach. Ce marqueur vous permet d'er ce
  rappel de la liste en faisant &;:



             void gtk_signal_disconnect (GtkObject *object, gint id);





  Ainsi, en passant le widget dont on veut supprimer le gestionnaire et
  le marqueur ou identificateur retournpar l'une des fonctions
  _s_i_g_n_a_l___c_o_n_n_e_c_t, on peut donnecter un gestionnaire de signal.

  Une autre fonction permettant de supprimer tous les gestionnaires de
  signaux pour un objet est :



             gtk_signal_handlers_destroy (GtkObject *object);




  Cet appel n'a pas trop besoin d'explications. Il e simplement tous les
  gestionnaires de signaux de l'objet passen paramre.



  33..33..  UUnn BBoonnjjoouurr ttoouutt llee mmoonnddee aammiioorr..XXSS 1122 33..33.. UUnn BBoonnjjoouurr ttoouutt llee
  mmoonnddee aammiioorr..XXEE

  udions une version lement amior avec de meilleurs exemples de
  fonctions de rappel. Ceci permettra aussi d'introduire le sujet
  suivant : le placement des wigdets.




















  #include <gtk/gtk.h>

  /* Notre nouveau rappel amior La donn pass cette fonction est
   * imprim sur stdout. */

  void rappel (GtkWidget *widget, gpointer *data)
  {
      g_print ("Re-Bonjour - %s a pressen", (char *) data);
  }

  /* Un autre rappel */

  void delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)
  {
      gtk_main_quit ();
  }

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