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

static voidwindows_menu_recent_add (GimpContainer   *container,                         GimpSessionInfo *info,                         GimpUIManager   *manager){  const gchar *ui_path;  gchar       *action_name;  gchar       *action_path;  gint         info_id;  gchar       *merge_key;  guint        merge_id;  ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");  info_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info),                                                "recent-action-id"));  action_name = g_strdup_printf ("windows-recent-%04d", info_id);  action_path = g_strdup_printf ("%s/Windows/Recently Closed Docks", ui_path);  merge_key = g_strdup_printf ("windows-recent-%04d-merge-id", info_id);  merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));  g_object_set_data (G_OBJECT (manager), merge_key,                     GUINT_TO_POINTER (merge_id));  gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,                         action_path, action_name, action_name,                         GTK_UI_MANAGER_MENUITEM,                         TRUE);  g_free (merge_key);  g_free (action_path);  g_free (action_name);}

static voidwindows_menu_dock_window_added (GimpDialogFactory *factory,                                GimpDockWindow    *dock_window,                                GimpUIManager     *manager){  const gchar *ui_path;  gchar       *action_name;  gchar       *action_path;  gchar       *merge_key;  guint        merge_id;  ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");  action_name = windows_actions_dock_window_to_action_name (dock_window);  action_path = g_strdup_printf ("%s/Windows/Docks",                                 ui_path);  merge_key = windows_menu_dock_window_to_merge_id (dock_window);  merge_id  = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));  g_object_set_data (G_OBJECT (manager), merge_key,                     GUINT_TO_POINTER (merge_id));  gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,                         action_path, action_name, action_name,                         GTK_UI_MANAGER_MENUITEM,                         FALSE);  g_free (merge_key);  g_free (action_path);  g_free (action_name);}

GtkWidget*search_box_new (AnjutaDocman *docman){	SearchBox* search_box;	AnjutaUI *ui;	search_box = SEARCH_BOX (g_object_new (SEARCH_TYPE_BOX, "homogeneous",											FALSE, NULL));	g_signal_connect (G_OBJECT (docman), "document-changed",					  G_CALLBACK (on_document_changed), search_box);	search_box->priv->status = anjuta_shell_get_status (docman->shell, NULL);		ui = anjuta_shell_get_ui (docman->shell, NULL);	search_box->priv->popup_menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),											"/SearchboxPopup");	g_assert (search_box->priv->popup_menu != NULL && GTK_IS_MENU (search_box->priv->popup_menu));	search_box->priv->case_action = 		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/CaseCheck");	search_box->priv->highlight_action =		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/HighlightAll");	search_box->priv->regex_action = 		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/RegexSearch");	g_signal_connect (search_box->priv->popup_menu, "deactivate",					  G_CALLBACK (gtk_widget_hide), NULL);	return GTK_WIDGET (search_box);}

PtpSimulatorUIManager *ptp_simulator_ui_manager_new(void){    PtpSimulatorUIManager   *ui_manager;    GtkActionGroup          *menubar_action_group;    GError                  *error = NULL;        menubar_action_group = gtk_action_group_new("MenuActionGroup");        gtk_action_group_add_actions(menubar_action_group,                  /* the action group */                                 menubar_action_entries,                /* an array of action descriptions */                                 G_N_ELEMENTS(menubar_action_entries),  /* the number of entries */                                 NULL);                                 /* data to pass to the action callbacks */        ui_manager = g_object_new(PTP_SIMULATOR_TYPE_UI_MANAGER, NULL);    gtk_ui_manager_insert_action_group(GTK_UI_MANAGER(ui_manager), menubar_action_group, 0);        gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), menubar_definition, -1, &error);    if (error != NULL) {        fprintf(stderr, "Warning: building menubar failed: %s/n", error->message);        g_error_free(error);        error = NULL;    }    g_object_unref(menubar_action_group);        return ui_manager;}

