自学教程：C++ GTK_MENU函数代码示例

static gboolean on_button_release(G_GNUC_UNUSED GtkWidget * widget, GdkEventButton * event,		G_GNUC_UNUSED gpointer user_data){	if (event->button == 3)	{		GtkTreeSelection *treesel;		GtkTreeModel *model;		GtkTreeIter iter;		treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(s_file_view));		if (!gtk_tree_selection_get_selected(treesel, &model, &iter))			return FALSE;		gtk_widget_set_sensitive(s_popup_menu.expand, gtk_tree_model_iter_has_child(model, &iter));		gtk_widget_set_sensitive(s_popup_menu.remove_external_dir, topmost_selected(model, &iter, FALSE));		gtk_menu_popup(GTK_MENU(s_popup_menu.widget), NULL, NULL, NULL, NULL,						event->button, event->time);		return TRUE;	}	return FALSE;}

/* Keep track of the last menu item selected. (For the purposes * of the option menu */intclip_GTK_MENUGETACTIVE(ClipMachine * ClipMachineMemory){   C_widget *cmnu = _fetch_cw_arg(ClipMachineMemory);   GtkWidget *item;   C_widget *citem;   CHECKCWID(cmnu, GTK_IS_MENU);   item = gtk_menu_get_active(GTK_MENU(cmnu->widget));   citem = _list_get_cwidget(ClipMachineMemory, item);   if (!citem)      citem = _register_widget(ClipMachineMemory, item, NULL);   if (citem)    {       ClipVar  *ret = RETPTR(ClipMachineMemory);       _clip_mclone(ClipMachineMemory, ret, &citem->obj);    }   return 0; err:   return 1;}

voidpanel_menu_button_set_menu_path (PanelMenuButton *button,				 const char      *menu_uri){	const char *menu_path;	char       *scheme;	g_return_if_fail (PANEL_IS_MENU_BUTTON (button));	scheme    = NULL;	menu_path = split_menu_uri (menu_uri, &scheme);	if (!scheme)		return;	button->priv->path_root = panel_menu_scheme_to_path_root (scheme);	g_free (scheme);	if (!button->priv->menu_path && (!menu_path || !menu_path [0]))		return;	if (button->priv->menu_path && menu_path &&	    !strcmp (button->priv->menu_path, menu_path))		return;	g_free (button->priv->menu_path);	button->priv->menu_path = NULL;	button->priv->menu_path = g_strdup (menu_path);	if (button->priv->menu)		gtk_menu_detach (GTK_MENU (button->priv->menu));	button->priv->menu = NULL;	panel_menu_button_set_icon (button);}

void wxFrame::AttachMenuBar( wxMenuBar *menuBar ){    wxFrameBase::AttachMenuBar(menuBar);    if (m_frameMenuBar)    {#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2        hildon_window_set_menu(HILDON_WINDOW(m_widget),                               GTK_MENU(m_frameMenuBar->m_menubar));#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2        m_frameMenuBar->SetParent(this);        // menubar goes into top of vbox (m_mainWidget)        gtk_box_pack_start(            GTK_BOX(m_mainWidget), menuBar->m_widget, false, false, 0);        gtk_box_reorder_child(GTK_BOX(m_mainWidget), menuBar->m_widget, 0);        // disconnect wxWindowGTK "size_request" handler,        // it interferes with sizing of detached GtkHandleBox        gulong handler_id = g_signal_handler_find(            menuBar->m_widget,            GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),            g_signal_lookup("size_request", GTK_TYPE_WIDGET),            0, NULL, NULL, menuBar);        if (handler_id != 0)            g_signal_handler_disconnect(menuBar->m_widget, handler_id);        // reset size request to allow native sizing to work        gtk_widget_set_size_request(menuBar->m_widget, -1, -1);        gtk_widget_show( m_frameMenuBar->m_widget );#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2    }    // make sure next size_allocate causes a wxSizeEvent    m_oldClientWidth = 0;}

voidglade_popup_simple_pop (GladeProject *project, GdkEventButton *event){  GtkWidget *popup_menu;  gint button;  gint event_time;  popup_menu = glade_popup_create_menu (NULL, NULL, project, FALSE);  if (!popup_menu)    return;  if (event)    {      button = event->button;      event_time = event->time;    }  else    {      button = 0;      event_time = gtk_get_current_event_time ();    }  gtk_menu_popup (GTK_MENU (popup_menu), NULL, NULL,                  NULL, NULL, button, event_time);}

void on_trayicon_menu (GtkStatusIcon *status_icon,		       guint          button,		       guint          activate_time,		       gpointer       user_data){  GromitData *data = (GromitData *) user_data;  if(data->debug)    g_printerr("DEBUG: trayicon menu popup/n");  /* create the menu */  GtkWidget *menu = gtk_menu_new ();  /* Create the menu items */  //TODO option menu  GtkWidget* sep_item = gtk_separator_menu_item_new();  GtkWidget* quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);  /* Add them to the menu */  gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep_item);  gtk_menu_shell_append (GTK_MENU_SHELL (menu), quit_item);  /* Attach the callback functions to the respective activate signal */  g_signal_connect(G_OBJECT (quit_item), "activate",		   G_CALLBACK (gtk_main_quit),		   NULL);  /* We do need to show menu items */  gtk_widget_show (sep_item);  gtk_widget_show (quit_item);  /* show menu */  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,                  0, gtk_get_current_event_time());}

static gboolean select_verse_button_press_callback(GtkWidget *widget,						   GdkEventButton *event,						   EDITOR *editor){	GtkWidget *menu;	menu =	    main_versekey_drop_down_verse_menu(editor->navbar, NB_EDITOR,					       NULL, editor);	if (!menu)		return 0;	g_signal_connect(menu, "deactivate",			 G_CALLBACK(menu_deactivate_callback), widget);	if ((event->type == GDK_BUTTON_PRESS) && event->button == 1) {		gtk_widget_grab_focus(widget);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),					     TRUE);		gtk_menu_popup(GTK_MENU(menu), NULL, NULL,			       menu_position_under, widget, event->button,			       event->time);		return TRUE;	}	return FALSE;}

static GtkWidget *bmark_popup_menu(Tbfwin * bfwin, gboolean show_bmark_specific, gboolean show_file_specific) {	GtkWidget *menu, *menu_item;	menu = gtk_menu_new();	if (show_bmark_specific) {		menu_item = gtk_menu_item_new_with_label(_("Goto bookmark"));		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_goto_lcb),						 bfwin);		gtk_menu_append(GTK_MENU(menu), menu_item);			menu_item = gtk_separator_menu_item_new();		gtk_menu_append(GTK_MENU(menu), menu_item);			menu_item = gtk_menu_item_new_with_label(_("Edit"));		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_rename_lcb),						 bfwin);		gtk_menu_append(GTK_MENU(menu), menu_item);		menu_item = gtk_menu_item_new_with_label(_("Delete"));		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_del_lcb),						 bfwin);		gtk_menu_append(GTK_MENU(menu), menu_item);	}	if (show_file_specific) {		menu_item = gtk_menu_item_new_with_label(_("Delete all in document"));		g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_deldoc_lcb),						 bfwin);		gtk_menu_append(GTK_MENU(menu), menu_item);	}	menu_item = gtk_menu_item_new_with_label(_("Delete all"));	g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_delall_lcb),					 bfwin);	gtk_menu_append(GTK_MENU(menu), menu_item);	gtk_widget_show_all(menu);	g_signal_connect_after(G_OBJECT(menu), "destroy", G_CALLBACK(destroy_disposable_menu_cb), menu);	return menu;}

