static void _get_current_debug_flags(GtkToggleAction *action)
{
static uint64_t debug_flags = 0, tmp_flags;
static slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr = NULL;
int err_code = get_new_info_config(&slurm_ctl_conf_ptr);
GtkAction *debug_action = NULL;
GtkToggleAction *toggle_action;
gboolean orig_state, new_state;
int i;
if (err_code != SLURM_ERROR)
debug_flags = slurm_ctl_conf_ptr->debug_flags;
for (i = 0; i < debug_action_entries; i++) {
debug_action = gtk_action_group_get_action(
menu_action_group, debug_actions[i].name);
toggle_action = GTK_TOGGLE_ACTION(debug_action);
orig_state = gtk_toggle_action_get_active(toggle_action);
if (debug_str2flags((char *)debug_actions[i].name, &tmp_flags)
!= SLURM_SUCCESS) {
g_error("debug_str2flags no good: %s\n",
debug_actions[i].name);
continue;
}
new_state = debug_flags & tmp_flags;
if (orig_state != new_state)
gtk_toggle_action_set_active(toggle_action, new_state);
}
}
static void
formhistory_deactivate_cb (MidoriExtension* extension,
MidoriBrowser* browser)
{
MidoriApp* app = midori_extension_get_app (extension);
FormHistoryPriv* priv = g_object_get_data (G_OBJECT (extension), "priv");
GtkActionGroup* action_group = midori_browser_get_action_group (browser);
GtkAction* action;
g_signal_handlers_disconnect_by_func (
browser, formhistory_add_tab_cb, extension);
g_signal_handlers_disconnect_by_func (
extension, formhistory_deactivate_cb, browser);
g_signal_handlers_disconnect_by_func (
app, formhistory_app_add_browser_cb, extension);
GList* tabs = midori_browser_get_tabs (browser);
for (; tabs; tabs = g_list_next (tabs))
formhistory_deactivate_tab (tabs->data, extension);
g_list_free (tabs);
g_object_set_data (G_OBJECT (browser), "FormHistoryExtension", NULL);
action = gtk_action_group_get_action (action_group, "FormHistoryToggleState");
if (action != NULL)
{
gtk_action_group_remove_action (action_group, action);
g_object_unref (action);
}
formhistory_private_destroy (priv);
}
void
gimp_action_group_set_action_viewable (GimpActionGroup *group,
const gchar *action_name,
GimpViewable *viewable)
{
GtkAction *action;
g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
g_return_if_fail (action_name != NULL);
g_return_if_fail (viewable == NULL || GIMP_IS_VIEWABLE (viewable));
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
if (! action)
{
g_warning ("%s: Unable to set viewable of action "
"which doesn't exist: %s",
G_STRFUNC, action_name);
return;
}
if (! GIMP_IS_ACTION (action))
{
g_warning ("%s: Unable to set \"viewable\" of action "
"which is not a GimpAction: %s",
G_STRFUNC, action_name);
return;
}
g_object_set (action, "viewable", viewable, NULL);
}
static void
plug_in_actions_unregister_procedure (GimpPDB *pdb,
GimpProcedure *procedure,
GimpActionGroup *group)
{
if (GIMP_IS_PLUG_IN_PROCEDURE (procedure))
{
GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure);
g_signal_handlers_disconnect_by_func (plug_in_proc,
plug_in_actions_menu_path_added,
group);
if (plug_in_proc->menu_label &&
! plug_in_proc->file_proc)
{
GtkAction *action;
#if 0
g_print ("%s: %s\n", G_STRFUNC,
gimp_object_get_name (procedure));
#endif
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
gimp_object_get_name (procedure));
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
}
}
}
static GtkWidget *
toolbar_create_toolbutton (NemoToolbar *self,
gboolean create_toggle,
const gchar *name)
{
GtkWidget *button;
GtkWidget *image;
GtkAction *action;
if (create_toggle)
{
button = gtk_toggle_button_new ();
} else {
button = gtk_button_new ();
}
image = gtk_image_new ();
gtk_button_set_image (GTK_BUTTON (button), image);
action = gtk_action_group_get_action (self->priv->action_group, name);
gtk_activatable_set_related_action (GTK_ACTIVATABLE (button), action);
gtk_button_set_label (GTK_BUTTON (button), NULL);
gtk_widget_set_tooltip_text (button, gtk_action_get_tooltip (action));
return button;
}
static void tb_editor_set_item_values(TBEditorWidget *tbw, const gchar *action_name,
GtkListStore *store, GtkTreeIter *iter)
{
gchar *icon = NULL;
gchar *label = NULL;
gchar *label_clean = NULL;
GtkAction *action;
action = gtk_action_group_get_action(tbw->action_group, action_name);
if (action != NULL)
{
icon = katze_object_get_string(action, "icon-name");
if (icon == NULL)
{
icon = katze_object_get_string(action, "stock-id");
}
label = katze_object_get_string(action, "label");
if (label != NULL)
label_clean = katze_strip_mnemonics(label);
}
gtk_list_store_set(store, iter,
TB_EDITOR_COL_ACTION, action_name,
TB_EDITOR_COL_LABEL, label_clean,
TB_EDITOR_COL_ICON, icon,
-1);
g_free(icon);
g_free(label);
g_free(label_clean);
}
static void
equalizerwin_set_shade(gboolean shaded)
{
GtkAction *action = gtk_action_group_get_action(
toggleaction_group_others , "roll up equalizer" );
gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , shaded );
}
int
clip_GTK_ACTIONGROUPGETACTION(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
gchar *name = _clip_parc(ClipMachineMemory, 2);
GtkAction *action;
C_object *caction;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
LOCALE_TO_UTF(name);
action = gtk_action_group_get_action(GTK_ACTION_GROUP(cagroup->object), name);
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);
}
FREE_TEXT(name);
return 0;
err:
return 1;
}
void
gimp_action_group_set_action_active (GimpActionGroup *group,
const gchar *action_name,
gboolean active)
{
GtkAction *action;
g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
g_return_if_fail (action_name != NULL);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
if (! action)
{
g_warning ("%s: Unable to set \"active\" of action "
"which doesn't exist: %s",
G_STRFUNC, action_name);
return;
}
if (! GTK_IS_TOGGLE_ACTION (action))
{
g_warning ("%s: Unable to set \"active\" of action "
"which is not a GtkToggleAction: %s",
G_STRFUNC, action_name);
return;
}
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
active ? TRUE : FALSE);
}
static void
tool_options_actions_update_presets (GimpActionGroup *group,
const gchar *action_prefix,
GCallback callback,
const gchar *help_id,
GimpContainer *presets)
{
GList *list;
gint n_children = 0;
gint i;
for (i = 0; ; i++)
{
gchar *action_name;
GtkAction *action;
action_name = g_strdup_printf ("%s-%03d", action_prefix, i);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
g_free (action_name);
if (! action)
break;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
}
if (presets)
n_children = gimp_container_get_n_children (presets);
if (n_children > 0)
{
GimpEnumActionEntry entry;
entry.name = NULL;
entry.label = NULL;
entry.accelerator = "";
entry.tooltip = NULL;
entry.value = 0;
entry.value_variable = FALSE;
entry.help_id = help_id;
for (list = GIMP_LIST (presets)->list, i = 0;
list;
list = g_list_next (list), i++)
{
GimpObject *options = list->data;
entry.name = g_strdup_printf ("%s-%03d", action_prefix, i);
entry.label = gimp_object_get_name (options);
entry.stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (options));
entry.value = i;
gimp_action_group_add_enum_actions (group, NULL, &entry, 1, callback);
g_free ((gchar *) entry.name);
}
}
}
static gboolean
geyes_applet_fill (MatePanelApplet *applet)
{
EyesApplet *eyes_applet;
GtkActionGroup *action_group;
gchar *ui_path;
g_set_application_name (_("Eyes"));
gtk_window_set_default_icon_name ("mate-eyes-applet");
mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
mate_panel_applet_set_background_widget (applet, GTK_WIDGET (applet));
eyes_applet = create_eyes (applet);
eyes_applet->timeout_id = g_timeout_add (
UPDATE_TIMEOUT, (GSourceFunc) timer_cb, eyes_applet);
action_group = gtk_action_group_new ("Geyes Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group,
geyes_applet_menu_actions,
G_N_ELEMENTS (geyes_applet_menu_actions),
eyes_applet);
ui_path = g_build_filename (GEYES_MENU_UI_DIR, "geyes-applet-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file (eyes_applet->applet,
ui_path, action_group);
g_free (ui_path);
if (mate_panel_applet_get_locked_down (eyes_applet->applet)) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "Props");
gtk_action_set_visible (action, FALSE);
}
g_object_unref (action_group);
gtk_widget_set_tooltip_text (GTK_WIDGET (eyes_applet->applet), _("Eyes"));
set_atk_name_description (GTK_WIDGET (eyes_applet->applet), _("Eyes"),
_("The eyes look in the direction of the mouse pointer"));
g_signal_connect (eyes_applet->vbox,
"dispose",
G_CALLBACK (dispose_cb),
eyes_applet);
gtk_widget_show_all (GTK_WIDGET (eyes_applet->applet));
/* setup here and not in create eyes so the destroy signal is set so
* that when there is an error within loading the theme
* we can emit this signal */
if (properties_load (eyes_applet) == FALSE)
return FALSE;
setup_eyes (eyes_applet);
return TRUE;
}
void
liferea_shell_set_view_mode (nodeViewType newMode)
{
GtkRadioAction *action;
action = GTK_RADIO_ACTION (gtk_action_group_get_action (shell->priv->generalActions, "NormalView"));
gtk_radio_action_set_current_value (action, newMode);
}
static void
nemo_desktop_window_constructed (GObject *obj)
{
GtkActionGroup *action_group;
GtkAction *action;
AtkObject *accessible;
NemoDesktopWindow *window = NEMO_DESKTOP_WINDOW (obj);
NemoWindow *nwindow = NEMO_WINDOW (obj);
G_OBJECT_CLASS (nemo_desktop_window_parent_class)->constructed (obj);
g_object_set_data (G_OBJECT (window), "monitor_number",
GINT_TO_POINTER (window->details->monitor));
gtk_widget_hide (nwindow->details->statusbar);
gtk_widget_hide (nwindow->details->menubar);
action_group = nemo_window_get_main_action_group (nwindow);
/* Don't allow close action on desktop */
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_CLOSE);
gtk_action_set_sensitive (action, FALSE);
/* Don't allow new tab on desktop */
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_NEW_TAB);
gtk_action_set_sensitive (action, FALSE);
/* Set the accessible name so that it doesn't inherit the cryptic desktop URI. */
accessible = gtk_widget_get_accessible (GTK_WIDGET (window));
if (accessible) {
atk_object_set_name (accessible, _("Desktop"));
}
nemo_desktop_window_update_geometry (window);
gtk_window_set_resizable (GTK_WINDOW (window),
FALSE);
gtk_window_set_decorated (GTK_WINDOW (window),
FALSE);
gtk_widget_show (GTK_WIDGET (window));
}
static void
nemo_window_update_split_view_actions_sensitivity (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
gboolean have_multiple_panes;
gboolean next_pane_is_in_same_location;
GFile *active_pane_location;
GFile *next_pane_location;
NemoWindowPane *next_pane;
NemoWindowSlot *active_slot;
active_slot = nemo_window_get_active_slot (window);
action_group = nemo_window_get_main_action_group (window);
/* collect information */
have_multiple_panes = nemo_window_split_view_showing (window);
if (active_slot != NULL) {
active_pane_location = nemo_window_slot_get_location (active_slot);
} else {
active_pane_location = NULL;
}
next_pane = nemo_window_get_next_pane (window);
if (next_pane && next_pane->active_slot) {
next_pane_location = nemo_window_slot_get_location (next_pane->active_slot);
next_pane_is_in_same_location = (active_pane_location && next_pane_location &&
g_file_equal (active_pane_location, next_pane_location));
} else {
next_pane_location = NULL;
next_pane_is_in_same_location = FALSE;
}
/* switch to next pane */
action = gtk_action_group_get_action (action_group, "SplitViewNextPane");
gtk_action_set_sensitive (action, have_multiple_panes);
/* same location */
action = gtk_action_group_get_action (action_group, "SplitViewSameLocation");
gtk_action_set_sensitive (action, have_multiple_panes && !next_pane_is_in_same_location);
/* clean up */
g_clear_object (&active_pane_location);
g_clear_object (&next_pane_location);
}
void
block_priority_changed_handlers(ProcData *data, bool block)
{
gint i;
if (block) {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
priority_menu_entries[i].name));
g_signal_handlers_block_by_func(action, (gpointer)cb_renice, data);
}
} else {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
priority_menu_entries[i].name));
g_signal_handlers_unblock_by_func(action, (gpointer)cb_renice, data);
}
}
}
void shell_action_set_enabled(const gchar *action_name, gboolean setting)
{
GtkAction *action;
action = gtk_action_group_get_action(shell->action_group, action_name);
if (action) {
gtk_action_set_sensitive(action, setting);
}
}
static void
gdict_applet_set_menu_items_sensitive (GdictApplet *applet,
gboolean is_sensitive)
{
GtkAction *action;
action = gtk_action_group_get_action (applet->priv->context_menu_action_group,
"DictionaryClear");
gtk_action_set_sensitive (action, is_sensitive);
action = gtk_action_group_get_action (applet->priv->context_menu_action_group,
"DictionaryPrint");
gtk_action_set_sensitive (action, is_sensitive);
action = gtk_action_group_get_action (applet->priv->context_menu_action_group,
"DictionarySave");
gtk_action_set_sensitive (action, is_sensitive);
return;
}
void check_set (GtkActionGroup * action_group, const gchar * action_name,
gboolean is_on)
{
GtkAction * action = gtk_action_group_get_action (action_group, action_name);
g_return_if_fail (action != NULL);
gtk_toggle_action_set_active ((GtkToggleAction *) action, is_on);
}
static void
window_menus_set_bindings (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
action_group = nemo_window_get_main_action_group (window);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_TOOLBAR);
g_settings_bind (nemo_window_state,
NEMO_WINDOW_STATE_START_WITH_TOOLBAR,
action,
"active",
G_SETTINGS_BIND_DEFAULT);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_STATUSBAR);
g_settings_bind (nemo_window_state,
NEMO_WINDOW_STATE_START_WITH_STATUS_BAR,
action,
"active",
G_SETTINGS_BIND_DEFAULT);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_SIDEBAR);
g_settings_bind (nemo_window_state,
NEMO_WINDOW_STATE_START_WITH_SIDEBAR,
action,
"active",
G_SETTINGS_BIND_DEFAULT);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_LOCATION_ENTRY);
g_settings_bind (nemo_preferences,
NEMO_PREFERENCES_SHOW_LOCATION_ENTRY,
action,
"active",
G_SETTINGS_BIND_DEFAULT);
}
void
update_sensitivity(ProcData *data)
{
const char * const selected_actions[] = { "StopProcess",
"ContProcess",
"EndProcess",
"KillProcess",
"ChangePriority",
"MemoryMaps",
"OpenFiles",
"ProcessProperties" };
const char * const processes_actions[] = { "ShowActiveProcesses",
"ShowAllProcesses",
"ShowMyProcesses",
"ShowDependencies",
"Refresh"
};
size_t i;
gboolean processes_sensitivity, selected_sensitivity;
GtkAction *action;
processes_sensitivity = (data->config.current_tab == PROCMAN_TAB_PROCESSES);
selected_sensitivity = (processes_sensitivity && data->selected_process != NULL);
if(data->endprocessbutton) {
/* avoid error on startup if endprocessbutton
has not been built yet */
gtk_widget_set_sensitive(data->endprocessbutton, selected_sensitivity);
}
for (i = 0; i != G_N_ELEMENTS(processes_actions); ++i) {
action = gtk_action_group_get_action(data->action_group,
processes_actions[i]);
gtk_action_set_sensitive(action, processes_sensitivity);
}
for (i = 0; i != G_N_ELEMENTS(selected_actions); ++i) {
action = gtk_action_group_get_action(data->action_group,
selected_actions[i]);
gtk_action_set_sensitive(action, selected_sensitivity);
}
}
static gboolean python_console_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
MainWindow *mainwin;
GtkToggleAction *action;
mainwin = mainwindow_get_mainwindow();
action = GTK_TOGGLE_ACTION(gtk_action_group_get_action(mainwin->action_group, "Tools/ShowPythonConsole"));
gtk_toggle_action_set_active(action, FALSE);
return TRUE;
}
GtkAction * get_action_by_name(const gchar *name)
{
int p;
GtkAction *rc = NULL;
for(p = 0; action_group[p] && !rc; p++)
rc = gtk_action_group_get_action(action_group[p],name);
return rc;
}
void
caja_navigation_window_allow_forward (CajaNavigationWindow *window, gboolean allow)
{
GtkAction *action;
action = gtk_action_group_get_action (window->details->navigation_action_group,
CAJA_ACTION_FORWARD);
gtk_action_set_sensitive (action, allow);
}
void
nautilus_navigation_window_allow_forward (NautilusNavigationWindow *window, gboolean allow)
{
GtkAction *action;
action = gtk_action_group_get_action (window->details->navigation_action_group,
NAUTILUS_ACTION_FORWARD);
gtk_action_set_sensitive (action, allow);
}
static void
show_view_update_zoom_sensitivity (PlannerShowView *view)
{
gboolean in, out;
planner_gantt_chart_can_zoom (PLANNER_GANTT_CHART (view->priv->gantt),
&in,
&out);
g_object_set (gtk_action_group_get_action (GTK_ACTION_GROUP(view->priv->actions),
"ZoomIn"),
"sensitive", in,
NULL);
g_object_set (gtk_action_group_get_action (GTK_ACTION_GROUP(view->priv->actions),
"ZoomOut"),
"sensitive", out,
NULL);
}
static void
set_action_sensitive (BrowserData *data,
const char *action_name,
gboolean sensitive)
{
GtkAction *action;
action = gtk_action_group_get_action (data->action_group, action_name);
g_object_set (action, "sensitive", sensitive, NULL);
}
static void
setup_search_action (NemoWindowPane *pane)
{
GtkActionGroup *group = pane->action_group;
GtkAction *action;
action = gtk_action_group_get_action (group, NEMO_ACTION_SEARCH);
g_signal_connect (action, "activate",
G_CALLBACK (action_show_hide_search_callback), pane);
}
static void
set_action_sensitive (GthMediaViewerPage *self,
const char *action_name,
gboolean sensitive)
{
GtkAction *action;
action = gtk_action_group_get_action (self->priv->actions, action_name);
g_object_set (action, "sensitive", sensitive, NULL);
}
static void
search_bar_cancel_callback (GtkWidget *widget,
NemoWindowPane *pane)
{
GtkAction *search;
search = gtk_action_group_get_action (pane->action_group,
NEMO_ACTION_SEARCH);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (search), FALSE);
}
static void
query_editor_cancel_callback (NemoQueryEditor *editor,
NemoWindowSlot *slot)
{
GtkAction *search;
search = gtk_action_group_get_action (slot->pane->toolbar_action_group,
NEMO_ACTION_SEARCH);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (search), FALSE);
}