static gbooleanon_status_view_button_press_event (GtkWidget *widget, GdkEvent *event,                                   GitStatusPane *self){	GdkEventButton *button_event;	AnjutaPlugin *plugin;	AnjutaUI *ui;	GtkTreeView *status_view;	GtkTreeSelection *selection;	GtkTreeModel *status_model;	GtkTreeIter iter;	StatusType status_type;	GtkMenu *menu;	button_event = (GdkEventButton *) event;	menu = NULL;		if (button_event->type == GDK_BUTTON_PRESS && button_event->button == 3)	{		plugin = anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self));		ui = anjuta_shell_get_ui (plugin->shell, NULL);		status_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder,		                                                     "status_view"));		selection = gtk_tree_view_get_selection (status_view);		if (gtk_tree_selection_get_selected (selection, &status_model, &iter))		{			gtk_tree_model_get (status_model, &iter, COL_TYPE, &status_type, 			                    -1);			if (status_type == STATUS_TYPE_COMMIT)			{				menu = GTK_MENU (gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),				                              			    "/GitStatusCommitPopup"));			}			else if (status_type == STATUS_TYPE_NOT_UPDATED)			{				menu = GTK_MENU (gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),				                              				"/GitStatusNotUpdatedPopup"));			}			if (menu)			{				gtk_menu_popup (menu, NULL, NULL, NULL, NULL, button_event->button, 				                button_event->time);			}		}	}	return FALSE;}

static GtkWidget *create_popupmenu(void){	GObject *object;	GError *error = NULL;	xml = gtk_builder_new ();	if (gtk_builder_add_from_file (xml, "popup-menu.ui", &error) == 0) {		if (error->domain == GTK_BUILDER_ERROR) {			g_warning ("Failed to load popup-menu.ui: %s", error->message);			g_error_free (error);			return NULL;		}		g_error_free (error);		error = NULL;		if (gtk_builder_add_from_file (xml, PKGDATADIR "/popup-menu.ui", &error) == 0) {			g_warning ("Failed to load popup-menu.ui: %s", error->message);			g_error_free (error);			return NULL;		}	}	gtk_builder_connect_signals (xml, NULL);	if (bluetooth_applet_get_killswitch_state (applet) != BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER) {		GObject *object;		object = gtk_builder_get_object (xml, "killswitch-label");		gtk_action_set_visible (GTK_ACTION (object), TRUE);	}	if (option_debug != FALSE) {		GObject *object;		object = gtk_builder_get_object (xml, "quit");		gtk_action_set_visible (GTK_ACTION (object), TRUE);	}	object = gtk_builder_get_object (xml, "bluetooth-applet-ui-manager");	devices_action_group = gtk_action_group_new ("devices-action-group");	gtk_ui_manager_insert_action_group (GTK_UI_MANAGER (object),					    devices_action_group, -1);	action_set_bold (GTK_UI_MANAGER (object),			 GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),			 "/bluetooth-applet-popup/devices-label");	return GTK_WIDGET (gtk_builder_get_object (xml, "bluetooth-applet-popup"));}

static voidgaleon_encoding_menu_set_window (GaleonEncodingMenu *menu, GaleonWindow *window){	GtkActionGroup *action_group;	GtkWidget *widget;	GList *encodings;	g_return_if_fail (GALEON_IS_WINDOW (window));	menu->priv->window = window;	menu->priv->merge  = GTK_UI_MANAGER (window->merge);	action_group = gtk_action_group_new ("EncodingActions");	gtk_action_group_set_translation_domain (action_group, NULL);	menu->priv->action_group = action_group;	gtk_action_group_add_actions (action_group, menu_entries,				      n_menu_entries, menu);	gtk_action_group_add_toggle_actions (action_group, toggle_menu_entries,                                    	     n_toggle_menu_entries, menu);	encodings = galeon_encodings_get_encodings (menu->priv->encodings, LG_ALL);	g_list_foreach (encodings, (GFunc) add_action, menu);	g_list_free (encodings);	gtk_ui_manager_insert_action_group (menu->priv->merge,					    action_group, 0);	g_object_unref (action_group);	widget = gtk_ui_manager_get_widget (menu->priv->merge,					    "/menubar/View");	g_signal_connect_object (widget, "activate",				 G_CALLBACK (update_encoding_menu_cb),				 menu, 0);}