void ptt_menu_show(GtkWidget *button) {  ptt_menu_clear();  ptt_menu_update();  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0);}

static gboolean _on_click_item (GtkWidget *pWidget, GdkEventButton* pButton, CDQuickBrowserItem *pItem){	g_return_val_if_fail (pItem != NULL, FALSE);	GldiModuleInstance *myApplet = pItem->pApplet;	CD_APPLET_ENTER;	if (pButton->button == 3) // right click	{		gchar *cUri = g_filename_to_uri (pItem->cPath, NULL, NULL);		g_return_val_if_fail (cUri != NULL, FALSE);		GtkWidget *pMenu = gldi_menu_new (NULL);				GList *pApps = cairo_dock_fm_list_apps_for_file (cUri);		if (pApps != NULL)		{			GtkWidget *pSubMenu = CD_APPLET_ADD_SUB_MENU_WITH_IMAGE (D_("Open with"), pMenu, GLDI_ICON_NAME_OPEN);			cd_quick_browser_free_apps_list (myApplet);			GList *a;			gchar **pAppInfo;			gchar *cIconPath;			for (a = pApps; a != NULL; a = a->next)			{				pAppInfo = a->data;				if (pAppInfo[2] != NULL)					cIconPath = cairo_dock_search_icon_s_path (pAppInfo[2], cairo_dock_search_icon_size (GTK_ICON_SIZE_MENU));				else					cIconPath = NULL;				gpointer *data = g_new (gpointer, 2);				data[0] = pItem;				data[1] = pAppInfo[1];				myData.pAppList = g_list_prepend (myData.pAppList, data); // to save the exec command				CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (pAppInfo[0], cIconPath, _cd_launch_with, pSubMenu, data);				g_free (cIconPath);				g_free (pAppInfo[0]);				g_free (pAppInfo[2]);				g_free (pAppInfo);			}			g_list_free (pApps);		}		CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Open parent folder"), GLDI_ICON_NAME_DIRECTORY, _cd_open_parent, pMenu, pItem);				CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Copy the location"), GLDI_ICON_NAME_COPY, _cd_copy_location, pMenu, pItem);				gtk_widget_show_all (pMenu);		gtk_menu_popup (GTK_MENU (pMenu),			NULL,			NULL,			NULL,  // popup on mouse.			NULL,			1,			gtk_get_current_event_time ());		g_free (cUri);		CD_APPLET_LEAVE (TRUE); // do not remove quick_browser menu now	}	CD_APPLET_LEAVE (FALSE);}

nsSystemFontsGTK2::nsSystemFontsGTK2()  : mDefaultFontName(NS_LITERAL_STRING("sans-serif"))  , mButtonFontName(NS_LITERAL_STRING("sans-serif"))  , mFieldFontName(NS_LITERAL_STRING("sans-serif"))  , mMenuFontName(NS_LITERAL_STRING("sans-serif")){    InitPangoLib();    /*     * Much of the widget creation code here is similar to the code in     * nsLookAndFeel::InitColors().     */    // mDefaultFont    GtkWidget *label = gtk_label_new("M");    GtkWidget *parent = gtk_fixed_new();    GtkWidget *window = gtk_window_new(GTK_WINDOW_POPUP);    gtk_container_add(GTK_CONTAINER(parent), label);    gtk_container_add(GTK_CONTAINER(window), parent);    gtk_widget_ensure_style(label);    GetSystemFontInfo(label, &mDefaultFontName, &mDefaultFontStyle);    gtk_widget_destroy(window);  // no unref, windows are different    // mFieldFont    GtkWidget *entry = gtk_entry_new();    parent = gtk_fixed_new();    window = gtk_window_new(GTK_WINDOW_POPUP);    gtk_container_add(GTK_CONTAINER(parent), entry);    gtk_container_add(GTK_CONTAINER(window), parent);    gtk_widget_ensure_style(entry);    GetSystemFontInfo(entry, &mFieldFontName, &mFieldFontStyle);    gtk_widget_destroy(window);  // no unref, windows are different    // mMenuFont    GtkWidget *accel_label = gtk_accel_label_new("M");    GtkWidget *menuitem = gtk_menu_item_new();    GtkWidget *menu = gtk_menu_new();    g_object_ref_sink(GTK_OBJECT(menu));    gtk_container_add(GTK_CONTAINER(menuitem), accel_label);    gtk_menu_shell_append((GtkMenuShell *)GTK_MENU(menu), menuitem);    gtk_widget_ensure_style(accel_label);    GetSystemFontInfo(accel_label, &mMenuFontName, &mMenuFontStyle);    g_object_unref(menu);    // mButtonFont    parent = gtk_fixed_new();    GtkWidget *button = gtk_button_new();    label = gtk_label_new("M");    window = gtk_window_new(GTK_WINDOW_POPUP);              gtk_container_add(GTK_CONTAINER(button), label);    gtk_container_add(GTK_CONTAINER(parent), button);    gtk_container_add(GTK_CONTAINER(window), parent);    gtk_widget_ensure_style(label);    GetSystemFontInfo(label, &mButtonFontName, &mButtonFontStyle);    gtk_widget_destroy(window);  // no unref, windows are different}

void create_range_controls( void ){    GtkWidget *window;    GtkWidget *box1, *box2, *box3;    GtkWidget *button;    GtkWidget *scrollbar;    GtkWidget *separator;    GtkWidget *opt, *menu, *item;    GtkWidget *label;    GtkWidget *scale;    GtkObject *adj1, *adj2;    /* Standard window-creating stuff */    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);    gtk_signal_connect (GTK_OBJECT (window), "destroy",                        GTK_SIGNAL_FUNC(gtk_main_quit),                        NULL);    gtk_window_set_title (GTK_WINDOW (window), "range controls");    box1 = gtk_vbox_new (FALSE, 0);    gtk_container_add (GTK_CONTAINER (window), box1);    gtk_widget_show (box1);    box2 = gtk_hbox_new (FALSE, 10);    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);    gtk_widget_show (box2);    /* value, lower, upper, step_increment, page_increment, page_size */    /* Note that the page_size value only makes a difference for     * scrollbar widgets, and the highest value you'll get is actually     * (upper - page_size). */    adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);      vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));    scale_set_default_values (GTK_SCALE (vscale));    gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);    gtk_widget_show (vscale);    box3 = gtk_vbox_new (FALSE, 10);    gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);    gtk_widget_show (box3);    /* Reuse the same adjustment */    hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));    gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30);    scale_set_default_values (GTK_SCALE (hscale));    gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);    gtk_widget_show (hscale);    /* Reuse the same adjustment again */    scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));    /* Notice how this causes the scales to always be updated     * continuously when the scrollbar is moved */    gtk_range_set_update_policy (GTK_RANGE (scrollbar),                                  GTK_UPDATE_CONTINUOUS);    gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);    gtk_widget_show (scrollbar);    box2 = gtk_hbox_new (FALSE, 10);    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);    gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);    gtk_widget_show (box2);    /* A checkbutton to control whether the value is displayed or not */    button = gtk_check_button_new_with_label("Display value on scale widgets");    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);    gtk_signal_connect (GTK_OBJECT (button), "toggled",                        GTK_SIGNAL_FUNC(cb_draw_value), NULL);    gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);    gtk_widget_show (button);      box2 = gtk_hbox_new (FALSE, 10);    gtk_container_set_border_width (GTK_CONTAINER (box2), 10);    /* An option menu to change the position of the value */    label = gtk_label_new ("Scale Value Position:");    gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);    gtk_widget_show (label);      opt = gtk_option_menu_new();    menu = gtk_menu_new();    item = make_menu_item ("Top",                           GTK_SIGNAL_FUNC(cb_pos_menu_select),                           GINT_TO_POINTER (GTK_POS_TOP));    gtk_menu_append (GTK_MENU (menu), item);      item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select),                            GINT_TO_POINTER (GTK_POS_BOTTOM));    gtk_menu_append (GTK_MENU (menu), item);      item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select),                           GINT_TO_POINTER (GTK_POS_LEFT));    gtk_menu_append (GTK_MENU (menu), item);      item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select),                            GINT_TO_POINTER (GTK_POS_RIGHT));    gtk_menu_append (GTK_MENU (menu), item);  //.........这里部分代码省略.........

