source: trunk/third/gtk/docs/html/gtk_tut_it-8.html @ 14482

Revision 14482, 26.8 KB checked in by ghudson, 25 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r14481, which included commits to RCS files with non-trunk default branches.
Line 
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>GTK Tutorial: Widget Contenitore</TITLE>
6 <LINK HREF="gtk_tut_it-9.html" REL=next>
7 <LINK HREF="gtk_tut_it-7.html" REL=previous>
8 <LINK HREF="gtk_tut_it.html#toc8" REL=contents>
9</HEAD>
10<BODY BGCOLOR="#FFFFFF">
11<A HREF="gtk_tut_it-9.html">Avanti</A>
12<A HREF="gtk_tut_it-7.html">Indietro</A>
13<A HREF="gtk_tut_it.html#toc8">Indice</A>
14<HR NOSHADE>
15<H2><A NAME="s8">8. Widget Contenitore</A></H2>
16
17<H2><A NAME="ss8.1">8.1 Il widget Blocco Note (Notebook)</A>
18</H2>
19
20<P>Il widget Blocco note &egrave; un insieme di pagine sovrapposte l'una con l'altra,
21ognuna contente cose diverse. Questo widget &egrave; diventato molto comune nella
22programmazione delle interfacce utente ed &egrave; un buon metodo per mostrare informazioni
23tra loro correlate ma che debbano essere mostrate separatamente.
24<P>
25<P>La prima funzione da invocare che si deve conoscere, come si pu&ograve; intuire, &egrave; usata
26per creare un nuovo Blocco Note.
27<P>
28<BLOCKQUOTE><CODE>
29<PRE>
30GtkWidget* gtk_notebook_new (void);
31</PRE>
32</CODE></BLOCKQUOTE>
33<P>Una volta che il notebook &egrave; sato creato, ci sono 12 funzioni che possono
34operare sul widget notebook. Guardiamole individualmente.
35<P>La prima che vediamo riguarda come posizionare l'indicatore di pagina.
36Questi inidicatori di pagina o ``linguette'' (come possono anche essere chiamati)
37possono essere posizionati in quattro posti: alto, basso, sinistra.destra.
38<P>
39<BLOCKQUOTE><CODE>
40<PRE>
41void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);
42</PRE>
43</CODE></BLOCKQUOTE>
44<P>GtkPositionType sar&agrave; uno dei seguenti valori (molto autoesplicativi)
45<UL>
46<LI> GTK_POS_LEFT</LI>
47<LI> GTK_POS_RIGHT</LI>
48<LI> GTK_POS_TOP</LI>
49<LI> GTK_POS_BOTTOM</LI>
50</UL>
51<P>GTK_POS_TOP e' il valore predefinito.
52<P>Ora vediamo come aggiugere le pagine al Blocco Note. Ci sono 3 modi per farlo. Diamo
53un'occhiata ai primi due insieme, viste che sono molto simili.
54<P>
55<BLOCKQUOTE><CODE>
56<PRE>
57void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
58
59void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
60</PRE>
61</CODE></BLOCKQUOTE>
62<P>Queste funzioni aggiungono pagine al notebook inserendole rispettivamente alla fine
63(append) o all'inizio (prepend). *child &egrave; il widget che &egrave; posto nella pagina del
64notebook e *tab_label e la intestazione della pagina stessa.
65<P>L'ultima funzione per aggiungere una pagina al notebook contiene tutte le propriet&agrave;
66delle precedenti due, ma permette di specificare dove posizionare la pagina che
67si vuole inserire.
68<P>
69<BLOCKQUOTE><CODE>
70<PRE>
71void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, gint position);
72</PRE>
73</CODE></BLOCKQUOTE>
74<P>I parametri sono gli stessi di _append_ e _prepend_ tranne che per il parametro in
75pi&ugrave;: ``position''.
76Questo parametro viene usato per specificare in che posizione ineserire la pagina.
77<P>Ora che conosciamo come aggiungere le pagine, vediamo come poter toglierne una.
78<P>
79<BLOCKQUOTE><CODE>
80<PRE>
81void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);
82</PRE>
83</CODE></BLOCKQUOTE>
84<P>Questa funzione prende il numero della pagina specificata dal campo page_num e
85rimuove la pagina corrispondente dal Blocco Note.
86<P>Per trovare qual'&egrave; la pagina corrente nel notebook bisogna usare la funzione:
87<P>
88<BLOCKQUOTE><CODE>
89<PRE>
90gint gtk_notebook_current_page (GtkNotebook *notebook);
91</PRE>
92</CODE></BLOCKQUOTE>
93<P>Le prossime due funzioni sono semplicemente delle chiamate che muovono la pagina del
94notebook avanti o indietro. Semplicemente forniscono le chiamate alle rispettive
95funzioni del widget notebook su si pu&ograve; operare. NB: quando un notebook &egrave;
96correntemente sull'ultima pagina e viene invocata la funzione gtk_notebook_next_page,
97il notebook ritorner&agrave; automaticamente alla prima pagina. Logicamente succede anche
98il contrario quando invochi gtk_notebook_prev_page e ti trovi sulla prima pagina.
99<P>
100<BLOCKQUOTE><CODE>
101<PRE>
102void gtk_notebook_next_page (GtkNoteBook *notebook);
103void gtk_notebook_prev_page (GtkNoteBook *notebook);
104</PRE>
105</CODE></BLOCKQUOTE>
106<P>La prossima funzione stabilisce la pagina ``attiva''. Se si vuole che la pagina
107principale del notebook sia per esempio la 5 (ad esempio) si pu&ograve; usare questa
108funzione.
109Se non si usa questa funzione la pagina principale sar&agrave; la 1.
110<P>
111<BLOCKQUOTE><CODE>
112<PRE>
113void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);
114</PRE>
115</CODE></BLOCKQUOTE>
116<P>Le prossime due funzioni aggiungono o rimuovono, rispettivamente, le intestazioni e
117i bordi delle pagine.
118<P>
119<BLOCKQUOTE><CODE>
120<PRE>
121void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
122void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);
123</PRE>
124</CODE></BLOCKQUOTE>
125<P>show_tabs e show_border posso avere come valore TRUE o FALSE (0 or 1).
126<P>Diamo ora una occhiata ad un esempio. Si tratta di una espansione del codice preso
127dal file testgtk.c che &egrave; compreso in tutte le distribuzioni, e mostra
128tutte le 13 funzioni. Questo piccolo programma crea una finestra con un notebook
129e 6 bottoni. Il notebook contiene 11 pagine, aggiunte nei 3 modi differenti (alla
130fine, all'inizio o in qualsiasi posizione). I bottoni permettono di girare le
131intestazioni, aggiungere/rimuovere le intestazioni e i bordi, rimuovere una
132pagina, cambiare la pagina avanti e indietro e uscire dal programma.
133<P>
134<BLOCKQUOTE><CODE>
135<PRE>
136/* notebook.c */
137
138#include &lt;gtk/gtk.h>
139
140/* Queta funzione ruota le posizione delle linguette delle pagine */
141void rotate_book (GtkButton *button, GtkNotebook *notebook)
142{
143    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
144}
145
146/* Aggiunge e rimuove le linguette e i bordi */
147void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
148{
149    gint tval = FALSE;
150    gint bval = FALSE;
151    if (notebook->show_tabs == 0)
152            tval = TRUE;
153    if (notebook->show_border == 0)
154            bval = TRUE;
155   
156    gtk_notebook_set_show_tabs (notebook, tval);
157    gtk_notebook_set_show_border (notebook, bval);
158}
159
160/* Rimuove una pagina */
161void remove_book (GtkButton *button, GtkNotebook *notebook)
162{
163    gint page;
164   
165    page = gtk_notebook_current_page(notebook);
166    gtk_notebook_remove_page (notebook, page);
167    /* E' necessario fare un refresh del widget --
168       Questo forza il widget a ridisegnarsi. */
169    gtk_widget_draw(GTK_WIDGET(notebook), NULL);
170}
171
172void delete (GtkWidget *widget, gpointer data)
173{
174    gtk_main_quit ();
175}
176
177int main (int argc, char *argv[])
178{
179    GtkWidget *window;
180    GtkWidget *button;
181    GtkWidget *table;
182    GtkWidget *notebook;
183    GtkWidget *frame;
184    GtkWidget *label;
185    GtkWidget *checkbutton;
186    int i;
187    char bufferf[32];
188    char bufferl[32];
189   
190    gtk_init (&amp;argc, &amp;argv);
191   
192    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
193   
194    gtk_signal_connect (GTK_OBJECT (window), "destroy",
195                        GTK_SIGNAL_FUNC (destroy), NULL);
196   
197    gtk_container_border_width (GTK_CONTAINER (window), 10);
198   
199    table = gtk_table_new(2,6,TRUE);
200    gtk_container_add (GTK_CONTAINER (window), table);
201   
202    /* Crea un nuovo notebook, e tabilisce la posizione delle linguette */
203    notebook = gtk_notebook_new ();
204    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
205    gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
206    gtk_widget_show(notebook);
207   
208    /* appende una parte delle pagine */
209    for (i=0; i &lt; 5; i++) {
210        sprintf(bufferf, "Append Frame %d", i+1);
211        sprintf(bufferl, "Page %d", i+1);
212       
213        frame = gtk_frame_new (bufferf);
214        gtk_container_border_width (GTK_CONTAINER (frame), 10);
215        gtk_widget_set_usize (frame, 100, 75);
216        gtk_widget_show (frame);
217       
218        label = gtk_label_new (bufferf);
219        gtk_container_add (GTK_CONTAINER (frame), label);
220        gtk_widget_show (label);
221       
222        label = gtk_label_new (bufferl);
223        gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
224    }
225   
226   
227    /* Ora aggiungiamo una pagina in una certa posizione */
228    checkbutton = gtk_check_button_new_with_label ("Check me please!");
229    gtk_widget_set_usize(checkbutton, 100, 75);
230    gtk_widget_show (checkbutton);
231   
232    label = gtk_label_new ("Add spot");
233    gtk_container_add (GTK_CONTAINER (checkbutton), label);
234    gtk_widget_show (label);
235    label = gtk_label_new ("Add page");
236    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
237   
238    /* Ora finalmente aggiungiamo le pagine all'inizio */
239    for (i=0; i &lt; 5; i++) {
240        sprintf(bufferf, "Prepend Frame %d", i+1);
241        sprintf(bufferl, "PPage %d", i+1);
242       
243        frame = gtk_frame_new (bufferf);
244        gtk_container_border_width (GTK_CONTAINER (frame), 10);
245        gtk_widget_set_usize (frame, 100, 75);
246        gtk_widget_show (frame);
247       
248        label = gtk_label_new (bufferf);
249        gtk_container_add (GTK_CONTAINER (frame), label);
250        gtk_widget_show (label);
251       
252        label = gtk_label_new (bufferl);
253        gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
254    }
255   
256    /* Stabilisce quale sar&agrave; la prima pagina che sar&agrave; visualizzata. */
257    gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
258   
259   
260    /* Crea un set di bottoni */
261    button = gtk_button_new_with_label ("close");
262    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
263                               GTK_SIGNAL_FUNC (delete), NULL);
264    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
265    gtk_widget_show(button);
266   
267    button = gtk_button_new_with_label ("next page");
268    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
269                               (GtkSignalFunc) gtk_notebook_next_page,
270                               GTK_OBJECT (notebook));
271    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
272    gtk_widget_show(button);
273   
274    button = gtk_button_new_with_label ("prev page");
275    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
276                               (GtkSignalFunc) gtk_notebook_prev_page,
277                               GTK_OBJECT (notebook));
278    gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
279    gtk_widget_show(button);
280   
281    button = gtk_button_new_with_label ("tab position");
282    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
283                               (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
284    gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
285    gtk_widget_show(button);
286   
287    button = gtk_button_new_with_label ("tabs/border on/off");
288    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
289                               (GtkSignalFunc) tabsborder_book,
290                               GTK_OBJECT (notebook));
291    gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
292    gtk_widget_show(button);
293   
294    button = gtk_button_new_with_label ("remove page");
295    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
296                               (GtkSignalFunc) remove_book,
297                               GTK_OBJECT(notebook));
298    gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
299    gtk_widget_show(button);
300   
301    gtk_widget_show(table);
302    gtk_widget_show(window);
303   
304    gtk_main ();
305   
306    return 0;
307}
308</PRE>
309</CODE></BLOCKQUOTE>
310<P>E speriamo che questo vi aiuti a creare i Blocco Note per le vostre applicazioni GTK!
311<P>
312<H2><A NAME="ss8.2">8.2 Finestre Scorribili (Scrolled Windows)</A>
313</H2>
314
315<P>Le Finestre Scorribili sono usate per creare areee scorribili in una vera finestra.
316Si pu&ograve; inserire qualsiasi tipo di widget in questo tipo di finestra, e possono poi
317essere accessibili a prescindere dalle dimensioni usando le barre di scorrimento.
318<P>La funzione seguente &egrave; usata per creare una nuova scrolled window.
319<P>
320<BLOCKQUOTE><CODE>
321<PRE>
322GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
323                                    GtkAdjustment *vadjustment);
324</PRE>
325</CODE></BLOCKQUOTE>
326<P>Il primo argomento &egrave; l'aggiustamento (di quanto scendere ogni
327volta) orizzontale e il secondo &egrave; quello verticale.  A questi si assegna
328quasi sempre il valore NULL.
329<P>
330<P>
331<BLOCKQUOTE><CODE>
332<PRE>
333void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
334                                     GtkPolicyType      hscrollbar_policy,
335                     GtkPolicyType      vscrollbar_policy);
336</PRE>
337</CODE></BLOCKQUOTE>
338<P>Questa funzione stabilisce la politica da usare nella barra di scorrimento. Il primo
339argomento &egrave; la finestra scorribile interessata. Il secondo stabilisce la politica
340per la barra di scorrimento orizzontale e il terzo &egrave; quello per la politca verticale.
341<P>La politica pu&ograve; essere GTK_POLICY AUTOMATIC o GTK_POLICY_ALWAYS.
342GTK_POLICY_AUTOMATIC decide automaticamente se la barra di scorrimento deve essere
343visualizzata, mentre con GTK_POLICY_ALWAYS la barra verr&agrave; sempre mostrata.
344<P>
345<BLOCKQUOTE><CODE>
346<PRE>
347/* scrolledwin.c */
348
349#include &lt;gtk/gtk.h>
350
351void destroy(GtkWidget *widget, gpointer data)
352{
353    gtk_main_quit();
354}
355
356int main (int argc, char *argv[])
357{
358    static GtkWidget *window;
359    GtkWidget *scrolled_window;
360    GtkWidget *table;
361    GtkWidget *button;
362    char buffer[32];
363    int i, j;
364   
365    gtk_init (&amp;argc, &amp;argv);
366   
367    /* Crea una nuove finestra di dialogo in cui la scrolled window sar&agrave;
368        inserita. Una finestra di dialogo &egrave; semplicemente come una
369        finestra normale, ma ha anche un vbox e un separatore orizzontale
370        gi&agrave; inseriti per difetto. E'un modo semplice per
371        creare finestre di dialogo. */
372    window = gtk_dialog_new ();
373    gtk_signal_connect (GTK_OBJECT (window), "destroy",
374                        (GtkSignalFunc) destroy, NULL);
375    gtk_window_set_title (GTK_WINDOW (window), "dialog");
376    gtk_container_border_width (GTK_CONTAINER (window), 0);
377    gtk_widget_set_usize(window, 300, 300);   
378
379    /* crea una nuova finestra scorribile. */
380    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
381   
382    gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
383   
384    /* la politica &egrave; GTK_POLICY AUTOMATIC per lo scorrimento orizzontale e
385        GTK_POLICY_ALWAYS per quello verticale.  */
386    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
387                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
388   
389    /* La finestra di dialogo &egrave; creata con un vbox gi&agrave; inserito.*/
390    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
391                        TRUE, TRUE, 0);
392    gtk_widget_show (scrolled_window);
393   
394    /* crea una tablella di10 x 10. */
395    table = gtk_table_new (10, 10, FALSE);
396   
397    /* setta lo spazio tra ogni cella di 10 pixel sia verticale sia orizzontale*/
398    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
399    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
400   
401    /* inserisce la tabella nella finestra scorribile*/
402    gtk_container_add (GTK_CONTAINER (scrolled_window), table);
403    gtk_widget_show (table);
404   
405    /* questo semplicemente crea una griglia di bottoni nella tabelle per
406       dimostrare il comportamento della finestra scorribile */
407    for (i = 0; i &lt; 10; i++)
408       for (j = 0; j &lt; 10; j++) {
409          sprintf (buffer, "button (%d,%d)\n", i, j);
410          button = gtk_toggle_button_new_with_label (buffer);
411          gtk_table_attach_defaults (GTK_TABLE (table), button,
412                                     i, i+1, j, j+1);
413          gtk_widget_show (button);
414       }
415   
416    /* Aggiunge un bottone "close" alla fine della finestra */
417    button = gtk_button_new_with_label ("close");
418    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
419                               (GtkSignalFunc) gtk_widget_destroy,
420                               GTK_OBJECT (window));
421   
422    /* questo fa s&igrave; che questo bottone sia quello predefinito */
423   
424    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
425    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
426   
427    /* Questo ottiene il bottone predefinito. Premendo semplicemente l'"enter" il
428        bottone si avvier&agrave; */
429    gtk_widget_grab_default (button);
430    gtk_widget_show (button);
431   
432    gtk_widget_show (window);
433   
434    gtk_main();
435   
436    return(0);
437}
438</PRE>
439</CODE></BLOCKQUOTE>
440<P>Prova a giocare con il ridemensionamento della finestra. Noterete la reazione della
441barra di scorrimento. Potete anche usare la funzione gtk_widget_set_usize() per
442assegnare la dimensione predefinita della finestra o di un widget.
443<P>  
444<H2><A NAME="ss8.3">8.3 Il widget "Finestra Frazionata" (Paned Window)</A>
445</H2>
446
447<P>Le finestre frazionate tornano utili quando si vuole dividere un'area in due parti,
448<P>le cui dimensioni relative siano sotto il controllo dell'utente. Fra le due zone
449<P>viene disgnato un separatore dotato di una maniglia che l'utente pu&ograve;
450<P>trascinare per cambiare la proporzione fra le aree. La divisione pu&ograve;
451<P>essere sia di tipo orizzontale (HPaned) che verticale (VPaned).
452<P>
453<P>Per creare una finestra frazionata, si chiama una delle seguenti:
454<P>
455<BLOCKQUOTE><CODE>
456<PRE>
457GtkWidget* gtk_hpaned_new (void)
458GtkWidget* gtk_vpaned_new (void)
459</PRE>
460</CODE></BLOCKQUOTE>
461<P>
462<P>Dopo aver creato il widget della finestra frazionata, si devono aggiungere dei
463<P>widget figli alle due parti. Per farlo, si usano le funzioni:
464<P>
465<BLOCKQUOTE><CODE>
466<PRE>
467void gtk_paned_add1 (GtkPaned *paned, GtkWidget *child)
468void gtk_paned_add2 (GtkPaned *paned, GtkWidget *child)
469</PRE>
470</CODE></BLOCKQUOTE>
471<P><CODE>gtk_paned_add1()</CODE> inserisce il widget figlo alla parte di sinistra o superiore
472<P>della finestra. <CODE>gtk_paned_add2()</CODE> lo inserisce invece nella parte destra o
473<P>inferore.
474<P>
475<P>Per fare un esempio, creeremo una parte dell'interfaccia utente di un immaginario
476<P>programma di email. Si divide una finestra in due verticalmente,
477<P>con la parte superiore in cui si mette la lista dei messaggi, e quella inferiore con
478<P>il testo. La maggior parte del programma &egrave; piuttosto banale. Un paio
479<P>di punti da notare sono: Non si pu&ograve; scrivere su un widget di testo prima
480<P>che esso venga "realizato". Questa operazione pu&ograve; essere fatta con una
481<P>chiamata alla funzione <CODE>gtk_widget_realize()</CODE>, ma per far vedere un metodo
482<P>alternativo, connetteremo una funzione al segnale "realize" per aggiungere il testo.
483<P>Inoltre, dobbiamo aggiungere l'opzione <CODE>GTK_SHRINK</CODE> ad alcuni degli
484<P>elementi della tabella che contiene la finestra del testo e le barre di scorrimento, in
485<P>modo che quando si riducono le dimensioni della parte inferiore, le parti coinvolte
486<P>risultino proporzionalmente rimpicciolite invece di venir spinte fuori dal fondo
487<P>della finestra.
488<P>
489<P>
490<BLOCKQUOTE><CODE>
491<PRE>
492/* paned.c */
493
494#include &lt;gtk/gtk.h>
495   
496/*Creiamo la lista dei "messaggi" */
497GtkWidget *
498create_list (void)
499{
500
501    GtkWidget *scrolled_window;
502    GtkWidget *list;
503    GtkWidget *list_item;
504   
505    int i;
506    char buffer[16];
507   
508    /* Creiamo una nuova finestra scorribile con barre di scorrimento solo
509
510     * se necessarie */
511    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
512    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
513                                    GTK_POLICY_AUTOMATIC,
514                                    GTK_POLICY_AUTOMATIC);
515   
516    /* Creiamo una nuova lista e la mettiamo nella finestra scorribile */
517    list = gtk_list_new ();
518    gtk_container_add (GTK_CONTAINER(scrolled_window), list);
519    gtk_widget_show (list);
520   
521    /* Aggiungiamo un po' di messaggi alla fiestra */
522    for (i=0; i&lt;10; i++) {
523
524        sprintf(buffer,"Message #%d",i);
525        list_item = gtk_list_item_new_with_label (buffer);
526        gtk_container_add (GTK_CONTAINER(list), list_item);
527        gtk_widget_show (list_item);
528
529    }
530   
531    return scrolled_window;
532}
533   
534/* Aggiungiamo un po' di testo al nostro widget di testo - questa e' una
535
536funzione di callback che viene invocata quando la finestra viene "realizzata".
537
538Potremmo anche forzare la finestra ad essere realizzata con la funzione
539
540 gtk_widget_realize, ma dovrebbe prima essere parte di una certa cerarchia */
541
542
543void
544realize_text (GtkWidget *text, gpointer data)
545{
546    gtk_text_freeze (GTK_TEXT (text));
547    gtk_text_insert (GTK_TEXT (text), NULL, &amp;text->style->black, NULL,
548    "From: pathfinder@nasa.gov\n"
549    "To: mom@nasa.gov\n"
550    "Subject: Made it!\n"
551    "\n"
552    "We just got in this morning. The weather has been\n"
553    "great - clear but cold, and there are lots of fun sights.\n"
554    "Sojourner says hi. See you soon.\n"
555    " -Path\n", -1);
556   
557    gtk_text_thaw (GTK_TEXT (text));
558}
559   
560/* Creiamo un'area di testo scorribile che mostra un "messaggio" */
561GtkWidget *
562create_text (void)
563{
564    GtkWidget *table;
565    GtkWidget *text;
566    GtkWidget *hscrollbar;
567    GtkWidget *vscrollbar;
568   
569    /*Creiamo una tabella in cui mettere il widget di testo e le barre di scorrimento */
570    table = gtk_table_new (2, 2, FALSE);
571   
572    /* Mettiamo un widget di testo nella parte superiore destra. Notate l'uso di
573     * GTK_SHRINK nella direzione y */
574    text = gtk_text_new (NULL, NULL);
575    gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
576                      GTK_FILL | GTK_EXPAND,
577                      GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
578    gtk_widget_show (text);
579   
580    /* Mettiamo una HScrollbar nella parte in basso a sinistra */
581    hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
582    gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
583                      GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
584    gtk_widget_show (hscrollbar);
585   
586    /* Aggiungiamo una VScrollbar in alto a sinistra */
587    vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
588    gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
589                      GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
590    gtk_widget_show (vscrollbar);
591   
592    /* Aggiungiamo un gestore per mettere un messaggio nel wiget di testo
593
594     * viene reaizzato */
595    gtk_signal_connect (GTK_OBJECT (text), "realize",
596                        GTK_SIGNAL_FUNC (realize_text), NULL);
597   
598    return table;
599}
600   
601int
602main (int argc, char *argv[])
603{
604    GtkWidget *window;
605    GtkWidget *vpaned;
606    GtkWidget *list;
607    GtkWidget *text;
608
609    gtk_init (&amp;argc, &amp;argv);
610   
611    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
612    gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
613    gtk_signal_connect (GTK_OBJECT (window), "destroy",
614                        GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
615    gtk_container_border_width (GTK_CONTAINER (window), 10);
616   
617    /* Creiamo un widget frazionato verticalmente e aggiungiamolo alla
618
619     * finestra di piu' alto livello */
620   
621    vpaned = gtk_vpaned_new ();
622    gtk_container_add (GTK_CONTAINER(window), vpaned);
623    gtk_widget_show (vpaned);
624   
625    /* Creiamo il contenuto delle de parti della finestra */
626   
627    list = create_list ();
628    gtk_paned_add1 (GTK_PANED(vpaned), list);
629    gtk_widget_show (list);
630   
631    text = create_text ();
632    gtk_paned_add2 (GTK_PANED(vpaned), text);
633    gtk_widget_show (text);
634    gtk_widget_show (window);
635    gtk_main ();
636    return 0;
637}
638</PRE>
639</CODE></BLOCKQUOTE>
640<P>  
641<H2><A NAME="ss8.4">8.4 Cornici ad aspetto fisso (Aspect Frames)</A>
642</H2>
643
644<P>Il widget aspect frame \ analogo al widget "cornice", tranne che per il
645<P>fatto che &egrave; in grado di forzare le finestre figlie ad avere un certo aspetto,
646<P>cio&egrave; un certo rapporto fra altezza e larghezza, aggiungendo se necessario
647<P>dello spazio in pi&ugrave;. Ci&ograve; pu&ograve; tornare utile se per esempio
648<P>si vuole fare l'anteprima di un'immagine: le dimensioni dell'anteprima devono
649<P>variare se l'utente ridimensiona la finestra, ma le proporzioni devono essere
650<P>sempre quelle dell'immagine originale.
651<P>Per creare una nuova cornice ad aspetto fisso, si usa:
652<P>
653<BLOCKQUOTE><CODE>
654<PRE>
655GtkWidget* gtk_aspect_frame_new  (const gchar *label,
656                                        gfloat xalign,
657                                        gfloat yalign,
658                                        gfloat ratio,
659                                        gint obey_child)
660</PRE>
661</CODE></BLOCKQUOTE>
662<P><CODE>xalign</CODE> e <CODE>yalign</CODE> specificano l'allineamento come si fa con il widget di
663<P>allineamento. Se <CODE>obey_child</CODE> &egrave; TRUE, le proporzioni di una finestra
664<P>figlia saranno le stesse delle misure ideali richieste. In caso contrario, vengono
665<P>stabilite da <CODE>ratio</CODE>.
666<P>
667<P>Per cambiare le opzioni di una finestra esistente, si pu&ograve; usare:   
668To change the options of an existing aspect frame, you can use:
669<P>
670<BLOCKQUOTE><CODE>
671<PRE>
672void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame,
673                           gfloat xalign,
674                           gfloat yalign,
675                           gfloat ratio,
676                           gint obey_child)
677</PRE>
678</CODE></BLOCKQUOTE>
679<P>
680<P>Per fare un esempio, il seguente programma usa un Aspect Frame per rendere
681<P>disponibile un'area disegnabile che sia sempre di proporzioni 2:1, in quasiasi
682<P>modo l'utente ridimensioni la finestra di base.
683<P>
684<P>
685<BLOCKQUOTE><CODE>
686<PRE>
687/* aspectframe.c */
688
689#include &lt;gtk/gtk.h>
690   
691int
692main (int argc, char *argv[])
693{
694    GtkWidget *window;
695    GtkWidget *aspect_frame;
696    GtkWidget *drawing_area;
697    gtk_init (&amp;argc, &amp;argv);
698   
699    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
700    gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
701    gtk_signal_connect (GTK_OBJECT (window), "destroy",
702    GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
703    gtk_container_border_width (GTK_CONTAINER (window), 10);
704   
705    /* Creiamo aspect_frame e lo mettiamo nella finestra di base */
706   
707    aspect_frame = gtk_aspect_frame_new ("2x1", /* etichetta */
708                                         0.5, /* x del centro */
709                                         0.5, /* y del centro */
710                                         2, /* xsize/ysize = 2 */
711                                         FALSE /* ignora le proporzioni del figlio */);
712   
713    gtk_container_add (GTK_CONTAINER(window), aspect_frame);
714    gtk_widget_show (aspect_frame);
715   
716    /* Aggiungamo un widget figlio alla nostra cornice */
717   
718    drawing_area = gtk_drawing_area_new ();
719   
720    /* Chiediamo una finestra 200x200, anche se l'AspectFrame ce ne dara' una
721     * di 200x100 perche' forziamo l'aspetto 2:1 */
722    gtk_widget_set_usize (drawing_area, 200, 200);
723    gtk_container_add (GTK_CONTAINER(aspect_frame), drawing_area);
724    gtk_widget_show (drawing_area);
725   
726    gtk_widget_show (window);
727    gtk_main ();
728    return 0;
729
730</PRE>
731</CODE></BLOCKQUOTE>
732<P>
733<P>
734<P>
735<HR NOSHADE>
736<A HREF="gtk_tut_it-9.html">Avanti</A>
737<A HREF="gtk_tut_it-7.html">Indietro</A>
738<A HREF="gtk_tut_it.html#toc8">Indice</A>
739</BODY>
740</HTML>
Note: See TracBrowser for help on using the repository browser.