intclip_GTK_UIMANAGERADDUI(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   guint     merge_id = _clip_parni(ClipMachineMemory, 2);   gchar    *path = _clip_parc(ClipMachineMemory, 3);   gchar    *name = _clip_parc(ClipMachineMemory, 4);   gchar    *action = _clip_parc(ClipMachineMemory, 5);   GtkUIManagerItemType type = _clip_parni(ClipMachineMemory, 6);   gboolean  top = _clip_parl(ClipMachineMemory, 7);   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   CHECKARG(2, NUMERIC_type_of_ClipVarType);   CHECKARG(3, CHARACTER_type_of_ClipVarType);   CHECKARG(4, CHARACTER_type_of_ClipVarType);   CHECKARG(5, CHARACTER_type_of_ClipVarType);   CHECKARG(6, NUMERIC_type_of_ClipVarType);   CHECKARG(7, LOGICAL_type_of_ClipVarType);   gtk_ui_manager_add_ui(GTK_UI_MANAGER(cmanager->object), merge_id, path, name, action, type, top);   return 0; err:   return 1;}

intclip_GTK_UIMANAGERGETACTION(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   gchar    *path = _clip_parc(ClipMachineMemory, 2);   GtkAction *action;   C_object *caction;   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   CHECKARG(2, CHARACTER_type_of_ClipVarType);   action = gtk_ui_manager_get_action(GTK_UI_MANAGER(cmanager->object), path);   if (action)    {       caction = _list_get_cobject(ClipMachineMemory, action);       if (!caction)	  caction = _register_object(ClipMachineMemory, action, GTK_TYPE_ACTION, NULL, NULL);       if (caction)	  _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &caction->obj);    }   return 0; err:   return 1;}

static voidbuild_search_entry(GitgWindow *window, GtkBuilder *builder){	GtkWidget *box = GTK_WIDGET(gtk_builder_get_object(builder, "hbox_top"));	GtkWidget *entry = sexy_icon_entry_new();		GtkImage *image = GTK_IMAGE(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU));	sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, image);		gtk_tree_view_set_search_entry(window->priv->tree_view, GTK_ENTRY(entry));	gtk_widget_show(entry);	gtk_box_pack_end(GTK_BOX(box), entry, FALSE, FALSE, 0);		GtkBuilder *b = gitg_utils_new_builder( "gitg-menus.xml");		GtkUIManager *manager = GTK_UI_MANAGER(gtk_builder_get_object(b, "uiman"));	window->priv->search_popup = GTK_WIDGET(g_object_ref(gtk_ui_manager_get_widget(manager, "/ui/search_popup")));		gtk_builder_connect_signals(b, window);	g_object_unref(b);		g_signal_connect(entry, "icon-pressed", G_CALLBACK(on_search_icon_pressed), window);	gtk_tree_view_set_search_column(window->priv->tree_view, 1);		gtk_tree_view_set_search_equal_func(window->priv->tree_view, search_equal_func, window, NULL);		GtkAccelGroup *group = gtk_accel_group_new();		GClosure *closure = g_cclosure_new(G_CALLBACK(focus_search), entry, NULL); 	gtk_accel_group_connect(group, GDK_f, GDK_CONTROL_MASK, 0, closure); 	gtk_window_add_accel_group(GTK_WINDOW(window), group);}

intclip_GTK_UIMANAGERGETACCELGROUP(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   GtkAccelGroup *agroup;   C_widget *cagroup;   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   agroup = gtk_ui_manager_get_accel_group(GTK_UI_MANAGER(cmanager->object));   if (agroup)    {       cagroup = _list_get_cwidget(ClipMachineMemory, agroup);       if (!cagroup)	  cagroup = _register_widget(ClipMachineMemory, GTK_WIDGET(agroup), NULL);       if (cagroup)	  _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cagroup->obj);    }   return 0; err:   return 1;}