void tray_icon_on_menu(GtkStatusIcon *status_icon, guint button,         guint activate_time, gpointer user_data){    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, gtk_status_icon_position_menu, status_icon, button, activate_time);}

void PopupMenu::show(const IntRect& rect, FrameView* view, int index){    ASSERT(client());    if (!m_popup) {        m_popup = GTK_MENU(gtk_menu_new());#if GLIB_CHECK_VERSION(2,10,0)        g_object_ref_sink(G_OBJECT(m_popup));#else        g_object_ref(G_OBJECT(m_popup));        gtk_object_sink(GTK_OBJECT(m_popup));#endif        g_signal_connect(m_popup, "unmap", G_CALLBACK(menuUnmapped), this);    } else        gtk_container_foreach(GTK_CONTAINER(m_popup), reinterpret_cast<GtkCallback>(menuRemoveItem), this);    int x, y;    gdk_window_get_origin(GTK_WIDGET(view->containingWindow())->window, &x, &y);    m_menuPosition = view->contentsToWindow(rect.location());    m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height());    m_indexMap.clear();    const int size = client()->listSize();    for (int i = 0; i < size; ++i) {        GtkWidget* item;        if (client()->itemIsSeparator(i))            item = gtk_separator_menu_item_new();        else            item = gtk_menu_item_new_with_label(client()->itemText(i).utf8().data());        m_indexMap.add(item, i);        g_signal_connect(item, "activate", G_CALLBACK(menuItemActivated), this);        // FIXME: Apply the RenderStyle from client()->itemStyle(i)        gtk_widget_set_sensitive(item, client()->itemIsEnabled(i));        gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), item);        gtk_widget_show(item);    }    gtk_menu_set_active(m_popup, index);    // The size calls are directly copied from gtkcombobox.c which is LGPL    GtkRequisition requisition;    gtk_widget_set_size_request(GTK_WIDGET(m_popup), -1, -1);    gtk_widget_size_request(GTK_WIDGET(m_popup), &requisition);    gtk_widget_set_size_request(GTK_WIDGET(m_popup), MAX(rect.width(), requisition.width), -1);    GList* children = GTK_MENU_SHELL(m_popup)->children;    if (size)        for (int i = 0; i < size; i++) {            if (i > index)              break;            GtkWidget* item = reinterpret_cast<GtkWidget*>(children->data);            GtkRequisition itemRequisition;            gtk_widget_get_child_requisition(item, &itemRequisition);            m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height);            children = g_list_next(children);        }    else        // Center vertically the empty popup in the combo box area        m_menuPosition.setY(m_menuPosition.y() - rect.height() / 2);    gtk_menu_popup(m_popup, NULL, NULL, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time());}

//.........这里部分代码省略.........      screen_width = wnck_screen_get_width (screen);      screen_height = wnck_screen_get_height (screen);      if (window_x >= screen_width)        gtk_widget_show (priv->left_item);      else        gtk_widget_hide (priv->left_item);      if (window_x < viewport_width - screen_width)        gtk_widget_show (priv->right_item);      else        gtk_widget_hide (priv->right_item);      if (window_y >= screen_height)        gtk_widget_show (priv->up_item);      else        gtk_widget_hide (priv->up_item);      if (window_y < viewport_height - screen_height)        gtk_widget_show (priv->down_item);      else        gtk_widget_hide (priv->down_item);    }  else if (!viewport_mode && workspace && !wnck_window_is_pinned (priv->window))    {      if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_LEFT))        gtk_widget_show (priv->left_item);      else        gtk_widget_hide (priv->left_item);      if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_RIGHT))        gtk_widget_show (priv->right_item);      else        gtk_widget_hide (priv->right_item);      if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_UP))        gtk_widget_show (priv->up_item);      else        gtk_widget_hide (priv->up_item);      if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_DOWN))        gtk_widget_show (priv->down_item);      else        gtk_widget_hide (priv->down_item);    }  else    {      gtk_widget_hide (priv->left_item);      gtk_widget_hide (priv->right_item);      gtk_widget_hide (priv->up_item);      gtk_widget_hide (priv->down_item);    }  if (viewport_mode)    {      int viewport_width, viewport_height;      int screen_width, screen_height;      viewport_width = wnck_workspace_get_width (workspace);      viewport_height = wnck_workspace_get_height (workspace);      screen_width = wnck_screen_get_width (screen);      screen_height = wnck_screen_get_height (screen);      gtk_widget_show (priv->workspace_separator);      gtk_widget_show (priv->pin_item);      gtk_widget_show (priv->unpin_item);      if (viewport_width  >= 2 * screen_width ||          viewport_height >= 2 * screen_height)        {          gtk_widget_show (priv->workspace_item);          refill_submenu_viewport (menu);        }      else        {          gtk_widget_hide (priv->workspace_item);          gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));        }    }  else if (wnck_screen_get_workspace_count (screen) > 1)    {      gtk_widget_show (priv->workspace_separator);      gtk_widget_show (priv->pin_item);      gtk_widget_show (priv->unpin_item);      gtk_widget_show (priv->workspace_item);      refill_submenu_workspace (menu);    }  else    {      gtk_widget_hide (priv->workspace_separator);      gtk_widget_hide (priv->pin_item);      gtk_widget_hide (priv->unpin_item);      gtk_widget_hide (priv->workspace_item);      gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));    }  gtk_menu_reposition (GTK_MENU (menu));  return FALSE;}

LOCAL_SYMBOL MetaWindowMenu*meta_window_menu_new   (MetaFrames         *frames,                        MetaMenuOp          ops,                        MetaMenuOp          insensitive,                        Window              client_xwindow,                        unsigned long       active_workspace,                        int                 n_workspaces,                        MetaWindowMenuFunc  func,                        gpointer            data){  int i;  MetaWindowMenu *menu;  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */  if (n_workspaces < 2)    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);    menu = g_new (MetaWindowMenu, 1);  menu->frames = frames;  menu->client_xwindow = client_xwindow;  menu->func = func;  menu->data = data;  menu->ops = ops;  menu->insensitive = insensitive;      menu->menu = gtk_menu_new ();  gtk_menu_set_screen (GTK_MENU (menu->menu),                       gtk_widget_get_screen (GTK_WIDGET (frames)));  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)    {      MenuItem menuitem = menuitems[i];      if (ops & menuitem.op || menuitem.op == 0)        {          GtkWidget *mi;          MenuData *md;          unsigned int key;          MetaVirtualModifier mods;          mi = menu_item_new (&menuitem, -1);          /* Set the activeness of radiobuttons. */          switch (menuitem.op)            {            case META_MENU_OP_STICK:              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace == 0xFFFFFFFF);              break;            case META_MENU_OP_UNSTICK:              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace != 0xFFFFFFFF);              break;            default:              break;            }          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)            {              if (ops & META_MENU_OP_WORKSPACES)                {                  Display *display;                  Window xroot;                  GdkScreen *screen;                  GdkWindow *window;                  GtkWidget *submenu;                  int j;                  MenuItem to_another_workspace = {                    0, MENU_ITEM_NORMAL,                    NULL, FALSE,                    N_("Move to Another _Workspace")                  };                  meta_verbose ("Creating %d-workspace menu current space %lu/n",                      n_workspaces, active_workspace);                  window = gtk_widget_get_window (GTK_WIDGET (frames));                  display = GDK_WINDOW_XDISPLAY (window);                  screen = gdk_window_get_screen (window);                  xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));                  submenu = gtk_menu_new ();                  g_assert (mi==NULL);                  mi = menu_item_new (&to_another_workspace, -1);                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);                  for (j = 0; j < n_workspaces; j++)                    {                      char *label;                      MenuData *md;                      unsigned int key;                      MetaVirtualModifier mods;                      MenuItem moveitem;                      GtkWidget *submi;                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,                          j + 1,//.........这里部分代码省略.........

/** * @brief Instance initializer function for the /e GtkExperimentTranscript widget * * @param klass Newly constructed /e GtkExperimentTranscript instance */static voidgtk_experiment_transcript_init(GtkExperimentTranscript *klass){	GtkWidget *item, *submenu, *image;	klass->priv = GTK_EXPERIMENT_TRANSCRIPT_GET_PRIVATE(klass);	klass->speaker = NULL;	klass->interactive_format.default_font = NULL;	klass->interactive_format.default_text_color = NULL;	klass->interactive_format.default_bg_color = NULL;	klass->priv->flag_mask = 0;	klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0.,							  0., 0., 0.);	g_object_ref_sink(klass->priv->time_adjustment);	klass->priv->time_adj_on_value_changed_id =		g_signal_connect(G_OBJECT(klass->priv->time_adjustment),				 "value-changed",				 G_CALLBACK(time_adj_on_value_changed), klass);	klass->priv->layer_text = NULL;	klass->priv->layer_text_layout =		gtk_widget_create_pango_layout(GTK_WIDGET(klass), NULL);	pango_layout_set_wrap(klass->priv->layer_text_layout, PANGO_WRAP_WORD_CHAR);	pango_layout_set_ellipsize(klass->priv->layer_text_layout, PANGO_ELLIPSIZE_END);	klass->priv->backdrop.start = 0;	klass->priv->backdrop.end = 0;	klass->priv->contribs = NULL;	klass->priv->formats = NULL;	klass->priv->interactive_format.regexp = NULL;	klass->priv->interactive_format.attribs = NULL;	/** @todo It should be possible to reset font and colors (to widget defaults) */	klass->priv->menu = gtk_menu_new();	gtk_menu_attach_to_widget(GTK_MENU(klass->priv->menu),				  GTK_WIDGET(klass), NULL);	item = gtk_image_menu_item_new_with_mnemonic("Choose _Font...");	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_FONT,					 GTK_ICON_SIZE_MENU);	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);	g_signal_connect(item, "activate",			 G_CALLBACK(choose_font_activated), klass);	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);	gtk_widget_show(item);	item = gtk_image_menu_item_new_with_mnemonic("Choose _Text Color...");	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,					 GTK_ICON_SIZE_MENU);	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);	g_signal_connect(item, "activate",			 G_CALLBACK(choose_text_color_activated), klass);	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);	gtk_widget_show(item);	item = gtk_image_menu_item_new_with_mnemonic("Choose _Background Color...");	image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,					 GTK_ICON_SIZE_MENU);	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);	g_signal_connect(item, "activate",			 G_CALLBACK(choose_bg_color_activated), klass);	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);	gtk_widget_show(item);	submenu = gtk_menu_new();	item = gtk_menu_item_new_with_label("Text Alignment");	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);	gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);	gtk_widget_show(item);	/*	 * position in alignment_group list corresponds with PangoAlignment	 * (PANGO_ALIGN_RIGHT, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT)	 */	item = gtk_radio_menu_item_new_with_mnemonic(NULL, "_Left");	klass->priv->alignment_group =			gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));	g_signal_connect(item, "activate",			 G_CALLBACK(text_alignment_activated), klass);	gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);	item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,						     "_Center");	klass->priv->alignment_group =			gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));	g_signal_connect(item, "activate",			 G_CALLBACK(text_alignment_activated), klass);	gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);	item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,//.........这里部分代码省略.........

