LinuxFocus article number 303 http://linuxfocus.org

par Özcan Güngör <ozcangungor(at)netscape.net> L´auteur: J'utilise Linux depuis 1997. Liberté, flexibilité et opensource. Ce sont les propriétés que je préfère. Traduit en Français par: Frédéric Nourry <frederic.nourry(at)laposte.net>

Programmer des interfaces graphiques avec GTK, Partie II Résumé: Dans cet article, nous allons aborder les boîtes et les tables. Grâce à elles, nous serons capables de disposer les composants là où nous le voulons dans les fenêtres. Pour bien comprendre ces articles, vous devez posséder les notions suivantes de programmation en langage C: Variables Fonctions Pointeurs De plus, il est recommandé de lire l'article précédent. _________________ _________________ _________________

Organiser les composants grâce à des boîtes

"Packer" des composants signifie placer ces composants dans l'ordre souhaité dans une fenêtre. Une des façons de faire cela avec GTK consiste à utiliser des boîtes. L'objectif principal des boîtes est d'organiser les composants de façon à les placer verticalement ou horizontalement. Il y a deux types de boîtes: les horizontales et les verticales. Voyons en détails ces deux types :

Boîtes horizontales

Dans ce type de boîte, les composants sont disposés horizontalement. La fonction suivante est utilisée pour créer une boîte horizontale.

gtk_widget *box;
box=gtk_hbox_new(gboolean homogenous, gint spacing);

où le paramètre homogeneous est utilisé pour indiquer si les composants sont placés de façon homogènes ou non: si oui (TRUE), alors les composants remplissent la totalité de la boîte à égale distance les uns des autres, et si non (FALSE), ils sont placés côte à côte. spacing est utilisé pour définir l'espace minimal entre les composants.

Boîtes verticales

Avec ce type de boîte, les composants sont disposés verticalement. La fonction suivante est utilisée pour créer une boîte verticale.

gtk_widget *box;
box=gtk_vbox_new(gboolean homogenous, gint spacing);

Les paramètres de cette fonction ont la même signification que pour 'gtk_hbox_new'.

Propriétés communes des boîtes

Ajouter des composants peut être fait de deux façons: la première est la suivante :

gtk_box_pack_start(GtkBox *box,GtkWidget *child,
                 gboolean expand, gboolean fill, guint padding);

La fonction complémentaire de gtk_box_pack_start est gtk_box_pack_end

gtk_box_pack_end(GtkBox *box,GtkWidget *child,
                gboolean expand, gboolean fill, guint padding);

Pour ajouter une boîte dans une fenêtre, la fonction suivante est utilisée:

gtk_container_add (GtkContainer *container,GtkWidget *component);

gtk_container_add(GTK_CONTAINER(window),box);

gtk_box_set_homogeneous (GtkBox *box, gboolean homogenous);
gtk_box_set_spacing(GtkBox *box, gint spacing);

gtk_box_set_child_packing(GkBox *box,GtkWidget *shild,
       gboolean expand, gboolean  fill, guint padding,
       GtkPackType packingtype);

Pour mieux comprendre ceci, essayez le code suivant : kutular.c.

Les tables

Les tables, comme en HTML, nous aident à placer des composants dans des cellules. Pour cela, il suffit de créer une table possédant assez de lignes et de colonnes. Ensuite, nous pouvons placer un composant dans une cellule ou un groupe de cellules (seulement pour celles situées côte à côte). Pour créer une table, on utilise la fonction suivante:

GtkWidget *table;
GtkWidget* gtk_table_new(guint  row, guint column, gboolean homogenous);

La fonction suivante est utilisée pour ajouter un composant à une table:

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

xoptions et yoptions peuvent avoir trois valeurs différentes : GTK_FILL, GTK_EXPAND, GTK_SHRINK. Avec GTK_FILL le composant occupe une cellule (ou un groupe de cellules) entièrement. Avec GTK_EXPAND le composant est situé au centre de la cellule (ou d'un groupe de cellules) et GTK_SHRINK permet de l'adapter (le rétrécir) aux dimensions de la cellule (ou du groupe de cellules). xoptions permet de ne jouer que sur l'axe x des cellules et yoptions que sur l'axe y.

xpadding ajoute de l'espace à gauche et à droite d'un composant suivant l'axe x, alors que ypadding le fait suivant l'axe y.

Voici un exemple de code:

#include <gtk/gtk.h>

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

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

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

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

    table = gtk_table_new (2, 2, TRUE);

    gtk_container_add (GTK_CONTAINER (window), table);

    button = gtk_button_new_with_label ("button 1");
    gtk_table_attach(GTK_TABLE(table), button, 0, 1, 0, 2,GTK_SHRINK,
                     GTK_SHRINK,0,0);
    gtk_widget_show (button);

    button = gtk_button_new_with_label ("button 2");
    gtk_table_attach (GTK_TABLE(table), button, 1, 2, 1, 2,
                      GTK_SHRINK,GTK_SHRINK,0,0);
    gtk_widget_show (button);

    button = gtk_button_new_with_label ("button 3");
    gtk_table_attach (GTK_TABLE(table), button, 1, 2, 0, 1,
                      GTK_SHRINK,GTK_SHRINK,0,0);
    gtk_widget_show (button);

    gtk_widget_show (table);
    gtk_widget_show (window);

    gtk_main ();

    return 0;
}

Comme gtk_table_attach possède de nombreux paramètres, une nouvelle fonction plus courte a été créée; gtk_table_attach_defaults. Cette fonction fait la même chose avec moins de paramètres.

void gtk_table_attach_defaults (GtkTable *table,GtkWidget *child,
                guint left_attach, guint right_attach, guint top_attach,
                guint bottom_attach);

La fonction suivante est utilisée pour changer le nombre de lignes et de colonnes d'une table existante :

void gtk_table_resize(GtkTable *table, guint rows, guint columns);

Avec les fonctions suivantes, vous pouvez changer l'espacement dans une ligne ou dans une colonne:

void gtk_table_set_row_spacing (GtkTable *table, guint row,
                              	guint spacing);
void gtk_table_set_col_spacing (GtkTable *table, guint column,
				guint spacing);

Les fonctions suivantes permettent de changer l'espacement pour toutes les lignes ou les colonnes :

void gtk_table_set_row_spacings (GtkTable *table, guint spacing);
void gtk_table_set_col_spacings (GtkTable *table, guint spacing);

La fonction suivante change la valeur d'homogénéité d'une table existante :

void gtk_table_set_homogeneous (GtkTable *table, gboolean homogenous);

En résumé

Dans cet article, nous avons vu différentes manières d'organiser des composants, puis les fonctions de propriétés des boîtes et des tables. J'ai toujours plaisir à recevoir des questions, des commentaires ou des idées de lecteurs. Envoyez-moi simplement un courrier électronique....

2005-01-14, generated by lfparser_pdf version 2.51