static gbooleanon_log_view_button_press_event (GtkWidget *log_view, GdkEventButton *event,                                GitLogPane *self){	GtkMenu *menu;	GtkTreeSelection *selection;	AnjutaPlugin *plugin;	AnjutaUI *ui;	if (event->type == GDK_BUTTON_PRESS && event->button == 3)	{		selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_view));		if (gtk_tree_selection_count_selected_rows (selection) > 0)		{			plugin = anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self));			ui = anjuta_shell_get_ui (plugin->shell, NULL);			menu = GTK_MENU (gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),			                                            "/GitLogPopup"));			gtk_menu_popup (menu, NULL, NULL, NULL, NULL, event->button, 			                event->time);		}	}	return FALSE;}

voidfile_menu_setup (GimpUIManager *manager,                 const gchar   *ui_path){  GtkUIManager *ui_manager;  gint          n_entries;  guint         merge_id;  gint          i;  g_return_if_fail (GIMP_IS_UI_MANAGER (manager));  g_return_if_fail (ui_path != NULL);  ui_manager = GTK_UI_MANAGER (manager);  n_entries = GIMP_GUI_CONFIG (manager->gimp->config)->last_opened_size;  merge_id = gtk_ui_manager_new_merge_id (ui_manager);  for (i = 0; i < n_entries; i++)    {      gchar *action_name;      gchar *action_path;      action_name = g_strdup_printf ("file-open-recent-%02d", i + 1);      action_path = g_strdup_printf ("%s/File/Open Recent/Files", ui_path);      gtk_ui_manager_add_ui (ui_manager, merge_id,                             action_path, action_name, action_name,                             GTK_UI_MANAGER_MENUITEM,                             FALSE);      g_free (action_name);      g_free (action_path);    }}

static voidimpl_attach_window (EphyExtension *ext,		    EphyWindow *window){	LOG ("EphyJavaConsoleExtension attach_window");	if (java_console_is_available ())	{		GtkUIManager *manager;		WindowData *data;		data = g_new0 (WindowData, 1);		g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY, data,					(GDestroyNotify) g_free);		data->action_group = gtk_action_group_new ("EphyJCExtActions");		gtk_action_group_set_translation_domain (data->action_group, GETTEXT_PACKAGE);		gtk_action_group_add_actions (data->action_group, action_entries,				      	      G_N_ELEMENTS (action_entries), window);		manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));		gtk_ui_manager_insert_action_group (manager, data->action_group, 0);		g_object_unref (data->action_group);		data->merge_id = gtk_ui_manager_new_merge_id (manager);		gtk_ui_manager_add_ui (manager, data->merge_id, "/menubar/ToolsMenu",				       ACTION_NAME_SHOW_CONSOLE, ACTION_NAME_SHOW_CONSOLE,				       GTK_UI_MANAGER_MENUITEM, FALSE);	}}

static gbooleangimp_ui_manager_entry_load (GimpUIManager         *manager,                            GimpUIManagerUIEntry  *entry,                            GError               **error){  gchar       *filename           = NULL;  const gchar *menus_dir_override = g_getenv ("GIMP_TESTING_MENUS_DIR");  /* In order for test cases to be able to run without GIMP being   * installed yet, allow them to override the menus directory to the   * menus dir in the source root   */  if (menus_dir_override)    filename = g_build_filename (menus_dir_override, entry->basename, NULL);  else    filename = g_build_filename (gimp_data_directory (), "menus",                                 entry->basename, NULL);  if (manager->gimp->be_verbose)    g_print ("loading menu '%s' for %s/n",             gimp_filename_to_utf8 (filename), entry->ui_path);  entry->merge_id = gtk_ui_manager_add_ui_from_file (GTK_UI_MANAGER (manager),                                                     filename, error);  g_free (filename);  if (! entry->merge_id)    return FALSE;  return TRUE;}