static voidrefill_submenu_viewport (WnckActionMenu *menu){  GtkWidget *submenu;  GList *children;  GList *l;  WnckScreen *screen;  WnckWorkspace *workspace;  int window_x, window_y;  int viewport_x, viewport_y;  int viewport_width, viewport_height;  int screen_width, screen_height;  int x, y;  int number;  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item));  /* Remove existing items */  children = gtk_container_get_children (GTK_CONTAINER (submenu));  for (l = children; l; l = l->next)    gtk_container_remove (GTK_CONTAINER (submenu), l->data);  g_list_free (children);  screen = wnck_window_get_screen (menu->priv->window);  workspace = wnck_screen_get_workspace (screen, 0);  wnck_window_get_geometry (menu->priv->window,                            &window_x, &window_y, NULL, NULL);  viewport_x = wnck_workspace_get_viewport_x (workspace);  viewport_y = wnck_workspace_get_viewport_y (workspace);  window_x += viewport_x;  window_y += viewport_y;  viewport_width = wnck_workspace_get_width (workspace);  viewport_height = wnck_workspace_get_height (workspace);  screen_width = wnck_screen_get_width (screen);  screen_height = wnck_screen_get_height (screen);  number = 1;  for (y = 0; y < viewport_height; y += screen_height)    {      char      *label;      GtkWidget *item;      for (x = 0; x < viewport_width; x += screen_width)        {          /* Keep this in sync with what is in get_workspace_name_with_accel()           */          if (number == 10)            label = g_strdup_printf (_("Workspace 1_0"));          else            label = g_strdup_printf (_("Workspace %s%d"),                                     number < 10 ? "_" : "",                                     number);          number++;          item = make_menu_item (MOVE_TO_WORKSPACE);          g_object_set_data (G_OBJECT (item), "viewport_x",                             GINT_TO_POINTER (x));          g_object_set_data (G_OBJECT (item), "viewport_y",                             GINT_TO_POINTER (y));          if (window_x >= x && window_x < x + screen_width &&              window_y >= y && window_y < y + screen_height)            gtk_widget_set_sensitive (item, FALSE);          gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);          set_item_text (item, label);          set_item_stock (item, NULL);          g_free (label);        }    }  gtk_menu_reposition (GTK_MENU (submenu));}

