static void
windows_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 void
windows_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 gboolean
on_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 void
galeon_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);
}
int
clip_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;
}
int
clip_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 void
build_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);
}
int
clip_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 gboolean
on_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;
}
void
file_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 void
impl_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 gboolean
gimp_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 void
windows_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);
}
}
gboolean
actions_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(¶m_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;
}
int
clip_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 void
on_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 gboolean
gimp_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 void
killswitch_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 void
gui_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 void
gui_add_to_app_menu (GimpUIManager *ui_manager,
GtkosxApplication *osx_app,
const gchar *action_path,
gint index)
{
GtkWidget *item;
item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui_manager), action_path);
if (GTK_IS_MENU_ITEM (item))
gtkosx_application_insert_app_menu_item (osx_app, GTK_WIDGET (item), index);
}
static void
gimp_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 void
windows_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;
}
int
clip_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;
}
int
clip_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 void
impl_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 gboolean
gimp_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;
}