static voidwindows_menu_display_reorder (GimpContainer *container,                              GimpDisplay   *display,                              gint           new_index,                              GimpUIManager *manager){  gint n_display = gimp_container_get_n_children (container);  gint i;  for (i = new_index; i < n_display; i++)    {      GimpObject *d = gimp_container_get_child_by_index (container, i);      windows_menu_display_remove (container, GIMP_DISPLAY (d), manager);    }  /* If I don't ensure the menu items are effectively removed, adding   * the same ones may simply cancel the effect of the removal, hence   * losing the menu reordering.   */  gtk_ui_manager_ensure_update (GTK_UI_MANAGER (manager));  for (i = new_index; i < n_display; i++)    {      GimpObject *d = gimp_container_get_child_by_index (container, i);      windows_menu_display_add (container, GIMP_DISPLAY (d), manager);    }}

gbooleanactions_changed_cb(GSignalInvocationHint *hint,                   guint n_param_values,                   const GValue *param_values,                   gpointer data){    ParasiteActionList *actionlist = PARASITE_ACTIONLIST(data);    GtkUIManager *uimanager;    GSList *i;    uimanager = GTK_UI_MANAGER(g_value_get_object(&param_values[0]));    i = g_slist_find(actionlist->priv->uimanagers, uimanager);    if (i == NULL) {        actionlist->priv->uimanagers =            g_slist_prepend(actionlist->priv->uimanagers, uimanager);        g_object_weak_ref(G_OBJECT(uimanager), uimanager_dispose_cb, data);    }    if (actionlist->priv->update_timeout == 0) {        actionlist->priv->update_timeout =            g_timeout_add(20, (GSourceFunc) update, actionlist);    }    return TRUE;}

intclip_GTK_UIMANAGERGETWIDGET(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   gchar    *path = _clip_parc(ClipMachineMemory, 2);   GtkWidget *wid;   C_widget *cwid;   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   CHECKARG(2, CHARACTER_type_of_ClipVarType);   wid = gtk_ui_manager_get_widget(GTK_UI_MANAGER(cmanager->object), path);   if (wid)    {       cwid = _list_get_cwidget(ClipMachineMemory, wid);       if (!cwid)	  cwid = _register_widget(ClipMachineMemory, wid, NULL);       if (cwid)	  _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);    }   return 0; err:   return 1;}

static voidon_file_view_show_popup_menu (AnjutaFileView* view, GFile* file,							  gboolean is_dir, guint button,							  guint32 time, AnjutaFileManager* file_manager){	GtkWidget *popup;	GtkWidget *rename;	AnjutaUI* ui = anjuta_shell_get_ui (ANJUTA_PLUGIN(file_manager)->shell, 										NULL);	popup = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),									   "/PopupFileManager");	rename = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),									   "/PopupFileManager/PopupFileManagerRename");	/* TODO */	gtk_widget_hide (rename);		g_return_if_fail (GTK_IS_WIDGET (popup));	gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL, button, time);}

static gbooleangimp_color_panel_button_press (GtkWidget      *widget,                               GdkEventButton *bevent){  if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))    {      GimpColorButton *color_button;      GimpColorPanel  *color_panel;      GtkUIManager    *ui_manager;      GtkActionGroup  *group;      GtkAction       *action;      GimpRGB          color;      color_button = GIMP_COLOR_BUTTON (widget);      color_panel  = GIMP_COLOR_PANEL (widget);      ui_manager   = GTK_UI_MANAGER (color_button->popup_menu);      group = gtk_ui_manager_get_action_groups (ui_manager)->data;      action = gtk_action_group_get_action (group,                                            "color-button-use-foreground");      gtk_action_set_visible (action, color_panel->context != NULL);      action = gtk_action_group_get_action (group,                                            "color-button-use-background");      gtk_action_set_visible (action, color_panel->context != NULL);      if (color_panel->context)        {          action = gtk_action_group_get_action (group,                                                "color-button-use-foreground");          gimp_context_get_foreground (color_panel->context, &color);          g_object_set (action, "color", &color, NULL);          action = gtk_action_group_get_action (group,                                                "color-button-use-background");          gimp_context_get_background (color_panel->context, &color);          g_object_set (action, "color", &color, NULL);        }      action = gtk_action_group_get_action (group, "color-button-use-black");      gimp_rgba_set (&color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);      g_object_set (action, "color", &color, NULL);      action = gtk_action_group_get_action (group, "color-button-use-white");      gimp_rgba_set (&color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);      g_object_set (action, "color", &color, NULL);    }  if (GTK_WIDGET_CLASS (parent_class)->button_press_event)    return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent);  return FALSE;}