void tray_icon_on_click(GtkStatusIcon *status_icon,         gpointer user_data){    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, gtk_status_icon_position_menu, status_icon, 0, gtk_get_current_event_time());}

void WebPopupMenuProxyGtk::hidePopupMenu(){    gtk_menu_popdown(GTK_MENU(m_popup));    resetTypeAheadFindState();}

static gint button_press_map_cb(GtkWidget * area, GdkEventButton * event,				gpointer user_data){	GuiMap *gmap = user_data;	GtkWidget *menu;	const Hex *adjacent;	gboolean port_ok;	gint num_ports;	gint i;	if (area->window == NULL || gmap->map == NULL)		return FALSE;	if (event->button != 1)		return TRUE;	current_hex = guimap_find_hex(gmap, event->x, event->y);	if (current_hex == NULL)		return TRUE;	menu = NULL;	if (event->button == 1) {		MapElement element;		Node *current_node;		gint distance_node;		gint distance_hex;		current_node = guimap_find_node(gmap, event->x, event->y);		element.node = current_node;		distance_node =		    guimap_distance_cursor(gmap, &element, MAP_NODE,					   event->x, event->y);		element.hex = current_hex;		distance_hex =		    guimap_distance_cursor(gmap, &element, MAP_HEX,					   event->x, event->y);		if (distance_node < distance_hex) {			current_node->no_setup = !current_node->no_setup;			for (i = 0; i < G_N_ELEMENTS(current_node->hexes);			     i++) {				guimap_draw_hex(gmap,						current_node->hexes[i]);			}			return TRUE;		} else {			menu = terrain_menu;		}	} else if (current_hex->roll > 0) {		menu = roll_menu;		for (i = 2; i <= 12; i++) {			if (roll_numbers[i] != NULL)				gtk_check_menu_item_set_active				    (GTK_CHECK_MENU_ITEM(roll_numbers[i]),				     current_hex->roll == i);		}		gtk_check_menu_item_set_active(shuffle_tile,					       current_hex->shuffle);	} else if (current_hex->terrain == SEA_TERRAIN) {		num_ports = 0;		for (i = 0; i < 6; i++) {			adjacent = hex_in_direction(current_hex, i);			port_ok = FALSE;			if (adjacent != NULL &&			    adjacent->terrain != LAST_TERRAIN &&			    adjacent->terrain != SEA_TERRAIN) {				num_ports++;				if (current_hex->resource != NO_RESOURCE)					port_ok = TRUE;			}			gtk_widget_set_sensitive(port_directions[i],						 port_ok);			gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM						       (port_directions							[i]),						       current_hex->facing						       == i && port_ok);		}		if (num_ports > 0)			menu = port_menu;	}	if (menu != NULL)		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,			       event->button, event->time);	return TRUE;}

