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 è un insieme di pagine sovrapposte l'una con l'altra, |
---|
21 | ognuna contente cose diverse. Questo widget è diventato molto comune nella |
---|
22 | programmazione delle interfacce utente ed è un buon metodo per mostrare informazioni |
---|
23 | tra loro correlate ma che debbano essere mostrate separatamente. |
---|
24 | <P> |
---|
25 | <P>La prima funzione da invocare che si deve conoscere, come si può intuire, è usata |
---|
26 | per creare un nuovo Blocco Note. |
---|
27 | <P> |
---|
28 | <BLOCKQUOTE><CODE> |
---|
29 | <PRE> |
---|
30 | GtkWidget* gtk_notebook_new (void); |
---|
31 | </PRE> |
---|
32 | </CODE></BLOCKQUOTE> |
---|
33 | <P>Una volta che il notebook è sato creato, ci sono 12 funzioni che possono |
---|
34 | operare sul widget notebook. Guardiamole individualmente. |
---|
35 | <P>La prima che vediamo riguarda come posizionare l'indicatore di pagina. |
---|
36 | Questi inidicatori di pagina o ``linguette'' (come possono anche essere chiamati) |
---|
37 | possono essere posizionati in quattro posti: alto, basso, sinistra.destra. |
---|
38 | <P> |
---|
39 | <BLOCKQUOTE><CODE> |
---|
40 | <PRE> |
---|
41 | void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos); |
---|
42 | </PRE> |
---|
43 | </CODE></BLOCKQUOTE> |
---|
44 | <P>GtkPositionType sarà 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 |
---|
53 | un'occhiata ai primi due insieme, viste che sono molto simili. |
---|
54 | <P> |
---|
55 | <BLOCKQUOTE><CODE> |
---|
56 | <PRE> |
---|
57 | void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label); |
---|
58 | |
---|
59 | void 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 è il widget che è posto nella pagina del |
---|
64 | notebook e *tab_label e la intestazione della pagina stessa. |
---|
65 | <P>L'ultima funzione per aggiungere una pagina al notebook contiene tutte le proprietà |
---|
66 | delle precedenti due, ma permette di specificare dove posizionare la pagina che |
---|
67 | si vuole inserire. |
---|
68 | <P> |
---|
69 | <BLOCKQUOTE><CODE> |
---|
70 | <PRE> |
---|
71 | void 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 |
---|
75 | più: ``position''. |
---|
76 | Questo 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> |
---|
81 | void 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 |
---|
85 | rimuove la pagina corrispondente dal Blocco Note. |
---|
86 | <P>Per trovare qual'è la pagina corrente nel notebook bisogna usare la funzione: |
---|
87 | <P> |
---|
88 | <BLOCKQUOTE><CODE> |
---|
89 | <PRE> |
---|
90 | gint 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 |
---|
94 | notebook avanti o indietro. Semplicemente forniscono le chiamate alle rispettive |
---|
95 | funzioni del widget notebook su si può operare. NB: quando un notebook è |
---|
96 | correntemente sull'ultima pagina e viene invocata la funzione gtk_notebook_next_page, |
---|
97 | il notebook ritornerà automaticamente alla prima pagina. Logicamente succede anche |
---|
98 | il contrario quando invochi gtk_notebook_prev_page e ti trovi sulla prima pagina. |
---|
99 | <P> |
---|
100 | <BLOCKQUOTE><CODE> |
---|
101 | <PRE> |
---|
102 | void gtk_notebook_next_page (GtkNoteBook *notebook); |
---|
103 | void 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 |
---|
107 | principale del notebook sia per esempio la 5 (ad esempio) si può usare questa |
---|
108 | funzione. |
---|
109 | Se non si usa questa funzione la pagina principale sarà la 1. |
---|
110 | <P> |
---|
111 | <BLOCKQUOTE><CODE> |
---|
112 | <PRE> |
---|
113 | void 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 |
---|
117 | i bordi delle pagine. |
---|
118 | <P> |
---|
119 | <BLOCKQUOTE><CODE> |
---|
120 | <PRE> |
---|
121 | void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs); |
---|
122 | void 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 |
---|
127 | dal file testgtk.c che è compreso in tutte le distribuzioni, e mostra |
---|
128 | tutte le 13 funzioni. Questo piccolo programma crea una finestra con un notebook |
---|
129 | e 6 bottoni. Il notebook contiene 11 pagine, aggiunte nei 3 modi differenti (alla |
---|
130 | fine, all'inizio o in qualsiasi posizione). I bottoni permettono di girare le |
---|
131 | intestazioni, aggiungere/rimuovere le intestazioni e i bordi, rimuovere una |
---|
132 | pagina, cambiare la pagina avanti e indietro e uscire dal programma. |
---|
133 | <P> |
---|
134 | <BLOCKQUOTE><CODE> |
---|
135 | <PRE> |
---|
136 | /* notebook.c */ |
---|
137 | |
---|
138 | #include <gtk/gtk.h> |
---|
139 | |
---|
140 | /* Queta funzione ruota le posizione delle linguette delle pagine */ |
---|
141 | void 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 */ |
---|
147 | void 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 */ |
---|
161 | void 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 | |
---|
172 | void delete (GtkWidget *widget, gpointer data) |
---|
173 | { |
---|
174 | gtk_main_quit (); |
---|
175 | } |
---|
176 | |
---|
177 | int 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 (&argc, &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 < 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 < 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à la prima pagina che sarà 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. |
---|
316 | Si può inserire qualsiasi tipo di widget in questo tipo di finestra, e possono poi |
---|
317 | essere accessibili a prescindere dalle dimensioni usando le barre di scorrimento. |
---|
318 | <P>La funzione seguente è usata per creare una nuova scrolled window. |
---|
319 | <P> |
---|
320 | <BLOCKQUOTE><CODE> |
---|
321 | <PRE> |
---|
322 | GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment, |
---|
323 | GtkAdjustment *vadjustment); |
---|
324 | </PRE> |
---|
325 | </CODE></BLOCKQUOTE> |
---|
326 | <P>Il primo argomento è l'aggiustamento (di quanto scendere ogni |
---|
327 | volta) orizzontale e il secondo è quello verticale. A questi si assegna |
---|
328 | quasi sempre il valore NULL. |
---|
329 | <P> |
---|
330 | <P> |
---|
331 | <BLOCKQUOTE><CODE> |
---|
332 | <PRE> |
---|
333 | void 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 |
---|
339 | argomento è la finestra scorribile interessata. Il secondo stabilisce la politica |
---|
340 | per la barra di scorrimento orizzontale e il terzo è quello per la politca verticale. |
---|
341 | <P>La politica può essere GTK_POLICY AUTOMATIC o GTK_POLICY_ALWAYS. |
---|
342 | GTK_POLICY_AUTOMATIC decide automaticamente se la barra di scorrimento deve essere |
---|
343 | visualizzata, mentre con GTK_POLICY_ALWAYS la barra verrà sempre mostrata. |
---|
344 | <P> |
---|
345 | <BLOCKQUOTE><CODE> |
---|
346 | <PRE> |
---|
347 | /* scrolledwin.c */ |
---|
348 | |
---|
349 | #include <gtk/gtk.h> |
---|
350 | |
---|
351 | void destroy(GtkWidget *widget, gpointer data) |
---|
352 | { |
---|
353 | gtk_main_quit(); |
---|
354 | } |
---|
355 | |
---|
356 | int 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 (&argc, &argv); |
---|
366 | |
---|
367 | /* Crea una nuove finestra di dialogo in cui la scrolled window sarà |
---|
368 | inserita. Una finestra di dialogo è semplicemente come una |
---|
369 | finestra normale, ma ha anche un vbox e un separatore orizzontale |
---|
370 | già 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 è 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 è creata con un vbox già 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 < 10; i++) |
---|
408 | for (j = 0; j < 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ì 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à */ |
---|
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 |
---|
441 | barra di scorrimento. Potete anche usare la funzione gtk_widget_set_usize() per |
---|
442 | assegnare 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ò |
---|
450 | <P>trascinare per cambiare la proporzione fra le aree. La divisione può |
---|
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> |
---|
457 | GtkWidget* gtk_hpaned_new (void) |
---|
458 | GtkWidget* 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> |
---|
467 | void gtk_paned_add1 (GtkPaned *paned, GtkWidget *child) |
---|
468 | void 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 è piuttosto banale. Un paio |
---|
479 | <P>di punti da notare sono: Non si può scrivere su un widget di testo prima |
---|
480 | <P>che esso venga "realizato". Questa operazione può 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 <gtk/gtk.h> |
---|
495 | |
---|
496 | /*Creiamo la lista dei "messaggi" */ |
---|
497 | GtkWidget * |
---|
498 | create_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<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 | |
---|
536 | funzione di callback che viene invocata quando la finestra viene "realizzata". |
---|
537 | |
---|
538 | Potremmo 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 | |
---|
543 | void |
---|
544 | realize_text (GtkWidget *text, gpointer data) |
---|
545 | { |
---|
546 | gtk_text_freeze (GTK_TEXT (text)); |
---|
547 | gtk_text_insert (GTK_TEXT (text), NULL, &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" */ |
---|
561 | GtkWidget * |
---|
562 | create_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 | |
---|
601 | int |
---|
602 | main (int argc, char *argv[]) |
---|
603 | { |
---|
604 | GtkWidget *window; |
---|
605 | GtkWidget *vpaned; |
---|
606 | GtkWidget *list; |
---|
607 | GtkWidget *text; |
---|
608 | |
---|
609 | gtk_init (&argc, &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 è in grado di forzare le finestre figlie ad avere un certo aspetto, |
---|
646 | <P>cioè un certo rapporto fra altezza e larghezza, aggiungendo se necessario |
---|
647 | <P>dello spazio in più. Ciò può 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> |
---|
655 | GtkWidget* 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> è 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ò usare: |
---|
668 | To change the options of an existing aspect frame, you can use: |
---|
669 | <P> |
---|
670 | <BLOCKQUOTE><CODE> |
---|
671 | <PRE> |
---|
672 | void 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 <gtk/gtk.h> |
---|
690 | |
---|
691 | int |
---|
692 | main (int argc, char *argv[]) |
---|
693 | { |
---|
694 | GtkWidget *window; |
---|
695 | GtkWidget *aspect_frame; |
---|
696 | GtkWidget *drawing_area; |
---|
697 | gtk_init (&argc, &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> |
---|