static voidkillswitch_state_changed (GObject    *gobject,                          GParamSpec *pspec,                          gpointer    user_data){	GObject *object;	BluetoothApplet *applet = BLUETOOTH_APPLET (gobject);	BluetoothKillswitchState state = bluetooth_applet_get_killswitch_state (applet);	gboolean sensitive = TRUE;	gboolean bstate = FALSE;	const char *label, *status_label;	if (state == BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER) {		object = gtk_builder_get_object (xml, "bluetooth-applet-popup");		gtk_menu_popdown (GTK_MENU (object));		update_icon_visibility ();		return;	}	if (state == BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED) {		label = N_("Turn on Bluetooth");		status_label = N_("Bluetooth: Off");		bstate = FALSE;	} else if (state == BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED) {		label = N_("Turn off Bluetooth");		status_label = N_("Bluetooth: On");		bstate = TRUE;	} else if (state == BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED) {		sensitive = FALSE;		label = NULL;		status_label = N_("Bluetooth: Disabled");	} else {		g_assert_not_reached ();	}	object = gtk_builder_get_object (xml, "killswitch-label");	gtk_action_set_label (GTK_ACTION (object), _(status_label));	gtk_action_set_visible (GTK_ACTION (object), TRUE);	object = gtk_builder_get_object (xml, "killswitch");	gtk_action_set_visible (GTK_ACTION (object), sensitive);	gtk_action_set_label (GTK_ACTION (object), _(label));	if (sensitive != FALSE) {		gtk_action_set_label (GTK_ACTION (object), _(label));		g_object_set_data (object, "bt-active", GINT_TO_POINTER (bstate));	}	object = gtk_builder_get_object (xml, "bluetooth-applet-ui-manager");	gtk_ui_manager_ensure_update (GTK_UI_MANAGER (object));	update_icon_visibility ();}

static voidgui_add_to_app_menu (GimpUIManager   *ui_manager,                     IgeMacMenuGroup *group,                     const gchar     *action_path,                     const gchar     *label){  GtkWidget *item;  item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui_manager), action_path);  if (GTK_IS_MENU_ITEM (item))    ige_mac_menu_add_app_menu_item (group, GTK_MENU_ITEM (item), label);}

static voidgimp_ui_manager_real_update (GimpUIManager *manager,                             gpointer       update_data){  GList *list;  for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));       list;       list = g_list_next (list))    {      gimp_action_group_update (list->data, update_data);    }}

static voidwindows_menu_dock_window_added (GimpDialogFactory *factory,                                GimpDockWindow    *dock_window,                                GimpUIManager     *manager){  const gchar *ui_path;  gchar       *action_name;  gchar       *action_path;  gchar       *merge_key;  guint        merge_id;  ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");  action_name = windows_actions_dock_window_to_action_name (dock_window);  action_path = g_strdup_printf ("%s/Windows/Docks",                                 ui_path);  merge_key = windows_menu_dock_window_to_merge_id (dock_window);  merge_id  = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));  g_object_set_data (G_OBJECT (manager), merge_key,                     GUINT_TO_POINTER (merge_id));  gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,                         action_path, action_name, action_name,                         GTK_UI_MANAGER_MENUITEM,                         FALSE);  /* There can only be one toolbox around, so if a new is created,   * make sure to remove any toolbox entries from Recenly Closed Docks   */  if (windows_menu_is_toolbox_dock_window (dock_window))    windows_menu_remove_toolbox_entries (global_recent_docks);  g_free (merge_key);  g_free (action_path);  g_free (action_name);}

static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager){	GtkActionGroup *action_group = gtk_action_group_new("Menu");	gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);	gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);	GError* error = 0;	gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);	gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));	GtkWidget* menu = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");	return menu;}