static voidtray_menu_cb (GtkWidget *widget, guint button, guint time, gpointer userdata){	static GtkWidget *menu;	GtkWidget *submenu;	GtkWidget *item;	int away_status;	/* ph may have an invalid context now */	hexchat_set_context (ph, hexchat_find_context (ph, NULL, NULL));	/* close any old menu */	if (G_IS_OBJECT (menu))	{		tray_menu_destroy (menu, NULL);	}	menu = gtk_menu_new ();	/*gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));*/	if (tray_get_window_status () == WS_HIDDEN)		tray_make_item (menu, _("_Restore Window"), tray_menu_restore_cb, NULL);	else		tray_make_item (menu, _("_Hide Window"), tray_menu_restore_cb, NULL);	tray_make_item (menu, NULL, tray_menu_quit_cb, NULL);#ifndef WIN32 /* submenus are buggy on win32 */	submenu = mg_submenu (menu, _("_Blink on"));	blink_item (&prefs.hex_input_tray_chans, submenu, _("Channel Message"));	blink_item (&prefs.hex_input_tray_priv, submenu, _("Private Message"));	blink_item (&prefs.hex_input_tray_hilight, submenu, _("Highlighted Message"));	/*blink_item (BIT_FILEOFFER, submenu, _("File Offer"));*/	submenu = mg_submenu (menu, _("_Change status"));#else /* so show away/back in main tray menu */	submenu = menu;#endif	away_status = tray_find_away_status ();	item = tray_make_item (submenu, _("_Away"), tray_foreach_server, "away");	if (away_status == 1)		gtk_widget_set_sensitive (item, FALSE);	item = tray_make_item (submenu, _("_Back"), tray_foreach_server, "back");	if (away_status == 2)		gtk_widget_set_sensitive (item, FALSE);	menu_add_plugin_items (menu, "/x5$TRAY", NULL);#ifdef WIN32	tray_make_item (menu, NULL, tray_menu_quit_cb, NULL);	mg_create_icon_item (_("_Preferences"), GTK_STOCK_PREFERENCES, menu, tray_menu_settings, NULL);#endif	tray_make_item (menu, NULL, tray_menu_quit_cb, NULL);	mg_create_icon_item (_("_Quit"), GTK_STOCK_QUIT, menu, tray_menu_quit_cb, NULL);	g_object_ref (menu);	g_object_ref_sink (menu);	g_object_unref (menu);	g_signal_connect (G_OBJECT (menu), "selection-done",							G_CALLBACK (tray_menu_destroy), NULL);#ifdef WIN32	g_signal_connect (G_OBJECT (menu), "leave-notify-event",							G_CALLBACK (tray_menu_left_cb), NULL);	g_signal_connect (G_OBJECT (menu), "enter-notify-event",							G_CALLBACK (tray_menu_enter_cb), NULL);	tray_menu_timer = g_timeout_add(500, (GSourceFunc) tray_check_hide, menu);#endif	gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL,						 userdata, button, time);}

static voidmenushell_build_children (GladeXML *xml, GtkWidget *w, 			  GladeWidgetInfo *info){    int i, j;    MateUIInfo infos[2] = {	{ MATE_APP_UI_ITEM },	MATEUIINFO_END    };    for (i = 0; i < info->n_children; i++) {	GladeChildInfo *cinfo = &info->children[i];	GladeWidgetInfo *cwinfo = cinfo->child;	GtkWidget *child;	gchar *stock_name = NULL;		for (j = 0; j < cwinfo->n_properties; j++) {	    if (!strcmp (cwinfo->properties[j].name, "stock_item")) {		stock_name = cwinfo->properties[j].value;		break;	    }	}	if (!stock_name) {	    /* this is a normal menu item */	    child = glade_xml_build_widget (xml, cwinfo);	    gtk_menu_shell_append (GTK_MENU_SHELL (w), child);	    continue;	}	/* load the template MateUIInfo for this item */	if (!get_stock_uiinfo (stock_name, &infos[0])) {	    /* failure ... */	    if (!strncmp (stock_name, "MATEUIINFO_", 12))		stock_name += 12;	    child = gtk_menu_item_new_with_label (stock_name);	    glade_xml_set_common_params (xml, child, cwinfo);	    gtk_menu_shell_append (GTK_MENU_SHELL(w), child);	    continue;	}	/* we now have the template for this item.  Now fill it in */	for (j = 0; j < cwinfo->n_properties; j++) {	    const char *name  = cwinfo->properties[j].name;	    const char *value = cwinfo->properties[j].value;	    if (!strcmp (name, "label"))		infos[0].label = _(value);	    else if (!strcmp (name, "tooltip"))		infos[0].hint = _(value);	}	mate_app_fill_menu (GTK_MENU_SHELL(w), infos,			     glade_xml_ensure_accel(xml), TRUE,			     i);	child = infos[0].widget;	gtk_menu_item_remove_submenu(GTK_MENU_ITEM(child));	glade_xml_set_common_params(xml, child, cwinfo);    }#if 0    if (uline)	glade_xml_pop_uline_accel(xml);#endif#if 0    if (strcmp(info->classname, "GtkMenuBar") != 0 &&	mate_preferences_get_menus_have_tearoff()) {	GtkWidget *tearoff = gtk_tearoff_menu_item_new();		gtk_menu_prepend(GTK_MENU(w), tearoff);	gtk_widget_show(tearoff);    }#endif}

voidgimp_ui_manager_ui_popup (GimpUIManager        *manager,                          const gchar          *ui_path,                          GtkWidget            *parent,                          GimpMenuPositionFunc  position_func,                          gpointer              position_data,                          GDestroyNotify        popdown_func,                          gpointer              popdown_data){  GtkWidget *widget;  GdkEvent  *current_event;  gint       x, y;  guint      button;  guint32    activate_time;  MenuPos   *menu_pos;  g_return_if_fail (GIMP_IS_UI_MANAGER (manager));  g_return_if_fail (ui_path != NULL);  g_return_if_fail (parent == NULL || GTK_IS_WIDGET (parent));  widget = gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), ui_path);  if (GTK_IS_MENU_ITEM (widget))    widget = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));  if (! widget)    return;  g_return_if_fail (GTK_IS_MENU (widget));  if (! position_func)    {      position_func = gimp_ui_manager_menu_position;      position_data = parent;    }  (* position_func) (GTK_MENU (widget), &x, &y, position_data);  current_event = gtk_get_current_event ();  if (current_event && current_event->type == GDK_BUTTON_PRESS)    {      GdkEventButton *bevent = (GdkEventButton *) current_event;      button        = bevent->button;      activate_time = bevent->time;    }  else    {      button        = 0;      activate_time = 0;    }  if (current_event)    gdk_event_free (current_event);  menu_pos = g_object_get_data (G_OBJECT (widget), "menu-pos");  if (! menu_pos)    {      menu_pos = g_slice_new0 (MenuPos);      g_object_set_data_full (G_OBJECT (widget), "menu-pos", menu_pos,                              (GDestroyNotify) menu_pos_free);    }  menu_pos->x = x;  menu_pos->y = y;  if (popdown_func && popdown_data)    {      g_object_set_data_full (G_OBJECT (manager), "popdown-data",                              popdown_data, popdown_func);      g_signal_connect (widget, "selection-done",                        G_CALLBACK (gimp_ui_manager_delete_popdown_data),                        manager);    }  gtk_menu_popup (GTK_MENU (widget),                  NULL, NULL,                  gimp_ui_manager_menu_pos, menu_pos,                  button, activate_time);}

