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

Revision 14482, 21.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: 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
18devono essere di tipo GtkListItem.
19<P>Un widget GtkList possiede una sua propria finestra per ricevere eventi
20e un suo proprio colore di sfondo che di solito &egrave; bianco. Dal momento
21che &egrave; direttamente derivato dal widget GtkContainer, pu&ograve; essere trattato
22come tale usando la macro GTK_CONTAINER(List); si veda il widget GtkContainer
23per ulteriori dettagli.
24Per usare il widget GtkList in tutte le sue potenzialit&agrave;, si dovrebbe essere
25gi&agrave; familiari con l'uso della GList e delle relative funzioni g_list_*().
26<P>All'interno della definizione della struttura del widget GtkList c'&egrave; un
27campo che sar&agrave; per noi di grande interesse, cio&egrave;:
28<P>
29<BLOCKQUOTE><CODE>
30<PRE>
31struct _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
41gli elementi che sono selezionati correntemente, oppure a NULL se la
42selezione &egrave; vuota. Quindi, per avere informazioni sulla selezione corrente,
43leggiamo il campo GTK_LIST()->selection, senza per&ograve; modificarlo dal momento
44che i campi interni debbono essere gestiti dalle funzioni gtk_list_*().
45<P>Le modalit&agrave; di selezione in una GtkList, e quindi il contenuto di
46GTK_LIST()->selection, sono determinate dal campo selection_mode:
47<P>selection_mode pu&ograve; assumere uno dei seguenti valori:
48<UL>
49<LI> GTK_SELECTION_SINGLE - La selezione pu&ograve; essere o NULL oppure
50un puntatore GList* per un singolo elemento
51selezionato.
52</LI>
53<LI> GTK_SELECTION_BROWSE - La selezione &egrave; null se la lista non contiene
54alcun widget o se ha solo widget non sensibili,
55oppure pu&ograve; contenere un puntatore a una struttura
56GList, e quindi esattamente un elemento di lista.
57</LI>
58<LI> GTK_SELECTION_MULTIPLE - La selezione &egrave; ``NULL'' se non &egrave; selezionato
59alcun elemento di lista, oppure un puntatore GList al
60primo elemento selezionato. Quello, a sua volta, punta
61a una struttura GList per il secondo elemento selezionato
62e cos&igrave; via.
63</LI>
64<LI> GTK_SELECTION_EXTENDED - La selezione &egrave; sempre NULL.</LI>
65</UL>
66<P>Il valore per difetto &egrave;  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>
74void selection_changed (GtkList *LIST)
75</PRE>
76</CODE></BLOCKQUOTE>
77<P>Questo segnale verr&agrave; invocato ogni volta che il campo di
78selezione di una GtkList &egrave; cambiato. Questo accade quando
79un figlio della GtkList viene selezionato o deselezionato.
80<P>
81<BLOCKQUOTE><CODE>
82<PRE>
83void select_child (GtkList *LIST, GtkWidget *CHILD)
84</PRE>
85</CODE></BLOCKQUOTE>
86<P>Questo segnale viene invocato quando un fuglio di una GtkList
87sta per essere selezionato. Questo accade principalmente in
88occasione di chiamate a gtk_list_select_item() e gtk_list_select_child(),
89di pressioni di bottoni e a volte pu&ograve; venir fatto scattare indirettamente
90in altre occasioni, in cui vengono aggiunti o rimossi dei figli
91dalla GtkList.
92<P>
93<BLOCKQUOTE><CODE>
94<PRE>
95void unselect_child (GtkList *LIST, GtkWidget *CHILD)
96</PRE>
97</CODE></BLOCKQUOTE>
98<P>Questo segnale viene invocato quando un figlio della GtkList sta
99per essere deselezionato. Ci&ograve; accade principalmente in occasione
100di chiamate a gtk_list_unselect_item() e gtk_list_unselect_child(),
101di pressioni di bottoni, e a volte pu&ograve; venir fatto scattare indirettamente
102in altre occasioni, in cui vengono aggiunti o rimossi dei figli
103dalla GtkList.
104<P>
105<H2><A NAME="ss9.2">9.2 Funzioni</A>
106</H2>
107
108<P>
109<BLOCKQUOTE><CODE>
110<PRE>
111guint 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>
118GtkWidget* gtk_list_new (void)
119</PRE>
120</CODE></BLOCKQUOTE>
121<P>Crea un nuovo oggetto `GtkList'. Il nuovo widget viene
122restituito sotto forma di un puntoatore ad un oggetto
123`GtkWidget&igrave;'. In caso di fallimento, viene ritornato NULL.
124<P>
125<BLOCKQUOTE><CODE>
126<PRE>
127void 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
131POSITION. ITEMS ITEMS &egrave; una lista doppiamente collegata, in
132cui ci si aspetta che i puntatori di ogni nodo puntino a
133un GtkListItem appena creato. I nodi GList di ITEMS vengono
134assunti dalla LIST.
135<P>
136<BLOCKQUOTE><CODE>
137<PRE>
138void 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(),
142ma alla fine della LIST. I nodi GList di ITEMS vengono
143assunti dalla LIST.
144<P>
145<BLOCKQUOTE><CODE>
146<PRE>
147void 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(),
151ma al principio della LIST. I nodi GList di ITEMS vengono
152assunti dalla LIST.
153<P>
154<BLOCKQUOTE><CODE>
155<PRE>
156void gtk_list_remove_items (GtkList *LIST, GList *ITEMS)
157</PRE>
158</CODE></BLOCKQUOTE>
159<P>Rimuove degli elementi di lista dalla LIST. ITEMS &egrave; una lista
160doppiamente collegata in cui ci si aspetta che i puntatori di
161ogni nodo puntino a un figlio diretto di LIST. E' poi responsabilit&agrave;
162del chiamante di fare una chiamata a g_list_free(ITEMS). E' anche
163necessario che il chiamante distrugga lui stesso gli elementi della
164lista.
165<P>
166<BLOCKQUOTE><CODE>
167<PRE>
168void 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 &egrave;
172interessato se la sua posizione corrente all'interno di LIST &egrave; compreso
173fra START ed END.
174<P>
175<BLOCKQUOTE><CODE>
176<PRE>
177void 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
181specificato dalla sua posizione corrente all'interno di LIST.
182<P>
183<BLOCKQUOTE><CODE>
184<PRE>
185void 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
189specificato dalla sua posizione corrente all'interno di LIST.
190<P>
191<BLOCKQUOTE><CODE>
192<PRE>
193void 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>
200void 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>
207gint 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,
211viene restituito `-1'.
212<P>
213<BLOCKQUOTE><CODE>
214<PRE>
215void 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&ograve; essere uno fra
219GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE o
220GTK_SELECTION_EXTENDED.
221<P>
222<BLOCKQUOTE><CODE>
223<PRE>
224GtkList* GTK_LIST (gpointer OBJ)
225</PRE>
226</CODE></BLOCKQUOTE>
227<P>Fa il cast di un generico puntatore a `GtkList*'. Per maggiori
228informazioni vedere Standard Macros::.
229<P>
230<BLOCKQUOTE><CODE>
231<PRE>
232GtkListClass* GTK_LIST_CLASS (gpointer CLASS)
233</PRE>
234</CODE></BLOCKQUOTE>
235<P>Fa il cast di un generico puntatore a `GtkListClass*'. Per maggiori
236informazioni vedere Standard Macros::.
237<P>
238<BLOCKQUOTE><CODE>
239<PRE>
240gint GTK_IS_LIST (gpointer OBJ)
241</PRE>
242</CODE></BLOCKQUOTE>
243<P>Determina se un generico puntatore si riferisce ad un oggetto `GtkList'.
244Per 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&agrave; i campbiamenti
250della selezione di una GtkList, e vi lascia ``imprigionare'' gli elementi
251di 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        &lt;gtk/gtk.h>
261#include        &lt;stdio.h>
262
263/* Questa e' la nostra stringa di identificazione dei dati per assegnarli
264 * ad elementi di lista
265 */
266const   gchar   *list_item_data_key="list_item_data";
267
268
269/* prototipi per i gestori di segnale che connetteremo
270 * al widget GtkList
271 */
272static  void    sigh_print_selection    (GtkWidget      *gtklist,
273                                         gpointer       func_data);
274static  void    sigh_button_event       (GtkWidget      *gtklist,
275                                         GdkEventButton *event,
276                                         GtkWidget      *frame);
277
278
279/* funzione main per predisporre l'interfaccia utente */
280
281gint 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(&amp;argc, &amp;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 &egrave; 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&lt;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), &amp;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&lt;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 */
439void
440sigh_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 &amp;&amp;
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 */
500void
501sigh_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 &egrave; progettato allo scopo di essere un contenitore
547collegato ad un figlio, per fornire le funzioni per la selezione e deselezione
548allo 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
550proprio colore di sfondo, che di solito &egrave; bianco.
551<P>Dal momento che questo widget deriva direttamente da GtkItem, pu&ograve; essere
552trattato come tale usando la macro GTK_ITEM(ListItem), vedere il widget
553GtkItem per ulteriori informazioni.
554Di solito un GtkListItem ha solo un'etichetta per identificare per esempio
555un nome di file all'interno di una GtkList -- per cui viene fornita la
556funzione appropriata gtk_list_item_new_with_label(). Si pu&ograve; ottenere lo
557stesso effetto creando una GtkLabel da sola, assegnando al suo allineamento
558i valori xalign=0 e yalign=0.5, aggiungendo successivamente un contenitore
559alla GtkListItem.
560<P>Dal momento che non si &egrave; obbligati a mettere una GtkLabel, si pu&ograve; anche
561aggiungere 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
568i 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>
577guint 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>
584GtkWidget* gtk_list_item_new (void)
585</PRE>
586</CODE></BLOCKQUOTE>
587<P>Crea un nuovo oggetto `GtkListItem'. Il nuovo widget viene restituito
588sottoforma di un puntatore ad un oggetto `GtkWidget'. In caso di
589fallimento, viene restituito `NULL'.
590<P>
591<BLOCKQUOTE><CODE>
592<PRE>
593GtkWidget* gtk_list_item_new_with_label (gchar *LABEL)
594</PRE>
595</CODE></BLOCKQUOTE>
596<P>Cre un nuovo oggetto `GtkListItem', avente come unico figlio
597un GtkLabel.  Il nuovo widget viene restituito
598sottoforma di un puntatore ad un oggetto `GtkWidget'. In caso di
599fallimento, viene restituito `NULL'.
600<P>
601<BLOCKQUOTE><CODE>
602<PRE>
603void gtk_list_item_select (GtkListItem *LIST_ITEM)
604</PRE>
605</CODE></BLOCKQUOTE>
606<P>Questa funzione &egrave; essenzialmente un wrapper per una chiamata a
607gtk_item_select (GTK_ITEM (list_item)) che emetter&agrave; il segnale
608select.
609Vedere GtkItem:: per maggiori informazioni.
610<P>
611<BLOCKQUOTE><CODE>
612<PRE>
613void gtk_list_item_deselect (GtkListItem *LIST_ITEM)
614</PRE>
615</CODE></BLOCKQUOTE>
616<P>Questa funzione &egrave; essenzialmente un wrapper per una chiamata a
617gtk_item_deselect (GTK_ITEM (list_item)) che emetter&agrave; il segnale
618deselect.
619Vedere GtkItem:: per maggiori informazioni.
620<P>
621<BLOCKQUOTE><CODE>
622<PRE>
623GtkListItem* GTK_LIST_ITEM (gpointer OBJ)
624</PRE>
625</CODE></BLOCKQUOTE>
626<P>Effettua il cast di un puntatore generico a `GtkListItem*'. Vedere
627Standard Macros:: per maggiorni informazioni.
628<P>
629<BLOCKQUOTE><CODE>
630<PRE>
631GtkListItemClass* GTK_LIST_ITEM_CLASS (gpointer CLASS)
632</PRE>
633</CODE></BLOCKQUOTE>
634<P>Effettua il cast di un puntatore generico a `GtkListItemClass*'. Vedere
635Standard Macros:: per maggiorni informazioni.
636<P>
637<BLOCKQUOTE><CODE>
638<PRE>
639gint 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,
649che 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>
Note: See TracBrowser for help on using the repository browser.