intclip_GTK_UIMANAGERGETUI(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   _clip_retc(ClipMachineMemory, gtk_ui_manager_get_ui(GTK_UI_MANAGER(cmanager->object)));   return 0; err:   return 1;}

intclip_GTK_UIMANAGERENSUREUPDATE(ClipMachine * ClipMachineMemory){   C_object *cmanager = _fetch_co_arg(ClipMachineMemory);   CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));   gtk_ui_manager_ensure_update(GTK_UI_MANAGER(cmanager->object));   return 0; err:   return 1;}

static voidimpl_attach_window (EphyExtension *extension,		    EphyWindow *window){	GtkUIManager *manager;	GtkActionGroup *action_group;	GtkAction *action;	GSettings *settings;	EphyLocationController *location_controller;	g_signal_connect (EPHY_SETTINGS_LOCKDOWN,			  "changed::" EPHY_PREFS_LOCKDOWN_FULLSCREEN,			  G_CALLBACK (fullscreen_cb), window);	g_signal_connect (EPHY_SETTINGS_LOCKDOWN,			  "changed::" EPHY_PREFS_LOCKDOWN_ARBITRARY_URL,			  G_CALLBACK (arbitrary_url_cb), window);	/* Trigger an initial state on these elements. */	fullscreen_cb (EPHY_SETTINGS_LOCKDOWN,		       EPHY_PREFS_LOCKDOWN_FULLSCREEN, window);	arbitrary_url_cb (EPHY_SETTINGS_LOCKDOWN,			  EPHY_PREFS_LOCKDOWN_ARBITRARY_URL, window);	manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));	action_group = find_action_group (manager, "WindowActions");	bind_settings_and_actions (EPHY_SETTINGS_LOCKDOWN,				   action_group, window_actions,				   G_N_ELEMENTS (window_actions));	action_group = find_action_group (manager, "PopupsActions");	bind_settings_and_actions (EPHY_SETTINGS_LOCKDOWN,				   action_group, popup_actions,				   G_N_ELEMENTS (popup_actions));	action = gtk_action_group_get_action (action_group,					      "SetImageAsBackground");	settings = ephy_settings_get ("org.gnome.desktop.background");	g_settings_bind_writable (settings, "picture-filename",				  action, "sensitive", FALSE);	action_group = find_action_group (manager, "SpecialToolbarActions");	bind_settings_and_actions (EPHY_SETTINGS_LOCKDOWN,				   action_group, special_toolbar_actions,				   G_N_ELEMENTS (special_toolbar_actions));	location_controller = ephy_window_get_location_controller (window);	bind_location_controller (EPHY_SETTINGS_LOCKDOWN, location_controller);}

static gbooleangimp_controllers_event_mapped (GimpControllerInfo        *info,                               GimpController            *controller,                               const GimpControllerEvent *event,                               const gchar               *action_name,                               GimpControllerManager     *manager){  GtkUIManager *ui_manager = GTK_UI_MANAGER (manager->ui_manager);  GList        *list;  for (list = gtk_ui_manager_get_action_groups (ui_manager);       list;       list = g_list_next (list))    {      GtkActionGroup *group = list->data;      GtkAction      *action;      action = gtk_action_group_get_action (group, action_name);      if (action)        {          switch (event->type)            {            case GIMP_CONTROLLER_EVENT_VALUE:              if (G_VALUE_HOLDS_DOUBLE (&event->value.value) &&                  GIMP_IS_ENUM_ACTION (action)               &&                  GIMP_ENUM_ACTION (action)->value_variable)                {                  gdouble value = g_value_get_double (&event->value.value);                  gimp_enum_action_selected (GIMP_ENUM_ACTION (action),                                             value * 1000);                  break;                }              /* else fallthru */            case GIMP_CONTROLLER_EVENT_TRIGGER:            default:              gtk_action_activate (action);              break;            }          return TRUE;        }    }  return FALSE;}