int main(int argc, char *argv[]){	GApplication *app;#ifdef HAVE_APP_INDICATOR	AppIndicator *indicator;#else	GtkStatusIcon *statusicon;#endif /* HAVE_APP_INDICATOR */	GtkWidget *menu;	GOptionContext *context;	GError *error = NULL;	bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");	textdomain(GETTEXT_PACKAGE);	g_type_init ();	/* Parse command-line options */	context = g_option_context_new (N_("- Bluetooth applet"));	g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);	g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);	g_option_context_add_group (context, gtk_get_option_group (TRUE));	if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {		g_print (_("%s/nRun '%s --help' to see a full list of available command line options./n"),			 error->message, argv[0]);		g_error_free (error);		return 1;	}	if (option_debug == FALSE) {		GError *error = NULL;		app = g_application_new ("org.cinnamon.Bluetooth.applet",					 G_APPLICATION_FLAGS_NONE);		if (!g_application_register (app, NULL, &error)) {			g_object_unref (app);			g_warning ("%s", error->message);			g_error_free (error);			return 1;		}		if (g_application_get_is_remote (app)) {			g_object_unref (app);			g_warning ("Applet is already running, exiting");			return 0;		}	} else {		app = NULL;	}	g_set_application_name(_("Bluetooth Applet"));	gtk_window_set_default_icon_name("bluetooth");	applet = g_object_new (BLUETOOTH_TYPE_APPLET, NULL);	g_signal_connect (G_OBJECT (applet), "notify::killswitch-state",			G_CALLBACK (killswitch_state_changed), NULL);	menu = create_popupmenu();#ifdef HAVE_APP_INDICATOR	indicator = init_notification();	app_indicator_set_menu(indicator, GTK_MENU(menu));	app_indicator_set_title(indicator, _("Bluetooth"));	gsettings = g_settings_new (BLUETOOTH_INDICATOR_GSETTINGS_SCHEMA_ID);	g_signal_connect (gsettings, "changed::" GSETTINGS_VISIBLE_KEY,	                  G_CALLBACK(update_icon_visibility), NULL);#else	statusicon = init_notification();#endif /* HAVE_APP_INDICATOR */	g_signal_connect (G_OBJECT (applet), "devices-changed",			G_CALLBACK (update_device_list), NULL);	g_signal_connect (G_OBJECT (applet), "notify::discoverable",			G_CALLBACK (update_discoverability), NULL);	g_signal_connect (G_OBJECT (applet), "notify::show-full-menu",			G_CALLBACK (update_menu_items), NULL);	killswitch_state_changed ((GObject*) applet, NULL, NULL);	update_menu_items ((GObject*) applet, NULL, NULL);	update_discoverability ((GObject*) applet, NULL, NULL);	update_device_list (applet, NULL);	update_icon_visibility();#ifndef HAVE_APP_INDICATOR	g_signal_connect(statusicon, "activate",				G_CALLBACK(activate_callback), menu);	g_signal_connect(statusicon, "popup-menu",				G_CALLBACK(popup_callback), menu);#endif /* HAVE_APP_INDICATOR */	setup_agents(applet);	gtk_main();	gtk_widget_destroy(menu);	cleanup_notification();//.........这里部分代码省略.........

static gbooleangimp_ui_manager_item_key_press (GtkWidget     *widget,                                GdkEventKey   *kevent,                                GimpUIManager *manager){  gchar *help_id = NULL;  while (! help_id)    {      GtkWidget *menu_item = GTK_MENU_SHELL (widget)->active_menu_item;      if (! menu_item && GTK_IS_MENU (widget))        {          GtkWidget *parent = gtk_widget_get_parent (widget);          GdkWindow *window = gtk_widget_get_window (parent);          gint       x, y;          gdk_window_get_pointer (window, &x, &y, NULL);          menu_item = find_widget_under_pointer (window, &x, &y);          if (menu_item && ! GTK_IS_MENU_ITEM (menu_item))            {              menu_item = gtk_widget_get_ancestor (menu_item,                                                   GTK_TYPE_MENU_ITEM);              if (! GTK_IS_MENU_ITEM (menu_item))                menu_item = NULL;            }        }      /*  first, get the help page from the item...       */      if (menu_item)        {          help_id = g_object_get_qdata (G_OBJECT (menu_item), GIMP_HELP_ID);          if (help_id && ! strlen (help_id))            help_id = NULL;        }      /*  ...then try the parent menu...       */      if (! help_id)        {          help_id = g_object_get_qdata (G_OBJECT (widget), GIMP_HELP_ID);          if (help_id && ! strlen (help_id))            help_id = NULL;        }      /*  ...finally try the menu's parent (if any)       */      if (! help_id)        {          menu_item = NULL;          if (GTK_IS_MENU (widget))            menu_item = gtk_menu_get_attach_widget (GTK_MENU (widget));          if (! menu_item)            break;          widget = gtk_widget_get_parent (menu_item);          if (! widget)            break;        }    }  /*  For any valid accelerator key except F1, continue with the   *  standard GtkMenuShell callback and assign a new shortcut, but   *  don't assign a shortcut to the help menu entries ...   */  if (kevent->keyval != GDK_KEY_F1)    {      if (help_id                                   &&          gtk_accelerator_valid (kevent->keyval, 0) &&          (strcmp (help_id, GIMP_HELP_HELP)         == 0 ||           strcmp (help_id, GIMP_HELP_HELP_CONTEXT) == 0))        {          return TRUE;        }      return FALSE;    }  /*  ...finally, if F1 was pressed over any menu, show its help page...  */  if (help_id)    {      gchar *help_domain = NULL;      gchar *help_string = NULL;      gchar *domain_separator;      help_id = g_strdup (help_id);      domain_separator = strchr (help_id, '?');      if (domain_separator)        {//.........这里部分代码省略.........

static void cb_popup_state(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data){  switch (button) {    case 1:#if UNIX      toggle_im_enabled();      break;    case 2:#endif      kbm_toggle();      break;    case 3:    {      char bak[512], cur[512];      get_gcin_conf_fstr(PHONETIC_KEYBOARD, cur, "");      get_gcin_conf_fstr(PHONETIC_KEYBOARD_BAK, bak, "");      if (bak[0] && strcmp(bak, cur)) {        char kbm[512];        strcpy(kbm, bak);        char *p=strchr(kbm, ' ');        if (p) {          *(p++)=0;          int i;          for(i=0;kbm_sel[i].name;i++)            if (!strcmp(kbm_sel[i].kbm, kbm)) {              break;            }          if (kbm_sel[i].kbm) {            unich_t tt[128];            if (mitems_state[0].name)              free(mitems_state[0].name);#if UNIX            sprintf(tt, "注音
C++ GTK_MENU_BAR函数代码示例
C++ GTK_LIST_STORE函数代码示例