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: Il Widgets Lista</TITLE> |
---|
6 | <LINK HREF="gtk_tut_it-10.html" REL=next> |
---|
7 | <LINK HREF="gtk_tut_it-8.html" REL=previous> |
---|
8 | <LINK HREF="gtk_tut_it.html#toc9" REL=contents> |
---|
9 | </HEAD> |
---|
10 | <BODY BGCOLOR="#FFFFFF"> |
---|
11 | <A HREF="gtk_tut_it-10.html">Avanti</A> |
---|
12 | <A HREF="gtk_tut_it-8.html">Indietro</A> |
---|
13 | <A HREF="gtk_tut_it.html#toc9">Indice</A> |
---|
14 | <HR NOSHADE> |
---|
15 | <H2><A NAME="s9">9. Il Widgets Lista</A></H2> |
---|
16 | |
---|
17 | <P>Il widget GtkList serve come contenitore verticale per altri widget che |
---|
18 | devono essere di tipo GtkListItem. |
---|
19 | <P>Un widget GtkList possiede una sua propria finestra per ricevere eventi |
---|
20 | e un suo proprio colore di sfondo che di solito è bianco. Dal momento |
---|
21 | che è direttamente derivato dal widget GtkContainer, può essere trattato |
---|
22 | come tale usando la macro GTK_CONTAINER(List); si veda il widget GtkContainer |
---|
23 | per ulteriori dettagli. |
---|
24 | Per usare il widget GtkList in tutte le sue potenzialità, si dovrebbe essere |
---|
25 | già familiari con l'uso della GList e delle relative funzioni g_list_*(). |
---|
26 | <P>All'interno della definizione della struttura del widget GtkList c'è un |
---|
27 | campo che sarà per noi di grande interesse, cioè: |
---|
28 | <P> |
---|
29 | <BLOCKQUOTE><CODE> |
---|
30 | <PRE> |
---|
31 | struct _GtkList |
---|
32 | { |
---|
33 | ... |
---|
34 | GList *selection; |
---|
35 | guint selection_mode; |
---|
36 | ... |
---|
37 | }; |
---|
38 | </PRE> |
---|
39 | </CODE></BLOCKQUOTE> |
---|
40 | <P>Il campo ``selection'' in un GtkList punta a una lista collegata di tutti |
---|
41 | gli elementi che sono selezionati correntemente, oppure a NULL se la |
---|
42 | selezione è vuota. Quindi, per avere informazioni sulla selezione corrente, |
---|
43 | leggiamo il campo GTK_LIST()->selection, senza però modificarlo dal momento |
---|
44 | che i campi interni debbono essere gestiti dalle funzioni gtk_list_*(). |
---|
45 | <P>Le modalità di selezione in una GtkList, e quindi il contenuto di |
---|
46 | GTK_LIST()->selection, sono determinate dal campo selection_mode: |
---|
47 | <P>selection_mode può assumere uno dei seguenti valori: |
---|
48 | <UL> |
---|
49 | <LI> GTK_SELECTION_SINGLE - La selezione può essere o NULL oppure |
---|
50 | un puntatore GList* per un singolo elemento |
---|
51 | selezionato. |
---|
52 | </LI> |
---|
53 | <LI> GTK_SELECTION_BROWSE - La selezione è null se la lista non contiene |
---|
54 | alcun widget o se ha solo widget non sensibili, |
---|
55 | oppure può contenere un puntatore a una struttura |
---|
56 | GList, e quindi esattamente un elemento di lista. |
---|
57 | </LI> |
---|
58 | <LI> GTK_SELECTION_MULTIPLE - La selezione è ``NULL'' se non è selezionato |
---|
59 | alcun elemento di lista, oppure un puntatore GList al |
---|
60 | primo elemento selezionato. Quello, a sua volta, punta |
---|
61 | a una struttura GList per il secondo elemento selezionato |
---|
62 | e così via. |
---|
63 | </LI> |
---|
64 | <LI> GTK_SELECTION_EXTENDED - La selezione è sempre NULL.</LI> |
---|
65 | </UL> |
---|
66 | <P>Il valore per difetto è GTK_SELECTION_MULTIPLE. |
---|
67 | <P> |
---|
68 | <H2><A NAME="ss9.1">9.1 Segnali</A> |
---|
69 | </H2> |
---|
70 | |
---|
71 | <P> |
---|
72 | <BLOCKQUOTE><CODE> |
---|
73 | <PRE> |
---|
74 | void selection_changed (GtkList *LIST) |
---|
75 | </PRE> |
---|
76 | </CODE></BLOCKQUOTE> |
---|
77 | <P>Questo segnale verrà invocato ogni volta che il campo di |
---|
78 | selezione di una GtkList è cambiato. Questo accade quando |
---|
79 | un figlio della GtkList viene selezionato o deselezionato. |
---|
80 | <P> |
---|
81 | <BLOCKQUOTE><CODE> |
---|
82 | <PRE> |
---|
83 | void select_child (GtkList *LIST, GtkWidget *CHILD) |
---|
84 | </PRE> |
---|
85 | </CODE></BLOCKQUOTE> |
---|
86 | <P>Questo segnale viene invocato quando un fuglio di una GtkList |
---|
87 | sta per essere selezionato. Questo accade principalmente in |
---|
88 | occasione di chiamate a gtk_list_select_item() e gtk_list_select_child(), |
---|
89 | di pressioni di bottoni e a volte può venir fatto scattare indirettamente |
---|
90 | in altre occasioni, in cui vengono aggiunti o rimossi dei figli |
---|
91 | dalla GtkList. |
---|
92 | <P> |
---|
93 | <BLOCKQUOTE><CODE> |
---|
94 | <PRE> |
---|
95 | void unselect_child (GtkList *LIST, GtkWidget *CHILD) |
---|
96 | </PRE> |
---|
97 | </CODE></BLOCKQUOTE> |
---|
98 | <P>Questo segnale viene invocato quando un figlio della GtkList sta |
---|
99 | per essere deselezionato. Ciò accade principalmente in occasione |
---|
100 | di chiamate a gtk_list_unselect_item() e gtk_list_unselect_child(), |
---|
101 | di pressioni di bottoni, e a volte può venir fatto scattare indirettamente |
---|
102 | in altre occasioni, in cui vengono aggiunti o rimossi dei figli |
---|
103 | dalla GtkList. |
---|
104 | <P> |
---|
105 | <H2><A NAME="ss9.2">9.2 Funzioni</A> |
---|
106 | </H2> |
---|
107 | |
---|
108 | <P> |
---|
109 | <BLOCKQUOTE><CODE> |
---|
110 | <PRE> |
---|
111 | guint gtk_list_get_type (void) |
---|
112 | </PRE> |
---|
113 | </CODE></BLOCKQUOTE> |
---|
114 | <P>Restituisce l'identificatore di tipo `GtkList'. |
---|
115 | <P> |
---|
116 | <BLOCKQUOTE><CODE> |
---|
117 | <PRE> |
---|
118 | GtkWidget* gtk_list_new (void) |
---|
119 | </PRE> |
---|
120 | </CODE></BLOCKQUOTE> |
---|
121 | <P>Crea un nuovo oggetto `GtkList'. Il nuovo widget viene |
---|
122 | restituito sotto forma di un puntoatore ad un oggetto |
---|
123 | `GtkWidgetì'. In caso di fallimento, viene ritornato NULL. |
---|
124 | <P> |
---|
125 | <BLOCKQUOTE><CODE> |
---|
126 | <PRE> |
---|
127 | void gtk_list_insert_items (GtkList *LIST, GList *ITEMS, gint POSITION) |
---|
128 | </PRE> |
---|
129 | </CODE></BLOCKQUOTE> |
---|
130 | <P>Inserisce degli elementi di lista nella LIST, a partire da |
---|
131 | POSITION. ITEMS ITEMS è una lista doppiamente collegata, in |
---|
132 | cui ci si aspetta che i puntatori di ogni nodo puntino a |
---|
133 | un GtkListItem appena creato. I nodi GList di ITEMS vengono |
---|
134 | assunti dalla LIST. |
---|
135 | <P> |
---|
136 | <BLOCKQUOTE><CODE> |
---|
137 | <PRE> |
---|
138 | void gtk_list_append_items (GtkList *LIST, GList *ITEMS) |
---|
139 | </PRE> |
---|
140 | </CODE></BLOCKQUOTE> |
---|
141 | <P>Inserisce elementi di lista proprio come gtk_list_insert_items(), |
---|
142 | ma alla fine della LIST. I nodi GList di ITEMS vengono |
---|
143 | assunti dalla LIST. |
---|
144 | <P> |
---|
145 | <BLOCKQUOTE><CODE> |
---|
146 | <PRE> |
---|
147 | void gtk_list_prepend_items (GtkList *LIST, GList *ITEMS) |
---|
148 | </PRE> |
---|
149 | </CODE></BLOCKQUOTE> |
---|
150 | <P>Inserisce elementi di lista proprio come gtk_list_insert_items(), |
---|
151 | ma al principio della LIST. I nodi GList di ITEMS vengono |
---|
152 | assunti dalla LIST. |
---|
153 | <P> |
---|
154 | <BLOCKQUOTE><CODE> |
---|
155 | <PRE> |
---|
156 | void gtk_list_remove_items (GtkList *LIST, GList *ITEMS) |
---|
157 | </PRE> |
---|
158 | </CODE></BLOCKQUOTE> |
---|
159 | <P>Rimuove degli elementi di lista dalla LIST. ITEMS è una lista |
---|
160 | doppiamente collegata in cui ci si aspetta che i puntatori di |
---|
161 | ogni nodo puntino a un figlio diretto di LIST. E' poi responsabilità |
---|
162 | del chiamante di fare una chiamata a g_list_free(ITEMS). E' anche |
---|
163 | necessario che il chiamante distrugga lui stesso gli elementi della |
---|
164 | lista. |
---|
165 | <P> |
---|
166 | <BLOCKQUOTE><CODE> |
---|
167 | <PRE> |
---|
168 | void gtk_list_clear_items (GtkList *LIST, gint START, gint END) |
---|
169 | </PRE> |
---|
170 | </CODE></BLOCKQUOTE> |
---|
171 | <P>Rimuove e distrugge elementi di lista da LIST. Un widget ne è |
---|
172 | interessato se la sua posizione corrente all'interno di LIST è compreso |
---|
173 | fra START ed END. |
---|
174 | <P> |
---|
175 | <BLOCKQUOTE><CODE> |
---|
176 | <PRE> |
---|
177 | void gtk_list_select_item (GtkList *LIST, gint ITEM) |
---|
178 | </PRE> |
---|
179 | </CODE></BLOCKQUOTE> |
---|
180 | <P>Invoca il segnale select_child per un elemento di lista |
---|
181 | specificato dalla sua posizione corrente all'interno di LIST. |
---|
182 | <P> |
---|
183 | <BLOCKQUOTE><CODE> |
---|
184 | <PRE> |
---|
185 | void gtk_list_unselect_item (GtkList *LIST, gint ITEM) |
---|
186 | </PRE> |
---|
187 | </CODE></BLOCKQUOTE> |
---|
188 | <P>Invoca il segnale unselect_child per un elemento di lista |
---|
189 | specificato dalla sua posizione corrente all'interno di LIST. |
---|
190 | <P> |
---|
191 | <BLOCKQUOTE><CODE> |
---|
192 | <PRE> |
---|
193 | void gtk_list_select_child (GtkList *LIST, GtkWidget *CHILD) |
---|
194 | </PRE> |
---|
195 | </CODE></BLOCKQUOTE> |
---|
196 | <P>Invoca il segnale select_child per uno specifico CHILD. |
---|
197 | <P> |
---|
198 | <BLOCKQUOTE><CODE> |
---|
199 | <PRE> |
---|
200 | void gtk_list_unselect_child (GtkList *LIST, GtkWidget *CHILD) |
---|
201 | </PRE> |
---|
202 | </CODE></BLOCKQUOTE> |
---|
203 | <P>Invoca il segnale unselect_child per uno specifico CHILD. |
---|
204 | <P> |
---|
205 | <BLOCKQUOTE><CODE> |
---|
206 | <PRE> |
---|
207 | gint gtk_list_child_position (GtkList *LIST, GtkWidget *CHILD) |
---|
208 | </PRE> |
---|
209 | </CODE></BLOCKQUOTE> |
---|
210 | <P>Restituisce la posizione di CHILD all'interno di LIST. In caso di fallimento, |
---|
211 | viene restituito `-1'. |
---|
212 | <P> |
---|
213 | <BLOCKQUOTE><CODE> |
---|
214 | <PRE> |
---|
215 | void gtk_list_set_selection_mode (GtkList *LIST, GtkSelectionMode MODE) |
---|
216 | </PRE> |
---|
217 | </CODE></BLOCKQUOTE> |
---|
218 | <P>Assegna a LIST il modo di selezione MODE, che può essere uno fra |
---|
219 | GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE o |
---|
220 | GTK_SELECTION_EXTENDED. |
---|
221 | <P> |
---|
222 | <BLOCKQUOTE><CODE> |
---|
223 | <PRE> |
---|
224 | GtkList* GTK_LIST (gpointer OBJ) |
---|
225 | </PRE> |
---|
226 | </CODE></BLOCKQUOTE> |
---|
227 | <P>Fa il cast di un generico puntatore a `GtkList*'. Per maggiori |
---|
228 | informazioni vedere Standard Macros::. |
---|
229 | <P> |
---|
230 | <BLOCKQUOTE><CODE> |
---|
231 | <PRE> |
---|
232 | GtkListClass* GTK_LIST_CLASS (gpointer CLASS) |
---|
233 | </PRE> |
---|
234 | </CODE></BLOCKQUOTE> |
---|
235 | <P>Fa il cast di un generico puntatore a `GtkListClass*'. Per maggiori |
---|
236 | informazioni vedere Standard Macros::. |
---|
237 | <P> |
---|
238 | <BLOCKQUOTE><CODE> |
---|
239 | <PRE> |
---|
240 | gint GTK_IS_LIST (gpointer OBJ) |
---|
241 | </PRE> |
---|
242 | </CODE></BLOCKQUOTE> |
---|
243 | <P>Determina se un generico puntatore si riferisce ad un oggetto `GtkList'. |
---|
244 | Per maggiori informazioni vedere Standard Macros::. |
---|
245 | <P> |
---|
246 | <H2><A NAME="ss9.3">9.3 Esempio</A> |
---|
247 | </H2> |
---|
248 | |
---|
249 | <P>Diamo di seguito un programma di esempio che stamperà i campbiamenti |
---|
250 | della selezione di una GtkList, e vi lascia ``imprigionare'' gli elementi |
---|
251 | di una lista selezionandoli con il pulsante destro del mouse: |
---|
252 | <P> |
---|
253 | <BLOCKQUOTE><CODE> |
---|
254 | <PRE> |
---|
255 | /* list.c */ |
---|
256 | |
---|
257 | /* includiamo i file header di gtk+ |
---|
258 | * includiamo stdio.h, ne abbiamo bisogno per printf() |
---|
259 | */ |
---|
260 | #include <gtk/gtk.h> |
---|
261 | #include <stdio.h> |
---|
262 | |
---|
263 | /* Questa e' la nostra stringa di identificazione dei dati per assegnarli |
---|
264 | * ad elementi di lista |
---|
265 | */ |
---|
266 | const gchar *list_item_data_key="list_item_data"; |
---|
267 | |
---|
268 | |
---|
269 | /* prototipi per i gestori di segnale che connetteremo |
---|
270 | * al widget GtkList |
---|
271 | */ |
---|
272 | static void sigh_print_selection (GtkWidget *gtklist, |
---|
273 | gpointer func_data); |
---|
274 | static void sigh_button_event (GtkWidget *gtklist, |
---|
275 | GdkEventButton *event, |
---|
276 | GtkWidget *frame); |
---|
277 | |
---|
278 | |
---|
279 | /* funzione main per predisporre l'interfaccia utente */ |
---|
280 | |
---|
281 | gint main (int argc, gchar *argv[]) |
---|
282 | { |
---|
283 | GtkWidget *separator; |
---|
284 | GtkWidget *window; |
---|
285 | GtkWidget *vbox; |
---|
286 | GtkWidget *scrolled_window; |
---|
287 | GtkWidget *frame; |
---|
288 | GtkWidget *gtklist; |
---|
289 | GtkWidget *button; |
---|
290 | GtkWidget *list_item; |
---|
291 | GList *dlist; |
---|
292 | guint i; |
---|
293 | gchar buffer[64]; |
---|
294 | |
---|
295 | |
---|
296 | /* inizializza gtk+ (e di conseguenza gdk) */ |
---|
297 | |
---|
298 | gtk_init(&argc, &argv); |
---|
299 | |
---|
300 | |
---|
301 | /* crea una finestra in cui mettere tutti i widget |
---|
302 | * connette gtk_main_quit() al segnale "destroy" della finestra |
---|
303 | * per gestire le richieste di chiusura finestra del window manager |
---|
304 | */ |
---|
305 | window=gtk_window_new(GTK_WINDOW_TOPLEVEL); |
---|
306 | gtk_window_set_title(GTK_WINDOW(window), "GtkList Example"); |
---|
307 | gtk_signal_connect(GTK_OBJECT(window), |
---|
308 | "destroy", |
---|
309 | GTK_SIGNAL_FUNC(gtk_main_quit), |
---|
310 | NULL); |
---|
311 | |
---|
312 | |
---|
313 | /* all'interno della finestra abbiamo bisogno di una scatola |
---|
314 | * in cui mettere i widget verticalmente */ |
---|
315 | vbox=gtk_vbox_new(FALSE, 5); |
---|
316 | gtk_container_border_width(GTK_CONTAINER(vbox), 5); |
---|
317 | gtk_container_add(GTK_CONTAINER(window), vbox); |
---|
318 | gtk_widget_show(vbox); |
---|
319 | |
---|
320 | /* questa è la finestra scorribile in cui mettere il widget GtkList */ |
---|
321 | scrolled_window=gtk_scrolled_window_new(NULL, NULL); |
---|
322 | gtk_widget_set_usize(scrolled_window, 250, 150); |
---|
323 | gtk_container_add(GTK_CONTAINER(vbox), scrolled_window); |
---|
324 | gtk_widget_show(scrolled_window); |
---|
325 | |
---|
326 | /* crea il widget GtkList |
---|
327 | * connette il gestore di segnale sigh_print_selection() |
---|
328 | * al segnale "selection_changed" della GtkList, per stampare |
---|
329 | * gli elementi selezionati ogni volta che la selezione cambia |
---|
330 | */ |
---|
331 | gtklist=gtk_list_new(); |
---|
332 | gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist); |
---|
333 | gtk_widget_show(gtklist); |
---|
334 | gtk_signal_connect(GTK_OBJECT(gtklist), |
---|
335 | "selection_changed", |
---|
336 | GTK_SIGNAL_FUNC(sigh_print_selection), |
---|
337 | NULL); |
---|
338 | |
---|
339 | /* creiamo una "Prigione" (Prison) in cui mettere gli elementi di lista ;) |
---|
340 | */ |
---|
341 | frame=gtk_frame_new("Prison"); |
---|
342 | gtk_widget_set_usize(frame, 200, 50); |
---|
343 | gtk_container_border_width(GTK_CONTAINER(frame), 5); |
---|
344 | gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); |
---|
345 | gtk_container_add(GTK_CONTAINER(vbox), frame); |
---|
346 | gtk_widget_show(frame); |
---|
347 | |
---|
348 | /* connette il gestore di segnale sigh_button_event() alla GtkList |
---|
349 | * il quale gestira' l'"imprigionamento" degli elementi di lista |
---|
350 | */ |
---|
351 | gtk_signal_connect(GTK_OBJECT(gtklist), |
---|
352 | "button_release_event", |
---|
353 | GTK_SIGNAL_FUNC(sigh_button_event), |
---|
354 | frame); |
---|
355 | |
---|
356 | /* crea un separatore |
---|
357 | */ |
---|
358 | separator=gtk_hseparator_new(); |
---|
359 | gtk_container_add(GTK_CONTAINER(vbox), separator); |
---|
360 | gtk_widget_show(separator); |
---|
361 | |
---|
362 | /* infine creiamo un bottone e connettiamone il segnale "clicked" |
---|
363 | * alla distruzione della finestra |
---|
364 | */ |
---|
365 | button=gtk_button_new_with_label("Close"); |
---|
366 | gtk_container_add(GTK_CONTAINER(vbox), button); |
---|
367 | gtk_widget_show(button); |
---|
368 | gtk_signal_connect_object(GTK_OBJECT(button), |
---|
369 | "clicked", |
---|
370 | GTK_SIGNAL_FUNC(gtk_widget_destroy), |
---|
371 | GTK_OBJECT(window)); |
---|
372 | |
---|
373 | |
---|
374 | /* a questo punto creiamo 5 elementi di lista, ognuno con la |
---|
375 | * propria etichetta, e li aggiungiamo alla GtkList usando |
---|
376 | * gtk_container_add(). Inoltre, recuperiamo la stringa di testo |
---|
377 | * dall'etichetta e la associamo, per ogni elemento, a |
---|
378 | * list_item_data_key |
---|
379 | */ |
---|
380 | for (i=0; i<5; i++) { |
---|
381 | GtkWidget *label; |
---|
382 | gchar *string; |
---|
383 | |
---|
384 | sprintf(buffer, "ListItemContainer with Label #%d", i); |
---|
385 | label=gtk_label_new(buffer); |
---|
386 | list_item=gtk_list_item_new(); |
---|
387 | gtk_container_add(GTK_CONTAINER(list_item), label); |
---|
388 | gtk_widget_show(label); |
---|
389 | gtk_container_add(GTK_CONTAINER(gtklist), list_item); |
---|
390 | gtk_widget_show(list_item); |
---|
391 | gtk_label_get(GTK_LABEL(label), &string); |
---|
392 | gtk_object_set_data(GTK_OBJECT(list_item), |
---|
393 | list_item_data_key, |
---|
394 | string); |
---|
395 | } |
---|
396 | |
---|
397 | /* qui creiamo altre 5 etichette, questa volta usando |
---|
398 | * per la creazione gtk_list_item_new_with_label(). |
---|
399 | * Non possiamo recuperare la stringa di testo dall'etichetta |
---|
400 | * dal momento che non disponiamo di puntatori alle etichette, |
---|
401 | * quindi associamo semplicemente il list_item_data_key di ogni |
---|
402 | * elemento di lista con la medesima stringa di testo. |
---|
403 | * Per aggiungere elementi di lista, li mettiamo tutti in una lista |
---|
404 | * doppiamente collegata (GList), e quindi li aggiungiamo con una |
---|
405 | * unica chiamata a gtk_list_append_items(). |
---|
406 | * Dal momento che usiamo g_list_prepend() per mettere gli elementi |
---|
407 | * nella lista doppiamente collegata, il loro ordine sara' discendente |
---|
408 | * (invece che ascendente come sarebbe se usassimo g_list_append()) |
---|
409 | */ |
---|
410 | dlist=NULL; |
---|
411 | for (; i<10; i++) { |
---|
412 | sprintf(buffer, "List Item with Label %d", i); |
---|
413 | list_item=gtk_list_item_new_with_label(buffer); |
---|
414 | dlist=g_list_prepend(dlist, list_item); |
---|
415 | gtk_widget_show(list_item); |
---|
416 | gtk_object_set_data(GTK_OBJECT(list_item), |
---|
417 | list_item_data_key, |
---|
418 | "ListItem with integrated Label"); |
---|
419 | } |
---|
420 | gtk_list_append_items(GTK_LIST(gtklist), dlist); |
---|
421 | |
---|
422 | /* e finalmente vogliamo vedere la finestra, non e' vero? ;) |
---|
423 | */ |
---|
424 | gtk_widget_show(window); |
---|
425 | |
---|
426 | /* lancia il ciclo principale di gtk |
---|
427 | */ |
---|
428 | gtk_main(); |
---|
429 | |
---|
430 | /* si arriva a questo punto dopo la chiamata di gtk_main_quit(), |
---|
431 | * il che accade quando viene distrutta la finestra principale |
---|
432 | */ |
---|
433 | return 0; |
---|
434 | } |
---|
435 | |
---|
436 | /* questo e' il gestore di segnale che e' stato connesso all'evento di |
---|
437 | * pressione/rilascio del bottone della GtkList |
---|
438 | */ |
---|
439 | void |
---|
440 | sigh_button_event (GtkWidget *gtklist, |
---|
441 | GdkEventButton *event, |
---|
442 | GtkWidget *frame) |
---|
443 | { |
---|
444 | /* facciamo qualcosa solo nel caso di rilascio del terzo bottone |
---|
445 | * (quello piu' a destra) |
---|
446 | */ |
---|
447 | if (event->type==GDK_BUTTON_RELEASE && |
---|
448 | event->button==3) { |
---|
449 | GList *dlist, *free_list; |
---|
450 | GtkWidget *new_prisoner; |
---|
451 | |
---|
452 | /* recuperiamo l'elemento di lista selezionato correntemente, |
---|
453 | * che sara' il nostro prossimo prigioniero ;) |
---|
454 | */ |
---|
455 | dlist=GTK_LIST(gtklist)->selection; |
---|
456 | if (dlist) |
---|
457 | new_prisoner=GTK_WIDGET(dlist->data); |
---|
458 | else |
---|
459 | new_prisoner=NULL; |
---|
460 | |
---|
461 | /* cerchiamo elementi di lista gia' imprigionati, |
---|
462 | * li rimetteremo nella lista. |
---|
463 | * Ricordare di liberare la lista doppiamente collegata |
---|
464 | * che viene restituita da gtk_container_children() |
---|
465 | */ |
---|
466 | dlist=gtk_container_children(GTK_CONTAINER(frame)); |
---|
467 | free_list=dlist; |
---|
468 | while (dlist) { |
---|
469 | GtkWidget *list_item; |
---|
470 | |
---|
471 | list_item=dlist->data; |
---|
472 | |
---|
473 | gtk_widget_reparent(list_item, gtklist); |
---|
474 | |
---|
475 | dlist=dlist->next; |
---|
476 | } |
---|
477 | g_list_free(free_list); |
---|
478 | |
---|
479 | /* se abbiamo un nuovo prigioniero, lo rimuoviamo |
---|
480 | * dalla GtkList e lo mettiamo nella cornice della |
---|
481 | * "Prigione". Dobbiamo prima deselezionare l'elemento |
---|
482 | */ |
---|
483 | if (new_prisoner) { |
---|
484 | GList static_dlist; |
---|
485 | |
---|
486 | static_dlist.data=new_prisoner; |
---|
487 | static_dlist.next=NULL; |
---|
488 | static_dlist.prev=NULL; |
---|
489 | |
---|
490 | gtk_list_unselect_child(GTK_LIST(gtklist), |
---|
491 | new_prisoner); |
---|
492 | gtk_widget_reparent(new_prisoner, frame); |
---|
493 | } |
---|
494 | } |
---|
495 | } |
---|
496 | |
---|
497 | /* questo e' il gestore di segnaleche viene chiamato de la |
---|
498 | * GtkList emette il segnale "selection_changed" |
---|
499 | */ |
---|
500 | void |
---|
501 | sigh_print_selection (GtkWidget *gtklist, |
---|
502 | gpointer func_data) |
---|
503 | { |
---|
504 | GList *dlist; |
---|
505 | |
---|
506 | /* recuperiamo la lista doppiamente collegata degli |
---|
507 | * elementi selezionati della GtkList, ricordate di |
---|
508 | * trattarla come sola lettura |
---|
509 | */ |
---|
510 | dlist=GTK_LIST(gtklist)->selection; |
---|
511 | |
---|
512 | /* se non ci sono elementi selezionati non c'e' altro da |
---|
513 | * fare che dirlo all'utente |
---|
514 | */ |
---|
515 | if (!dlist) { |
---|
516 | g_print("Selection cleared\n"); |
---|
517 | return; |
---|
518 | } |
---|
519 | /* ok, abbiamo una selezione e quindi lo scriviamo |
---|
520 | */ |
---|
521 | g_print("The selection is a "); |
---|
522 | |
---|
523 | /* ottieniamo l'elemento di lista dalla lista doppiamente |
---|
524 | * collegata e poi richiediamo i dati associati con |
---|
525 | * list_item_data_key. Poi semplicemente li stampiamo |
---|
526 | */ |
---|
527 | while (dlist) { |
---|
528 | GtkObject *list_item; |
---|
529 | gchar *item_data_string; |
---|
530 | |
---|
531 | list_item=GTK_OBJECT(dlist->data); |
---|
532 | item_data_string=gtk_object_get_data(list_item, |
---|
533 | list_item_data_key); |
---|
534 | g_print("%s ", item_data_string); |
---|
535 | |
---|
536 | dlist=dlist->next; |
---|
537 | } |
---|
538 | g_print("\n"); |
---|
539 | } |
---|
540 | </PRE> |
---|
541 | </CODE></BLOCKQUOTE> |
---|
542 | <P> |
---|
543 | <H2><A NAME="ss9.4">9.4 Il Widget Elemento di Lista (List Item)</A> |
---|
544 | </H2> |
---|
545 | |
---|
546 | <P>Il widget GtkListItem è progettato allo scopo di essere un contenitore |
---|
547 | collegato ad un figlio, per fornire le funzioni per la selezione e deselezione |
---|
548 | allo stesso modo in cui il widget GtkList ne ha bisogno per i propri figli. |
---|
549 | <P>Un GtkListItem ha la sua propria finestra per ricevere eventi, e ha il suo |
---|
550 | proprio colore di sfondo, che di solito è bianco. |
---|
551 | <P>Dal momento che questo widget deriva direttamente da GtkItem, può essere |
---|
552 | trattato come tale usando la macro GTK_ITEM(ListItem), vedere il widget |
---|
553 | GtkItem per ulteriori informazioni. |
---|
554 | Di solito un GtkListItem ha solo un'etichetta per identificare per esempio |
---|
555 | un nome di file all'interno di una GtkList -- per cui viene fornita la |
---|
556 | funzione appropriata gtk_list_item_new_with_label(). Si può ottenere lo |
---|
557 | stesso effetto creando una GtkLabel da sola, assegnando al suo allineamento |
---|
558 | i valori xalign=0 e yalign=0.5, aggiungendo successivamente un contenitore |
---|
559 | alla GtkListItem. |
---|
560 | <P>Dal momento che non si è obbligati a mettere una GtkLabel, si può anche |
---|
561 | aggiungere una GtkVBox una GtkArrow ecc. alla GtkListItem. |
---|
562 | <P> |
---|
563 | <P> |
---|
564 | <H2><A NAME="ss9.5">9.5 Segnali</A> |
---|
565 | </H2> |
---|
566 | |
---|
567 | <P>Un GtkListItem non crea alcun nuovo segnale di per se, ma eredita |
---|
568 | i segnali di GtkItem. Per ulteriori informazioni, vedere GtkItem::. |
---|
569 | <P> |
---|
570 | <H2><A NAME="ss9.6">9.6 Funzioni</A> |
---|
571 | </H2> |
---|
572 | |
---|
573 | <P> |
---|
574 | <P> |
---|
575 | <BLOCKQUOTE><CODE> |
---|
576 | <PRE> |
---|
577 | guint gtk_list_item_get_type (void) |
---|
578 | </PRE> |
---|
579 | </CODE></BLOCKQUOTE> |
---|
580 | <P>Restituisce l'identificatore di tipo `GtkListItem'. |
---|
581 | <P> |
---|
582 | <BLOCKQUOTE><CODE> |
---|
583 | <PRE> |
---|
584 | GtkWidget* gtk_list_item_new (void) |
---|
585 | </PRE> |
---|
586 | </CODE></BLOCKQUOTE> |
---|
587 | <P>Crea un nuovo oggetto `GtkListItem'. Il nuovo widget viene restituito |
---|
588 | sottoforma di un puntatore ad un oggetto `GtkWidget'. In caso di |
---|
589 | fallimento, viene restituito `NULL'. |
---|
590 | <P> |
---|
591 | <BLOCKQUOTE><CODE> |
---|
592 | <PRE> |
---|
593 | GtkWidget* gtk_list_item_new_with_label (gchar *LABEL) |
---|
594 | </PRE> |
---|
595 | </CODE></BLOCKQUOTE> |
---|
596 | <P>Cre un nuovo oggetto `GtkListItem', avente come unico figlio |
---|
597 | un GtkLabel. Il nuovo widget viene restituito |
---|
598 | sottoforma di un puntatore ad un oggetto `GtkWidget'. In caso di |
---|
599 | fallimento, viene restituito `NULL'. |
---|
600 | <P> |
---|
601 | <BLOCKQUOTE><CODE> |
---|
602 | <PRE> |
---|
603 | void gtk_list_item_select (GtkListItem *LIST_ITEM) |
---|
604 | </PRE> |
---|
605 | </CODE></BLOCKQUOTE> |
---|
606 | <P>Questa funzione è essenzialmente un wrapper per una chiamata a |
---|
607 | gtk_item_select (GTK_ITEM (list_item)) che emetterà il segnale |
---|
608 | select. |
---|
609 | Vedere GtkItem:: per maggiori informazioni. |
---|
610 | <P> |
---|
611 | <BLOCKQUOTE><CODE> |
---|
612 | <PRE> |
---|
613 | void gtk_list_item_deselect (GtkListItem *LIST_ITEM) |
---|
614 | </PRE> |
---|
615 | </CODE></BLOCKQUOTE> |
---|
616 | <P>Questa funzione è essenzialmente un wrapper per una chiamata a |
---|
617 | gtk_item_deselect (GTK_ITEM (list_item)) che emetterà il segnale |
---|
618 | deselect. |
---|
619 | Vedere GtkItem:: per maggiori informazioni. |
---|
620 | <P> |
---|
621 | <BLOCKQUOTE><CODE> |
---|
622 | <PRE> |
---|
623 | GtkListItem* GTK_LIST_ITEM (gpointer OBJ) |
---|
624 | </PRE> |
---|
625 | </CODE></BLOCKQUOTE> |
---|
626 | <P>Effettua il cast di un puntatore generico a `GtkListItem*'. Vedere |
---|
627 | Standard Macros:: per maggiorni informazioni. |
---|
628 | <P> |
---|
629 | <BLOCKQUOTE><CODE> |
---|
630 | <PRE> |
---|
631 | GtkListItemClass* GTK_LIST_ITEM_CLASS (gpointer CLASS) |
---|
632 | </PRE> |
---|
633 | </CODE></BLOCKQUOTE> |
---|
634 | <P>Effettua il cast di un puntatore generico a `GtkListItemClass*'. Vedere |
---|
635 | Standard Macros:: per maggiorni informazioni. |
---|
636 | <P> |
---|
637 | <BLOCKQUOTE><CODE> |
---|
638 | <PRE> |
---|
639 | gint GTK_IS_LIST_ITEM (gpointer OBJ) |
---|
640 | </PRE> |
---|
641 | </CODE></BLOCKQUOTE> |
---|
642 | <P>Determina se un puntatore generico si riferisce ad un oggetto |
---|
643 | `GtkListItem'. Vedere Standard Macros:: per maggiorni informazioni. |
---|
644 | <P> |
---|
645 | <H2><A NAME="ss9.7">9.7 Esempio</A> |
---|
646 | </H2> |
---|
647 | |
---|
648 | <P>Come esempio su questo argomento, si veda quello relativo alla GtkList, |
---|
649 | che riguarda anche l'uso del GtkListItem. |
---|
650 | <P> |
---|
651 | <HR NOSHADE> |
---|
652 | <A HREF="gtk_tut_it-10.html">Avanti</A> |
---|
653 | <A HREF="gtk_tut_it-8.html">Indietro</A> |
---|
654 | <A HREF="gtk_tut_it.html#toc9">Indice</A> |
---|
655 | </BODY> |
---|
656 | </HTML> |
---|