gtk_tut_fr.txt

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

          /* Placement du sarateur dans la vbox. Ne pas oublier que tous les
           * widgets sont plac dans une vbox et qu'il seront plac
           * verticalement. */

          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          /* Crtion d'un nouveau label et affichage de celui-ci. */

          label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);

          /* Paramres : homogeneous = TRUE, spacing = 0,
           * expand = TRUE, fill = FALSE, padding = 0 */

          box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Paramres : homogeneous = TRUE, spacing = 0,
           * expand = TRUE, fill = TRUE, padding = 0 */

          box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Un autre sarateur */

          separator = gtk_hseparator_new ();

          /* Les 3 derniers paramres de gtk_box_pack_start sont :
           * expand = FALSE, fill = TRUE, padding = 5. */

          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          break;

      case 2:

          /* Crtion d'un label, box1 est une vbox identique
           * celle cre au dut de main() */

          label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);

          /* Paramres : homogeneous = FALSE, spacing = 10,
           * expand = TRUE, fill = FALSE, padding = 0 */

          box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Paramres : homogeneous = FALSE, spacing = 10,
           * expand = TRUE, fill = TRUE, padding = 0 */

          box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          separator = gtk_hseparator_new ();

          /* Les 3 derniers paramres de gtk_box_pack_start sont :
           * expand = FALSE, fill = TRUE, padding = 5. */

          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);

          /* Paramres : homogeneous = FALSE, spacing = 0,
           * expand = TRUE, fill = FALSE, padding = 10 */

          box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Paramres : homogeneous = FALSE, spacing = 0,
           * expand = TRUE, fill = TRUE, padding = 10 */

          box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          separator = gtk_hseparator_new ();

          /* Les 3 derniers paramres de gtk_box_pack_start sont :
           * expand = FALSE, fill = TRUE, padding = 5. */

          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);
          break;

      case 3:

          /* Ceci est une donstration de la possibilitd'utiliser
           * gtk_box_pack_end() pour aligner les widgets droite.
           * On cr d'abord une nouvelle boe comme d'habitude. */

          box2 = make_box (FALSE, 0, FALSE, FALSE, 0);

          /* On cr le label qui sera mis la fin. */

          label = gtk_label_new ("end");

          /* On le place en utilisant gtk_box_pack_end(), il est ainsi
           * mis droite de la hbox cre par l'appel make_box(). */

          gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);

          /* Affichage du label. */

          gtk_widget_show (label);

          /* Placement de box2 dans box1 (la vbox, vous vous rappelez ? :) */

          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Sarateur pour le bas. */

          separator = gtk_hseparator_new ();

          /* Configuration du sarateur en 400x5 pixels.
           * La hbox que l'on a cre aura donc 400 pixels de large,
           * et le label "end" sera sardes autres de la hbox.
           * Sinon, tous les widgets de la hbox seraient plac les plus
           * pr possible les uns des autres. */

          gtk_widget_set_usize (separator, 400, 5);

          /* Placement du sarateur dans la vbox (box1)
           * cre au debut de main(). */

          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);
      }

      /* Crtion d'une nouvelle hbox.. vous pouvez en utiliser autant que
       * que vous en avez besoin ! */

      quitbox = gtk_hbox_new (FALSE, 0);

      /* Notre bouton pour quitter. */

      button = gtk_button_new_with_label ("Quit");

      /* Configuration du signal pour druire la fenre. Ceci enverra le
       * signal "destroy" la fenre. Ce signal sera son tour captur     * par notre gestionnaire de signal dini plus haut. */

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

      /* Placement du bouton dans la quitbox
       * Les 3 derniers paramres de gtk_box_pack_start sont :
       * expand = TRUE, fill = FALSE, padding = 0. */

      gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);

      /* Placement de la quitbox dans la vbox (box1) */
      gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);

      /* Placement de la vbox (box1), qui contient maintenant tous nos
       * widgets, dans la fenre principale. */

      gtk_container_add (GTK_CONTAINER (window), box1);

      /* Affichage */

      gtk_widget_show (button);
      gtk_widget_show (quitbox);

      gtk_widget_show (box1);

      /* Affichage de la fenre en dernier */

      gtk_widget_show (window);

      /* Ne pas oublier notre fonction principale. */

      gtk_main ();

      /* Le contre revient ici lorsque gtk_main_quit() est appel,
       * jusqu'ce que  gtk_exit() soitutilis. */

      return 0;
  }






  44..44..  PPllaacceemmeenntt aavveecc lleess ttaabblleess

  udions une autre mhode de placement : les tables. Elles peuvent s'aver
  tr utiles dans certaines situations.

  En utilisant des tables, on cr une grille dans laquelle on peut placer
  les widgets. Ceux-ci peuvent occuper tous les endroits que l'on dire.

  La premie chose faire est, bien s, d'udier la fonction _g_t_k___t_a_b_l_e___n_e_w :



       GtkWidget* gtk_table_new (gint rows,
                                 gint columns,
                                 gint homogeneous);




  Le premier paramre est le nombre de lignes de la table et le deuxie,
  le nombre de colonnes.

  Le paramre _h_o_m_o_g_e_n_e_o_u_s s'occupe de la fan dont les cases de la table
  seront dimensionns. Si homogeneous vaut TRUE, les cases prennent la
  taille du plus grand widget de la table. S'il vaut FALSE, la taille
  des cases dend du widget le plus haut de la ligne et du plus large de
  cette colonne.

  Le nombre de lignes et colonnes va de 0 n, on est le nombre spifidans
  l'appel _g_t_k___t_a_b_l_e___n_e_w. Ainsi, avec _r_o_w_s = 2 et _c_o_l_u_m_n_s = 2, la table
  ressemblera ceci :


        0          1          2
       0+----------+----------+
        |          |          |
       1+----------+----------+
        |          |          |
       2+----------+----------+




  On notera que le syste de coordonns part du coin en haut gauche. Pour
  placer un widget dans une case, ou utilise la fonction suivante :



       void gtk_table_attach (GtkTable      *table,
                              GtkWidget     *child,
                              gint           left_attach,
                              gint           right_attach,
                              gint           top_attach,
                              gint           bottom_attach,
                              gint           xoptions,
                              gint           yoptions,
                              gint           xpadding,
                              gint           ypadding);





  Ole premier paramre (_t_a_b_l_e) est la table que l'on a cre et le second
  (_c_h_i_l_d) est le widget que l'on veut placer dans la table.

  Les paramres _l_e_f_t___a_t_t_a_c_h et _r_i_g_h_t___a_t_t_a_c_h spifient l'emplacement du
  widget et le nombre de cases utiliser. Par exemple, si on veut placer
  un bouton dans le coin infieur droit de la table drite plus haut et
  que l'on dire ne remplir QUE cette case, _l_e_f_t___a_t_t_a_c_h vaudra 1,
  _r_i_g_h_t___a_t_t_a_c_h vaudra 2; _t_o_p___a_t_t_a_c_h vaudra 1 et _b_o_t_t_o_m___a_t_t_a_c_h vaudra 2.

  Si on veut un widget occupant toute la ligne supieure de notre table,
  on utilisera les valeurs 0, 2, 0, 1.

  Les paramres _x_o_p_t_i_o_n_s et _y_o_p_t_i_o_n_s servent priser les options de
  placement et peuvent re combins par un OU logique pour permettre des
  options multiples.

  Ces options sont :

  +o  GTK_FILL - Si la case de la table est plus large que le widget, et
     que GTK_FILL est spifi le widget s'argira pour occuper toute la
     place disponible.

  +o  GTK_SHRINK - Si la table a moins de place qu'il ne lui en faut (g
     alement, cause d'un redimensionnement de la fenre par
     l'utilisateur), les widgets sont alors simplement pouss vers le bas
     de la fenre et disparaissent. Si GTK_SHRINK est spifi les widgets
     se ruiront en me temps que la table.

  +o  GTK_EXPAND - Cette option provoque l'extension de la table pour
     qu'elle utilise tout l'espace restant dans la fenre.

  Le paramres de _p_a_d_d_i_n_g jouent le me re que pour les boes, il crnt une
  zone libre, spifi en pixels, autour du widget.

  gtk_table_attach() a BEAUCOUP d'options.  Voici donc une
  fonction-raccourci :
       void gtk_table_attach_defaults (GtkTable   *table,
                                       GtkWidget  *widget,
                                       gint        left_attach,
                                       gint        right_attach,
                                       gint        top_attach,
                                       gint        bottom_attach);




  _x_o_p_t_i_o_n_s et _o_p_t_i_o_n_s valent par daut GTK_FILL | GTK_EXPAND, et _x_p_a_d_d_i_n_g
  et _y_p_a_d_d_i_n_g valent 0. Les autres paramres sont les mes que ceux de la
  fonction prente.

  Il existe aussi les fonctions _g_t_k___t_a_b_l_e___s_e_t___r_o_w___s_p_a_c_i_n_g_(_) et
  _g_t_k___t_a_b_l_e___s_e_t___c_o_l___s_p_a_c_i_n_g_(_). Elles permettent de placer des espaces
  apr une ligne ou une colonne.



       void gtk_table_set_row_spacing (GtkTable      *table,
                                       gint           row,
                                       gint           spacing);




  et


       void gtk_table_set_col_spacing  (GtkTable      *table,
                                        gint           column,
                                        gint           spacing);




  Pour les colonnes, l'espace est ajoutdroite de la colonne et pour les
  lignes, il est ajouten dessous.

  On peut aussi configurer un espacement pour toutes les lignes et/ou
  colonnes avec :



       void gtk_table_set_row_spacings (GtkTable *table,
                                        gint      spacing);




  Et,


       void gtk_table_set_col_spacings (GtkTable  *table,
                                        gint       spacing);




  Avec ces appels, la dernie ligne et la dernie colonne n'ont pas
  d'espace supplentaire.




  44..55..  EExxeemmppllee ddee ppllaacceemmeenntt aavveecc ttaabbllee

  Pour le moment, udiez l'exemple sur les tables (testgtk.c)
  distribuavec les sources de GTK.


  55..  VVuuee dd''eennsseemmbbllee ddeess wwiiddggeettss


  Les apes pour crr un widget en GTK sont :

  1. _g_t_k___*___n_e_w_(_) - une des fonctions disponibles pour crr un nouveau
     widget. Ces fonctions sont drites dans cette section.

  2. Connexion de tous les signaux que l'on souhaite utiliser avec les
     gestionnaires aduats.

  3. Configuration des attributs du widget.

  4. Placement du widget dans un container en utilisant un appel
     appropricomme _g_t_k___c_o_n_t_a_i_n_e_r___a_d_d_(_) ou _g_t_k___b_o_x___p_a_c_k___s_t_a_r_t_(_).

  5. Affichage du widget gre _g_t_k___w_i_d_g_e_t___s_h_o_w_(_).

  _g_t_k___w_i_d_g_e_t___s_h_o_w_(_) permet GTK de savoir que l'on a fini de configurer
  les attributs du widget et qu'il est pr re affich On peut aussi
  utiliser _g_t_k___w_i_d_g_e_t___h_i_d_e_(_) pour le faire disparare. L'ordre dans
  lequel on affiche les widgets n'est pas important, mais il est prable
  d'afficher la fenre en dernier pour qu'elle surgisse d'un seul coup
  plut que de voir les diffents widgets apparare l'ran au fur et mesure.
  Les fils d'un widget (une fenre est aussi un widget) ne seront pas
  affich tant que la fenre elle-me n'est pas affich par la fonction
  _g_t_k___w_i_d_g_e_t___s_h_o_w_(_).


  55..11..  CCoonnvveerrssiioonnss ddee ttyyppeess

  Vous remarquerez, au fur et mesure que vous progressez, que GTK
  utilise un syste de coercition de type. Celle-ci est toujours rlis en
  utilisant des macros qui vifient si l'objet donnpeut re converti et