📄 gtk_tut_it-10.html
字号:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><HTML><HEAD> <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.9"> <TITLE>GTK Tutorial: Il Widget Menù (Menu Widgets)</TITLE> <LINK HREF="gtk_tut_it-11.html" REL=next> <LINK HREF="gtk_tut_it-9.html" REL=previous> <LINK HREF="gtk_tut_it.html#toc10" REL=contents></HEAD><BODY BGCOLOR="#FFFFFF"><A HREF="gtk_tut_it-11.html">Avanti</A><A HREF="gtk_tut_it-9.html">Indietro</A><A HREF="gtk_tut_it.html#toc10">Indice</A><HR NOSHADE><H2><A NAME="s10">10. Il Widget Menù (Menu Widgets)</A></H2><P>Ci sono due modi per creare dei menù, quello facile e quello difficile.Ognuno è più adatto per certe circostanze, ma di solito si può usare ilmodo semplice, cioé menu_factory (la ``fabbrica dei menù''). Il modo ``difficile'' è di crearsi tutti i menù usando direttamente le chiamate.Quello semplice è di usare le chiamate di tipo gtk_menu_factory. Anche seè un modo molto più semplice, ci sono svantaggi e vantaggi per ciascunodei due approcci.<P>La menu_factory è molto più semplice da usare e per aggiungere dei nuovimenù, anche se scriversi un po' di funzioni per creare dei menù con ilmetodo manuale può dare risultati molto migliori dal punto di vista dell'usabilità. Con la menufactory, non è possibile mettere immagini ocaratteri '/' nei menù.<P><H2><A NAME="ss10.1">10.1 Creazione Manuale di Menù</A></H2><P>Seguendo la tradizionale arte dell'insegnamento, partiamo dal mododifficile. <CODE>:)</CODE><P>I widget che hanno a che fare con la creazione di una barra di menù e di sottomenù sono tre:<UL><LI>un elemento di menù, che \ quello che l'utente poi selezionerà, per esempio 'Salva'</LI><LI>un menù, che fa la parte di contenitore per gli elementi di menù, e</LI><LI>una barra dei menù, che è un contenitore per ciascuno dei menù</LI></UL><P><P>La cosa viene un po' complicata dal fatto che i widget elemento di menù vngono usati per<P>due scopi diversi. Essi sono sia i widget che vengono impacchettati nei menù, che <P>quelli che vengono impacchettati nella barra dei menù che, quando selezonati, attivano i menù.<P>Diamo un'occhiata alle funzioni usate per creare i menù e le barre di menù.Con questa prima funzione si crea un nuova barra di menù:<P><P><BLOCKQUOTE><CODE><PRE>GtkWidget *gtk_menu_bar_new(void);</PRE></CODE></BLOCKQUOTE><P>Questa funzione crea una nuova barra di menù. Per impacchettarla in unafinestra o si usa la funzione gtk_container_add, oppure, per impacchettarlain una scatola, le funzioni box_pack - come con i bottoni.<P><BLOCKQUOTE><CODE><PRE>GtkWidget *gtk_menu_new();</PRE></CODE></BLOCKQUOTE><P>Questa funzione restituisce un puntatore ad un nuovo menù, non viene mairealmente mostrato (con gtk_widget_show), serve solo per contenere glielementi del menù. Spero che il tutto risulti più chiaro quando daremoun'occhiata all'esempio più sotto.<P>Le prossime due chiamate sono usate per creare degli elementi che poivengono impacchettati nei menù e nelle barre dei menù..<P><BLOCKQUOTE><CODE><PRE>GtkWidget *gtk_menu_item_new();</PRE></CODE></BLOCKQUOTE><P>e<P><BLOCKQUOTE><CODE><PRE>GtkWidget *gtk_menu_item_new_with_label(const char *label);</PRE></CODE></BLOCKQUOTE><P>Queste chiamate sono usate per creare gli elementi di menù che devono poi essere mostrati.Ricordate la differenza che esiste fra un ``menù'' come quelli creati congtk_menu_new e un ``elemento di menù'' (menu item) come quelli creati conla funzione gtk_menu_item_new. L'elemento di menù sarà un bottonevero e proprio con una azione associata, mentre un menù è solo un contenitore che li raccoglie.Le funzioni gtk_menu_new_with_label e gtk_menu_new sono esattamente come vi aspettereste che siano dopo<P>aver conosciuto i bottoni. Una crea un nuovo elemento di menù con un'etichetta già impacchettata,<P>mentre l'altra crea un elemento di menù vuoto.<P><P>Una volta che si \ creato un elemento di menù, è necessario piazzarlo su di un menù.<P>Per fare ciò si usa la funzione gtk_menu_append. Per determinare quando l'utente ha selezionato un elemento, abbiamo bisogno di connettere il segnale <CODE>activate</CODE> nel solito modo.<P>Quindi, se volessimo creare un normale menù <CODE>File</CODE>, con le opzioni <CODE>Open</CODE>, <CODE>Save</CODE> e <CODE>Quit</CODE>, il codice avrebbe più o meno il seguente aspetto:<P><BLOCKQUOTE><CODE><PRE>file_menu = gtk_menu_new(); /* Non e' necessario mostrare i menu' *//* Creiamo gli elementi del menu' */open_item = gtk_menu_item_new_with_label("Open");save_item = gtk_menu_item_new_with_label("Save");quit_item = gtk_menu_item_new_with_label("Quit");/* Aggiungiamoli al menu' */gtk_menu_append( GTK_MENU(file_menu), open_item);gtk_menu_append( GTK_MENU(file_menu), save_item);gtk_menu_append( GTK_MENU(file_menu), quit_item);/* Colleghiamo le funzioni di callback al segnale activate */gtk_signal_connect_object( GTK_OBJECT(open_items), "activate", GTK_SIGNAL_FUNC(menuitem_response), (gpointer) "file.open");gtk_signal_connect_object( GTK_OBJECT(save_items), "activate", GTK_SIGNAL_FUNC(menuitem_response), (gpointer) "file.save");/* Possiamo collegare l'elemento Quit alla nostra funzione di uscita */gtk_signal_connect_object( GTK_OBJECT(quit_items), "activate", GTK_SIGNAL_FUNC(destroy), (gpointer) "file.quit");/* Abbiamo bisogno di mostrare gli elementi di menu' */gtk_widget_show( open_item );gtk_widget_show( save_item );gtk_widget_show( quit_item ); </PRE></CODE></BLOCKQUOTE><P><P>A questo punto abbiamo il nostro menù Adesso abbiamo bisogno di creare una barra dei menù<P>e un elemento di menù per <CODE>File</CODE>, a cui aggiungeremo il nostro menù. Il codice è questo:<P><P><BLOCKQUOTE><CODE><PRE>menu_bar = gtk_menu_bar_new();gtk_container_add( GTK_CONTAINER(window), menu_bar);gtk_widget_show( menu_bar );file_item = gtk_menu_item_new_with_label("File");gtk_widget_show(file_item);</PRE></CODE></BLOCKQUOTE><P><P>Ora dobbiamo associare il menù con <CODE>file_item</CODE>. Lo si può fare con la funzione<P><BLOCKQUOTE><CODE>void gtk_menu_item_set_submenu( GtkMenuItem *menu_item,GtkWidget *submenu);</CODE></BLOCKQUOTE><P><P>Quindi, il nostro esempio continuerebbe con<P><BLOCKQUOTE><CODE><PRE>gtk_menu_item_set_submenu( GTK_MENU_ITEM(file_item), file_menu);</PRE></CODE></BLOCKQUOTE><P><P>Ciò che manca a questo punto è di collegare il menù alla barra, cosa che si può ottenere tramite la funzione<P><BLOCKQUOTE><CODE>void gtk_menu_bar_append( GtkMenuBar *menu_bar, GtkWidget *menu_item);</CODE></BLOCKQUOTE><P>che nel nostro caso è:<P><BLOCKQUOTE><CODE><PRE>gtk_menu_bar_append( GTK_MENU_BAR(menu_bar), file_item );</PRE></CODE></BLOCKQUOTE><P><P>Se volessimo il menù giustificato a dstra, come sono spesso i menù di aiuto, potremm<P>usare la seguente funzioe (di nuovo su <CODE>file_item</CODE> in questo esempio) prima di fare il collegamento alla barra.<P><P><BLOCKQUOTE><CODE><PRE>void gtk_menu_item_right_justify (GtkMenuItem *menu_item);</PRE></CODE></BLOCKQUOTE>Ecco un riassunto dei passi necessari per creare una barra con i relativi menù collegati:<P><UL><LI> Create un nuovo menù con gtk_menu_new()</LI><LI> Usate delle chiamate multiple a gtk_menu_item_new() per ognuno deglielementi che volete mettere nel vostro menù. Usate inoltre gtk_menu_item_append()per mettere ciascuno di questi nuovi elementi sul menù..</LI><LI> Create un elemento di menù usando gtk_menu_item_new(). Questo rappresenta l'elemento di base delmenù, e il testo relativo sarà il testo mostrato sulla barra dei menù stessa.</LI><LI> Usate gtk_menu_item_set_submenu() per collegare i menù all'elemento base del menù (cioè quello creato al passaggio precedente).</LI><LI> Create una nuova barra di menù usando gtk_menu_bar_new. Questo passonecessita di essere effettuato una sola volta quando si crea una serie dimenù su una sola barra.</LI><LI> Usate gtk_menu_bar_append per mettere il menù base sulla barra dei menù.</LI></UL><P>Creare un menù a comparsa è più o meno la stessa cosa. La differenza è che ilil menù non viene attivato ``automaticamente'' da una barra, bensì per esempiocon la chiamata espicita alla funzione gtk_menu_popup() da parte di un evento di pressione di un pulsante.Seguite questi passaggi:<UL><LI>Create una funzione di gestione di un evento. Essa deve seguire il prototipo<BLOCKQUOTE><CODE>static gint handler(GtkWidget *widget, GdkEvent *event);</CODE></BLOCKQUOTE>e usare l'evento per scoprire dove il menu deve essere fatto comparire.</LI><LI>Nel gestore di evento, se questo è la pressione di un bottone, trattate<CODE>event</CODE> come l'evento relativo ad un bottone (cosa che in effetti è)e usatelo come mostrato nel codice di esempio per passare informazioni agtk_menu_popup().</LI><LI>Collegate il gestore di evento a un widget con<BLOCKQUOTE><CODE>gtk_signal_connect_object(GTK_OBJECT(widget), "event",GTK_SIGNAL_FUNC (handler), GTK_OBJECT(menu));</CODE></BLOCKQUOTE>in cui <CODE>widget</CODE> è il widget a cui state effettuando il collegamento, e<CODE>handler</CODE> è la funzione di gestione, mentre <CODE>menu</CODE> è un menùcreato con gtk_menu_new(). Quest'ultimo può essere un menù che viene ancheattivato da una barra di menù, come mostrato nel codice di esempio.</LI></UL><P><P><H2><A NAME="ss10.2">10.2 Esempio di Menù Manuale</A></H2><P>Per la teoria dovrebbe essere abbastanza. Diamo un'occhiata ad un esempio checi aiuti a chiarire le cose.<P><BLOCKQUOTE><CODE><PRE>/* menu.c */#include <gtk/gtk.h>static gint button_press (GtkWidget *, GdkEvent *);static void menuitem_response (gchar *);int main (int argc, char *argv[]){ GtkWidget *window; GtkWidget *menu; GtkWidget *menu_bar; GtkWidget *root_menu; GtkWidget *menu_items; GtkWidget *vbox; GtkWidget *button; char buf[128]; int i; gtk_init (&argc, &argv); /* crea una nuova finestra */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_usize( GTK_WIDGET (window), 200, 100); gtk_window_set_title(GTK_WINDOW (window), "GTK Menu Test"); gtk_signal_connect(GTK_OBJECT (window), "delete_event", (GtkSignalFunc) gtk_main_quit, NULL); /* Inizializziamo il menù, e ricordate: mai applicare * gtk_show_widget() al widget menù!! * Questo è il menù che contiene gli elementi, quello che * spunta quando si fa click sul "Menù radice" nell'applicazione */ menu = gtk_menu_new(); /* Ora creiamo un ciclo che crea tre elementi di menu per "test-menu". * Notete la chiamata a gtk_menu_append. In questo punto aggiungiamo una * lista di elementi al nostro menù. Normalmente, dovremmo poi catturare * il segnale di attivazione per ognuno degli elementi del menu, e creare * una funzione di ritorno per ciascuno di essi, ma qui non li mettiamo per * brevità. */ for(i = 0; i < 3; i++) { /* Copia i nomi in buf. */ sprintf(buf, "Test-undermenu - %d", i); /* Crea un nuovo elemento di menù con un nome... */ menu_items = gtk_menu_item_new_with_label(buf); /* ...e aggiungilo al menù. */ gtk_menu_append(GTK_MENU (menu), menu_items); /* Fa qualcosa di interessante quando si seleziona l'elemento */ gtk_signal_connect_object(GTK_OBJECT(menu_items), "activate", GTK_SIGNAL_FUNC(menuitem_response), (gpointer) g_strdup(buf)); /* Mostra il widget */ gtk_widget_show(menu_items); } /* Questo è il menù radice, e l'etichetta sarà il nome del menù che * verrà mostrato sulla barra dei menù. Non ci sarà alcun gestore di * segnale collegato, dal momento che non fa altro che mostrare il resto * del menù quando viene premuto. */ root_menu = gtk_menu_item_new_with_label("Root Menu"); gtk_widget_show(root_menu); /* Ora specifichiamo che vogliamo che il menù che abbiamo appena creato * sia il menù radice *// gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu); /* Una vbox in cui mettere un menù ed un bottone: */ vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); /* Crea una barra dei menù per metterci i menù e l'aggiunge alla finestra principale */ menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2); gtk_widget_show(menu_bar); /* Crea un bottone a cui collegare un menù */ button = gtk_button_new_with_label("press me"); gtk_signal_connect_object(GTK_OBJECT(button), "event", GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu)); gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2); gtk_widget_show(button); /* E finalmente attacchiamo l'elemento di menù alla barra dei menù -- questo * è l'elemento di menù "radice" di cui parlavo */ gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu); /* La finestra va mostrata sempre come ultimo passo in modo che sia già * completa di tutti i suoi elementi. */ gtk_widget_show(window); gtk_main (); return 0;}/* Risponde alla pressione di un bottone impostando un menù che * viene passato come widget.⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -