1 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> |
---|
2 | <HTML> |
---|
3 | <HEAD> |
---|
4 | <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.9"> |
---|
5 | <TITLE>Didacticiel: Widgets containers</TITLE> |
---|
6 | <LINK HREF="gtk_tut_fr-9.html" REL=next> |
---|
7 | <LINK HREF="gtk_tut_fr-7.html" REL=previous> |
---|
8 | <LINK HREF="gtk_tut_fr.html#toc8" REL=contents> |
---|
9 | </HEAD> |
---|
10 | <BODY BGCOLOR="#FFFFFF"> |
---|
11 | <A HREF="gtk_tut_fr-9.html">Page suivante</A> |
---|
12 | <A HREF="gtk_tut_fr-7.html">Page précédente</A> |
---|
13 | <A HREF="gtk_tut_fr.html#toc8">Table des matières</A> |
---|
14 | <HR NOSHADE> |
---|
15 | <H2><A NAME="s8">8. Widgets containers</A></H2> |
---|
16 | |
---|
17 | <H2><A NAME="ss8.1">8.1 Bloc-notes</A> |
---|
18 | </H2> |
---|
19 | |
---|
20 | <P>Le widget bloc-notes est un ensemble de « pages » qui se |
---|
21 | chevauchent. Chaque page contient des informations |
---|
22 | différentes. Récemment, ce widget est devenu plus commun dans la |
---|
23 | programmation des interfaces graphiques et c'est un bon moyen de |
---|
24 | montrer des blocs d'information similaires qui justifient une |
---|
25 | séparation de leur affichage. |
---|
26 | <P>Le premier appel de fonction que l'on doit connaître est, vous |
---|
27 | l'aviez deviné, celui qui crée un widget bloc-notes. |
---|
28 | <P> |
---|
29 | <BLOCKQUOTE><CODE> |
---|
30 | <PRE> |
---|
31 | GtkWidget* gtk_notebook_new (void); |
---|
32 | </PRE> |
---|
33 | </CODE></BLOCKQUOTE> |
---|
34 | <P>Lorsque le bloc-notes a été créé, il y a 12 fonctions permettant de |
---|
35 | travailler sur les blocs-notes. Étudions-les séparément. |
---|
36 | <P>La première permet de positionner les indicateurs de pages. Ceux-ci |
---|
37 | (désignés par le mot « tab » (signet)), peuvent se trouver en haut, en |
---|
38 | bas, à gauche ou à droite des pages. |
---|
39 | <P> |
---|
40 | <BLOCKQUOTE><CODE> |
---|
41 | <PRE> |
---|
42 | void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos); |
---|
43 | </PRE> |
---|
44 | </CODE></BLOCKQUOTE> |
---|
45 | <P><EM>GtkPositionType</EM> peut prendre les valeurs suivantes qu'il n'est |
---|
46 | pas nécessaire d'expliquer : |
---|
47 | <UL> |
---|
48 | <LI> GTK_POS_LEFT</LI> |
---|
49 | <LI> GTK_POS_RIGHT</LI> |
---|
50 | <LI> GTK_POS_TOP</LI> |
---|
51 | <LI> GTK_POS_BOTTOM</LI> |
---|
52 | </UL> |
---|
53 | <P>GTK_POS_TOP est la valeur par défaut. |
---|
54 | <P>La fonction suivante permet d'ajouter des pages à un bloc-notes. Il y |
---|
55 | a trois façons d'ajouter des pages. Regardons les deux premières qui |
---|
56 | sont très semblables. |
---|
57 | <P> |
---|
58 | <BLOCKQUOTE><CODE> |
---|
59 | <PRE> |
---|
60 | void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, |
---|
61 | GtkWidget *tab_label); |
---|
62 | |
---|
63 | void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, |
---|
64 | GtkWidget *tab_label); |
---|
65 | </PRE> |
---|
66 | </CODE></BLOCKQUOTE> |
---|
67 | <P>Ces fonctions ajoutent des pages au bloc-notes<EM>*notebook</EM> en les |
---|
68 | insérant à la fin (<EM>append</EM>) ou au début |
---|
69 | (<EM>prepend</EM>). <EM>*child</EM> est le widget qui est placé dans la page |
---|
70 | du bloc-notes, et <EM>*tab_label</EM> est le label de la page qui est |
---|
71 | ajoutée. |
---|
72 | <P>La troisième fonction ajoutant une page à un bloc-notes conserve |
---|
73 | toutes les propriétés des deux précédentes, mais elle nous permet en |
---|
74 | plus de spécifier la position où l'on désire insérer cette page. |
---|
75 | <P> |
---|
76 | <BLOCKQUOTE><CODE> |
---|
77 | <PRE> |
---|
78 | void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, |
---|
79 | GtkWidget *tab_label, gint position); |
---|
80 | </PRE> |
---|
81 | </CODE></BLOCKQUOTE> |
---|
82 | <P>Les paramètres sont les mêmes que <EM>_append_</EM> et <EM>_prepend_</EM> sauf |
---|
83 | qu'il y en a un de plus : <EM>position</EM>. Celui-ci sert à |
---|
84 | spécifier l'endroit où cette page sera insérée. |
---|
85 | <P>Maintenant que nous savons insérer une page, voyons comment en supprimer une. |
---|
86 | <P> |
---|
87 | <BLOCKQUOTE><CODE> |
---|
88 | <PRE> |
---|
89 | void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num); |
---|
90 | </PRE> |
---|
91 | </CODE></BLOCKQUOTE> |
---|
92 | <P>Cette fonction ôte la page spécifiée par <EM>page_num</EM> du widget |
---|
93 | <EM>*notebook</EM>. |
---|
94 | <P>Pour connaître la page courante d'un bloc-notes, on dispose de la |
---|
95 | fonction : |
---|
96 | <P> |
---|
97 | <BLOCKQUOTE><CODE> |
---|
98 | <PRE> |
---|
99 | gint gtk_notebook_current_page (GtkNotebook *notebook); |
---|
100 | </PRE> |
---|
101 | </CODE></BLOCKQUOTE> |
---|
102 | <P>Les deux fonctions suivantes permettent de passer à la page suivante |
---|
103 | ou précédente d'un bloc-notes. Il suffit de faire l'appel de la |
---|
104 | fonction adéquate avec le widget sur lequel on veut |
---|
105 | opérer. Remarque : lorsqu'on est sur la dernière page du |
---|
106 | bloc-notes et que l'on appelle <EM>gtk_notebook_next_page</EM>, on revient |
---|
107 | à la première page. De même, si l'on est sur la première page et que |
---|
108 | l'onappelle <EM>gtk_notebook_prev_page</EM>, on se retrouve sur sa |
---|
109 | dernière page. |
---|
110 | <P> |
---|
111 | <BLOCKQUOTE><CODE> |
---|
112 | <PRE> |
---|
113 | void gtk_notebook_next_page (GtkNoteBook *notebook); |
---|
114 | void gtk_notebook_prev_page (GtkNoteBook *notebook); |
---|
115 | </PRE> |
---|
116 | </CODE></BLOCKQUOTE> |
---|
117 | <P>La fonction qui suit permet de choisir la page « active ». Si vous |
---|
118 | voulez ouvrir le bloc-notes à la page 5, par exemple, vous utiliserez |
---|
119 | cette fonction. Sans elle, le bloc-notes s'ouvre sur sa première page |
---|
120 | par défaut. |
---|
121 | <P> |
---|
122 | <BLOCKQUOTE><CODE> |
---|
123 | <PRE> |
---|
124 | void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num); |
---|
125 | </PRE> |
---|
126 | </CODE></BLOCKQUOTE> |
---|
127 | <P>Les deux fonctions suivantes ajoutent ou ôtent les indicateurs de page |
---|
128 | et le contour du bloc-notes, respectivement. |
---|
129 | <P> |
---|
130 | <BLOCKQUOTE><CODE> |
---|
131 | <PRE> |
---|
132 | void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs); |
---|
133 | void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border); |
---|
134 | </PRE> |
---|
135 | </CODE></BLOCKQUOTE> |
---|
136 | <P><EM>show_tabs</EM> et <EM>show_border</EM> peuvent valoir TRUE ou FALSE (0 ou 1). |
---|
137 | <P>Voyons maintenant un exemple, il est tiré du code de <EM>testgtk.c</EM> de |
---|
138 | la distribution GTK et montre l'utilisation des 13 fonctions. Ce petit |
---|
139 | programme crée une fenêtre contenant un bloc-notes et six boutons. Le |
---|
140 | bloc-notes contient 11 pages, ajoutées par trois moyens |
---|
141 | différents : à la fin, au milieu et au début. Les boutons |
---|
142 | permettent de faire tourner les indicateurs de page, ajouter/ôter les |
---|
143 | indicateurs et le contour, ôter une page, passer à la page suivante et |
---|
144 | précédente, et sortir du programme. |
---|
145 | <P> |
---|
146 | <P> |
---|
147 | <BLOCKQUOTE><CODE> |
---|
148 | <PRE> |
---|
149 | |
---|
150 | #include <gtk/gtk.h> |
---|
151 | |
---|
152 | /* Rotation des indicateurs de page */ |
---|
153 | |
---|
154 | void rotate_book (GtkButton *button, GtkNotebook *notebook) |
---|
155 | { |
---|
156 | gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4); |
---|
157 | } |
---|
158 | |
---|
159 | /* Ajout/Suppression des indicateurs de pages et des contours */ |
---|
160 | |
---|
161 | void tabsborder_book (GtkButton *button, GtkNotebook *notebook) |
---|
162 | { |
---|
163 | gint tval = FALSE; |
---|
164 | gint bval = FALSE; |
---|
165 | if (notebook->show_tabs == 0) |
---|
166 | tval = TRUE; |
---|
167 | if (notebook->show_border == 0) |
---|
168 | bval = TRUE; |
---|
169 | |
---|
170 | gtk_notebook_set_show_tabs (notebook, tval); |
---|
171 | gtk_notebook_set_show_border (notebook, bval); |
---|
172 | } |
---|
173 | |
---|
174 | /* Suppression d'une page */ |
---|
175 | |
---|
176 | void remove_book (GtkButton *button, GtkNotebook *notebook) |
---|
177 | { |
---|
178 | gint page; |
---|
179 | |
---|
180 | page = gtk_notebook_current_page(notebook); |
---|
181 | gtk_notebook_remove_page (notebook, page); |
---|
182 | |
---|
183 | /* Il faut rafraîchir le widget -- |
---|
184 | * ce qui force le widget à se redessiner. */ |
---|
185 | |
---|
186 | gtk_widget_draw(GTK_WIDGET(notebook), NULL); |
---|
187 | } |
---|
188 | |
---|
189 | void delete (GtkWidget *widget, GdkEvent *event, gpointer *data) |
---|
190 | { |
---|
191 | gtk_main_quit (); |
---|
192 | } |
---|
193 | |
---|
194 | int main (int argc, char *argv[]) |
---|
195 | { |
---|
196 | GtkWidget *window; |
---|
197 | GtkWidget *button; |
---|
198 | GtkWidget *table; |
---|
199 | GtkWidget *notebook; |
---|
200 | GtkWidget *frame; |
---|
201 | GtkWidget *label; |
---|
202 | GtkWidget *checkbutton; |
---|
203 | int i; |
---|
204 | char bufferf[32]; |
---|
205 | char bufferl[32]; |
---|
206 | |
---|
207 | gtk_init (&argc, &argv); |
---|
208 | |
---|
209 | window = gtk_window_new (GTK_WINDOW_TOPLEVEL); |
---|
210 | |
---|
211 | gtk_signal_connect (GTK_OBJECT (window), "delete_event", |
---|
212 | GTK_SIGNAL_FUNC (delete), NULL); |
---|
213 | |
---|
214 | gtk_container_border_width (GTK_CONTAINER (window), 10); |
---|
215 | |
---|
216 | table = gtk_table_new(2,6,TRUE); |
---|
217 | gtk_container_add (GTK_CONTAINER (window), table); |
---|
218 | |
---|
219 | /* Création d'un bloc-notes, placement des indicateurs de page. */ |
---|
220 | |
---|
221 | notebook = gtk_notebook_new (); |
---|
222 | gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); |
---|
223 | gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1); |
---|
224 | gtk_widget_show(notebook); |
---|
225 | |
---|
226 | /* Ajoute un groupe de pages à la fin du bloc-notes. */ |
---|
227 | |
---|
228 | for (i=0; i < 5; i++) { |
---|
229 | sprintf(bufferf, "Append Frame %d", i+1); |
---|
230 | sprintf(bufferl, "Page %d", i+1); |
---|
231 | |
---|
232 | frame = gtk_frame_new (bufferf); |
---|
233 | gtk_container_border_width (GTK_CONTAINER (frame), 10); |
---|
234 | gtk_widget_set_usize (frame, 100, 75); |
---|
235 | gtk_widget_show (frame); |
---|
236 | |
---|
237 | label = gtk_label_new (bufferf); |
---|
238 | gtk_container_add (GTK_CONTAINER (frame), label); |
---|
239 | gtk_widget_show (label); |
---|
240 | |
---|
241 | label = gtk_label_new (bufferl); |
---|
242 | gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label); |
---|
243 | } |
---|
244 | |
---|
245 | |
---|
246 | /* Ajoute une page à un endroit précis. */ |
---|
247 | |
---|
248 | checkbutton = gtk_check_button_new_with_label ("Cochez moi !"); |
---|
249 | gtk_widget_set_usize(checkbutton, 100, 75); |
---|
250 | gtk_widget_show (checkbutton); |
---|
251 | |
---|
252 | label = gtk_label_new ("Emplacement de la nouvelle page"); |
---|
253 | gtk_container_add (GTK_CONTAINER (checkbutton), label); |
---|
254 | gtk_widget_show (label); |
---|
255 | label = gtk_label_new ("Ajout de page"); |
---|
256 | gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2); |
---|
257 | |
---|
258 | /* Ajout de pages au début du bloc-notes */ |
---|
259 | |
---|
260 | for (i=0; i < 5; i++) { |
---|
261 | sprintf(bufferf, "Prepend Frame %d", i+1); |
---|
262 | sprintf(bufferl, "Page %d", i+1); |
---|
263 | |
---|
264 | frame = gtk_frame_new (bufferf); |
---|
265 | gtk_container_border_width (GTK_CONTAINER (frame), 10); |
---|
266 | gtk_widget_set_usize (frame, 100, 75); |
---|
267 | gtk_widget_show (frame); |
---|
268 | |
---|
269 | label = gtk_label_new (bufferf); |
---|
270 | gtk_container_add (GTK_CONTAINER (frame), label); |
---|
271 | gtk_widget_show (label); |
---|
272 | |
---|
273 | label = gtk_label_new (bufferl); |
---|
274 | gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label); |
---|
275 | } |
---|
276 | |
---|
277 | /* Configuration de la page de départ (page 4) */ |
---|
278 | |
---|
279 | gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3); |
---|
280 | |
---|
281 | |
---|
282 | /* Création des boutons */ |
---|
283 | |
---|
284 | button = gtk_button_new_with_label ("Fermer"); |
---|
285 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
286 | GTK_SIGNAL_FUNC (delete), NULL); |
---|
287 | gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2); |
---|
288 | gtk_widget_show(button); |
---|
289 | |
---|
290 | button = gtk_button_new_with_label ("Page suivante"); |
---|
291 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
292 | (GtkSignalFunc) gtk_notebook_next_page, |
---|
293 | GTK_OBJECT (notebook)); |
---|
294 | gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2); |
---|
295 | gtk_widget_show(button); |
---|
296 | |
---|
297 | button = gtk_button_new_with_label ("Page précédente"); |
---|
298 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
299 | (GtkSignalFunc) gtk_notebook_prev_page, |
---|
300 | GTK_OBJECT (notebook)); |
---|
301 | gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2); |
---|
302 | gtk_widget_show(button); |
---|
303 | |
---|
304 | button = gtk_button_new_with_label ("Position des indicateurs"); |
---|
305 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
306 | (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook)); |
---|
307 | gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2); |
---|
308 | gtk_widget_show(button); |
---|
309 | |
---|
310 | button = gtk_button_new_with_label ("Indicateurs/Contours oui/non"); |
---|
311 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
312 | (GtkSignalFunc) tabsborder_book, |
---|
313 | GTK_OBJECT (notebook)); |
---|
314 | gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2); |
---|
315 | gtk_widget_show(button); |
---|
316 | |
---|
317 | button = gtk_button_new_with_label ("Oter page"); |
---|
318 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
319 | (GtkSignalFunc) remove_book, |
---|
320 | GTK_OBJECT(notebook)); |
---|
321 | gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2); |
---|
322 | gtk_widget_show(button); |
---|
323 | |
---|
324 | gtk_widget_show(table); |
---|
325 | gtk_widget_show(window); |
---|
326 | |
---|
327 | gtk_main (); |
---|
328 | |
---|
329 | return 0; |
---|
330 | } |
---|
331 | </PRE> |
---|
332 | </CODE></BLOCKQUOTE> |
---|
333 | <P>En espérant que ceci vous aide à créer des blocs-notes pour vos |
---|
334 | applications GTK. |
---|
335 | <P> |
---|
336 | <P> |
---|
337 | <H2><A NAME="ss8.2">8.2 Fenêtres avec barres de défilement</A> |
---|
338 | </H2> |
---|
339 | |
---|
340 | <P>Les fenêtres avec barres de défilement servent à créer des zones |
---|
341 | défilantes à l'intérieur d'une vraie fenêtre. On peut insérer |
---|
342 | n'importe quel widget dans ces fenêtres, ils seront accessibles quelle |
---|
343 | que soit leur taille en utilisant les barres de défilement. |
---|
344 | <P> |
---|
345 | <P>La fonction suivante sert à créer une fenêtre avec barre de |
---|
346 | défilement : |
---|
347 | <P> |
---|
348 | <BLOCKQUOTE><CODE> |
---|
349 | <PRE> |
---|
350 | GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment, |
---|
351 | GtkAdjustment *vadjustment); |
---|
352 | </PRE> |
---|
353 | </CODE></BLOCKQUOTE> |
---|
354 | <P>Le premier paramètre est l'ajustement horizontal, et le second |
---|
355 | l'ajustement vertical. Ils sont presque toujours positionnés à NULL. |
---|
356 | <P> |
---|
357 | <BLOCKQUOTE><CODE> |
---|
358 | <PRE> |
---|
359 | void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window, |
---|
360 | GtkPolicyType hscrollbar_policy, |
---|
361 | GtkPolicyType vscrollbar_policy); |
---|
362 | </PRE> |
---|
363 | </CODE></BLOCKQUOTE> |
---|
364 | <P>Cela permet de configurer le fonctionnement des barres de |
---|
365 | défilement. Le premier paramètre est la fenêtre à défilement que l'on |
---|
366 | veut modifier, le second configure le fonctionnement de la barre |
---|
367 | horizontale et le troisième celui de la barre verticale. |
---|
368 | <P>Ce fonctionnement peut être GTK_POLICY AUTOMATIC ou GTK_POLICY_ALWAYS. |
---|
369 | GTK_POLICY_AUTOMATIC décidera automatiquement de votre besoin en |
---|
370 | barres de défilement, alors que GTK_POLICY_ALWAYS mettra toujours |
---|
371 | celles-ci. |
---|
372 | <P>Voici un exemple simple qui place 100 boutons commutateurs dans une |
---|
373 | fenêtre à défilement. Je n'ai commenté que les parties qui sont |
---|
374 | nouvelles pour vous. |
---|
375 | <P> |
---|
376 | <BLOCKQUOTE><CODE> |
---|
377 | <PRE> |
---|
378 | #include <gtk/gtk.h> |
---|
379 | |
---|
380 | void destroy(GtkWidget *widget, gpointer *data) |
---|
381 | { |
---|
382 | gtk_main_quit(); |
---|
383 | } |
---|
384 | |
---|
385 | int main (int argc, char *argv[]) |
---|
386 | { |
---|
387 | static GtkWidget *window; |
---|
388 | GtkWidget *scrolled_window; |
---|
389 | GtkWidget *table; |
---|
390 | GtkWidget *button; |
---|
391 | char buffer[32]; |
---|
392 | int i, j; |
---|
393 | |
---|
394 | gtk_init (&argc, &argv); |
---|
395 | |
---|
396 | /* Création d'une boîte de dialogue pour y placer la fenêtre à défilement. |
---|
397 | * Une boîte de dialogue est une fenêtre comme les autres sauf qu'elle contient |
---|
398 | * une vbox et un séparateur horizontal. Ce n'est qu'un raccourci pour créer des |
---|
399 | * zones de dialogue. */ |
---|
400 | |
---|
401 | window = gtk_dialog_new (); |
---|
402 | gtk_signal_connect (GTK_OBJECT (window), "destroy", |
---|
403 | (GtkSignalFunc) destroy, NULL); |
---|
404 | gtk_window_set_title (GTK_WINDOW (window), "dialog"); |
---|
405 | gtk_container_border_width (GTK_CONTAINER (window), 0); |
---|
406 | |
---|
407 | /* Création d'une fenêtre à défilement. */ |
---|
408 | |
---|
409 | scrolled_window = gtk_scrolled_window_new (NULL, NULL); |
---|
410 | |
---|
411 | gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10); |
---|
412 | |
---|
413 | /* La gestion des barres est soit GTK_POLICY AUTOMATIC, soit GTK_POLICY_ALWAYS. |
---|
414 | * GTK_POLICY_AUTOMATIC décide automatiquement s'il faut ou non des barres, |
---|
415 | * GTK_POLICY_ALWAYS met toujours des barres |
---|
416 | * Le premier paramètre correspond à la barre horizontale, |
---|
417 | * le second à la barre verticale. */ |
---|
418 | |
---|
419 | gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), |
---|
420 | GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); |
---|
421 | |
---|
422 | /* Création d'une boîte de dialogue */ |
---|
423 | |
---|
424 | gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window, |
---|
425 | TRUE, TRUE, 0); |
---|
426 | gtk_widget_show (scrolled_window); |
---|
427 | |
---|
428 | /* Création d'une table de 10x10 cases. */ |
---|
429 | |
---|
430 | table = gtk_table_new (10, 10, FALSE); |
---|
431 | |
---|
432 | /* Configure l'espace des lignes et des colonnes de 10 pixels */ |
---|
433 | |
---|
434 | gtk_table_set_row_spacings (GTK_TABLE (table), 10); |
---|
435 | gtk_table_set_col_spacings (GTK_TABLE (table), 10); |
---|
436 | |
---|
437 | /* Place la table fans la fenêtre à défilement */ |
---|
438 | |
---|
439 | gtk_container_add (GTK_CONTAINER (scrolled_window), table); |
---|
440 | gtk_widget_show (table); |
---|
441 | |
---|
442 | /* Crée une grille de boutons commutateurs dans la table */ |
---|
443 | |
---|
444 | for (i = 0; i < 10; i++) |
---|
445 | for (j = 0; j < 10; j++) { |
---|
446 | sprintf (buffer, "bouton (%d,%d)\n", i, j); |
---|
447 | button = gtk_toggle_button_new_with_label (buffer); |
---|
448 | gtk_table_attach_defaults (GTK_TABLE (table), button, |
---|
449 | i, i+1, j, j+1); |
---|
450 | gtk_widget_show (button); |
---|
451 | } |
---|
452 | |
---|
453 | /* Ajoute un bouton « Fermer » en bas de la boîte de dialogue */ |
---|
454 | |
---|
455 | button = gtk_button_new_with_label ("Fermer"); |
---|
456 | gtk_signal_connect_object (GTK_OBJECT (button), "clicked", |
---|
457 | (GtkSignalFunc) gtk_widget_destroy, |
---|
458 | GTK_OBJECT (window)); |
---|
459 | |
---|
460 | /* On met ce bouton en « bouton par défaut ». */ |
---|
461 | |
---|
462 | GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); |
---|
463 | gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); |
---|
464 | |
---|
465 | /* Récupère le bouton par défaut. Le fait de presser la touche « Entrée » |
---|
466 | * activera le bouton. */ |
---|
467 | |
---|
468 | gtk_widget_grab_default (button); |
---|
469 | gtk_widget_show (button); |
---|
470 | |
---|
471 | gtk_widget_show (window); |
---|
472 | |
---|
473 | gtk_main(); |
---|
474 | |
---|
475 | return(0); |
---|
476 | } |
---|
477 | </PRE> |
---|
478 | </CODE></BLOCKQUOTE> |
---|
479 | <P>Essayez de changer la taille de la fenêtre et faites attention aux |
---|
480 | réactions des barres de défilement. On peut aussi utiliser la fonction |
---|
481 | <EM>gtk_widget_set_usize()</EM> pour configurer la taille par défaut de la |
---|
482 | fenêtre et des autres widgets. |
---|
483 | <P> |
---|
484 | <P> |
---|
485 | <HR NOSHADE> |
---|
486 | <A HREF="gtk_tut_fr-9.html">Page suivante</A> |
---|
487 | <A HREF="gtk_tut_fr-7.html">Page précédente</A> |
---|
488 | <A HREF="gtk_tut_fr.html#toc8">Table des matières</A> |
---|
489 | </BODY> |
---|
490 | </HTML> |
---|