/**
* thunar_history_set_action_group:
* @history : a #ThunarHistory.
* @action_group : a #GtkActionGroup or %NULL.
*
* Attaches @history to the specified @action_group,
* and thereby registers the actions "back" and
* "forward" provided by @history on the given
* @action_group.
**/
void
thunar_history_set_action_group (ThunarHistory *history,
GtkActionGroup *action_group)
{
_thunar_return_if_fail (THUNAR_IS_HISTORY (history));
_thunar_return_if_fail (action_group == NULL || GTK_IS_ACTION_GROUP (action_group));
/* verify that we don't already use that action group */
if (G_UNLIKELY (history->action_group == action_group))
return;
/* disconnect from the previous action group */
if (G_UNLIKELY (history->action_group != NULL))
{
gtk_action_group_remove_action (history->action_group, history->action_back);
gtk_action_group_remove_action (history->action_group, history->action_forward);
g_object_unref (G_OBJECT (history->action_group));
}
/* activate the new action group */
history->action_group = action_group;
/* connect to the new action group */
if (G_LIKELY (action_group != NULL))
{
g_object_ref (G_OBJECT (action_group));
gtk_action_group_add_action_with_accel (action_group, history->action_back, "<alt>Left");
gtk_action_group_add_action_with_accel (action_group, history->action_forward, "<alt>Right");
}
/* notify listeners */
g_object_notify (G_OBJECT (history), "action-group");
}
static void
empathy_mic_menu_microphone_removed_cb (EmpathyMicMonitor *monitor,
guint source_idx,
EmpathyMicMenu *self)
{
EmpathyMicMenuPrivate *priv = self->priv;
GList *l;
for (l = priv->microphones->head; l != NULL; l = l->next)
{
GtkRadioAction *action = l->data;
gint value;
g_object_get (action, "value", &value, NULL);
if (value != (gint) source_idx)
{
action = NULL;
continue;
}
g_signal_handlers_disconnect_by_func (action,
G_CALLBACK (empathy_mic_menu_activate_cb), self);
gtk_action_group_remove_action (priv->action_group, GTK_ACTION (action));
g_queue_remove (priv->microphones, action);
break;
}
empathy_mic_menu_update (self);
}
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->menu_paths) &&
! plug_in_proc->file_proc)
{
GtkAction *action;
#if 0
g_print ("%s: %s\n", G_STRFUNC,
gimp_object_get_name (GIMP_OBJECT (procedure)));
#endif
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
GIMP_OBJECT (procedure)->name);
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
}
}
}
static VALUE
rg_remove_action(VALUE self, VALUE action)
{
gtk_action_group_remove_action(_SELF(self), GTK_ACTION(RVAL2GOBJ(action)));
G_CHILD_REMOVE(self, action);
return self;
}
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);
}
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 void
remove_action_item (GtkAction *action, GtkUIManager *manager)
{
guint menu_merge_id;
GList *actions, *l;
menu_merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (action), "merge-id"));
gtk_ui_manager_remove_ui (GTK_UI_MANAGER (manager), menu_merge_id);
actions = gtk_action_group_list_actions (devices_action_group);
for (l = actions; l != NULL; l = l->next) {
GtkAction *a = l->data;
/* Don't remove the top-level action straight away */
if (g_str_equal (gtk_action_get_name (a), gtk_action_get_name (action)) != FALSE)
continue;
/* But remove all the sub-actions for it */
if (g_str_has_prefix (gtk_action_get_name (a), gtk_action_get_name (action)) != FALSE)
gtk_action_group_remove_action (devices_action_group, a);
}
g_list_free (actions);
gtk_action_group_remove_action (devices_action_group, action);
}
G_MODULE_EXPORT void rc_plugin_module_exit()
{
if(tag_reader_bin!=NULL)
{
gst_element_set_state(tag_reader_bin, GST_STATE_NULL);
gst_object_unref(tag_reader_bin);
}
if(table_id>0)
rc_gui_view_remove_page(table_id);
if(menu_id>0)
{
gtk_ui_manager_remove_ui(rc_gui_get_ui_manager(), menu_id);
gtk_action_group_remove_action(rc_gui_get_action_group(),
gtk_action_group_get_action(rc_gui_get_action_group(),
"EditTagEditor"));
}
if(popup_id>0)
{
gtk_ui_manager_remove_ui(rc_gui_get_ui_manager(), popup_id);
gtk_action_group_remove_action(rc_gui_get_action_group(),
gtk_action_group_get_action(rc_gui_get_action_group(),
"List2TagEditor"));
}
}
static void
windows_actions_dock_window_removed (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpActionGroup *group)
{
GtkAction *action;
gchar *action_name = windows_actions_dock_window_to_action_name (dock_window);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_free (action_name);
}
static void
node_removed_cb (EphyNode *parent,
EphyNode *child,
guint index,
GtkActionGroup *action_group)
{
GtkAction *action;
char name[EPHY_OPEN_TABS_ACTION_NAME_BUFFER_SIZE];
EPHY_OPEN_TABS_ACTION_NAME_PRINTF (name, child);
action = gtk_action_group_get_action (action_group, name);
if (action != NULL) {
gtk_action_group_remove_action (action_group, action);
}
}
static void
windows_actions_display_remove (GimpContainer *container,
GimpDisplay *display,
GimpActionGroup *group)
{
GtkAction *action;
gchar *action_name = gimp_display_get_action_name (display);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_free (action_name);
windows_actions_update_display_accels (group);
}
static void
window_actions_display_closed (GdkDisplay *display,
gboolean is_error,
GimpActionGroup *group)
{
const gchar *group_name;
gint n_screens;
gint i;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
gchar *screen_name;
gchar *action_name;
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
if (action)
{
GSList *radio_group;
radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (action));
if (radio_group->data == (gpointer) action)
radio_group = radio_group->next;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
}
g_free (action_name);
}
}
int
clip_GTK_ACTIONGROUPREMOVEACTION(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
C_object *caction = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(caction, GTK_IS_ACTION(caction->object));
gtk_action_group_remove_action(GTK_ACTION_GROUP(cagroup->object), GTK_ACTION(caction->object));
return 0;
err:
return 1;
}
static void
windows_actions_recent_remove (GimpContainer *container,
GimpSessionInfo *info,
GimpActionGroup *group)
{
GtkAction *action;
gint info_id;
gchar *action_name;
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 = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
if (action)
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_free (action_name);
}
static void remove_python_scripts_menus(void)
{
GSList *walk;
MainWindow *mainwin;
mainwin = mainwindow_get_mainwindow();
/* toolbar */
for(walk = python_mainwin_scripts_names; walk; walk = walk->next)
prefs_toolbar_unregister_plugin_item(TOOLBAR_MAIN, "Python", walk->data);
/* ui */
for(walk = python_mainwin_scripts_id_list; walk; walk = walk->next)
gtk_ui_manager_remove_ui(mainwin->ui_manager, GPOINTER_TO_UINT(walk->data));
g_slist_free(python_mainwin_scripts_id_list);
python_mainwin_scripts_id_list = NULL;
/* actions */
for(walk = python_mainwin_scripts_names; walk; walk = walk->next) {
GtkAction *action;
gchar *entry;
entry = g_strconcat(PYTHON_SCRIPTS_ACTION_PREFIX, walk->data, NULL);
action = gtk_action_group_get_action(mainwin->action_group, entry);
g_free(entry);
if(action)
gtk_action_group_remove_action(mainwin->action_group, action);
g_free(walk->data);
}
g_slist_free(python_mainwin_scripts_names);
python_mainwin_scripts_names = NULL;
/* compose scripts */
for(walk = python_compose_scripts_names; walk; walk = walk->next) {
prefs_toolbar_unregister_plugin_item(TOOLBAR_COMPOSE, "Python", walk->data);
g_free(walk->data);
}
g_slist_free(python_compose_scripts_names);
python_compose_scripts_names = NULL;
}
static void
remove_menu(struct menu_priv *item, int recursive)
{
if (recursive) {
struct menu_priv *next,*child=item->child;
while (child) {
next=child->sibling;
remove_menu(child, recursive);
child=next;
}
}
if (item->action) {
gtk_ui_manager_remove_ui(item->gui->menu_manager, item->merge_id);
gtk_action_group_remove_action(item->gui->dyn_group, item->action);
#if 0
if (item->callback)
g_signal_handler_disconnect(item->action, item->handler_id);
#endif
g_object_unref(item->action);
}
g_free(item->path);
g_free(item);
}
static void
tool_options_actions_update_presets (GimpActionGroup *group,
const gchar *action_prefix,
GCallback callback,
const gchar *help_id,
GimpContainer *presets,
gboolean need_writable,
gboolean need_deletable)
{
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 *preset = list->data;
GdkPixbuf *pixbuf = NULL;
entry.name = g_strdup_printf ("%s-%03d", action_prefix, i);
entry.label = gimp_object_get_name (preset);
entry.icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (preset));
entry.value = i;
g_object_get (preset, "icon-pixbuf", &pixbuf, NULL);
gimp_action_group_add_enum_actions (group, NULL, &entry, 1, callback);
if (need_writable)
SET_SENSITIVE (entry.name,
gimp_data_is_writable (GIMP_DATA (preset)));
if (need_deletable)
SET_SENSITIVE (entry.name,
gimp_data_is_deletable (GIMP_DATA (preset)));
if (pixbuf)
gimp_action_group_set_action_pixbuf (group, entry.name, pixbuf);
g_free ((gchar *) entry.name);
}
}
}
static void
toolbar_visibility_refresh (EggEditableToolbar *etoolbar)
{
EggEditableToolbarPrivate *priv = etoolbar->priv;
gint n_toolbars, n_items, i, j, k;
GtkToggleAction *action;
GList *list;
GString *string;
gboolean showing;
char action_name[40];
char *action_label;
char *tmp;
if (priv == NULL || priv->model == NULL || priv->manager == NULL ||
priv->visibility_paths == NULL || priv->actions == NULL)
{
return;
}
if (priv->visibility_actions == NULL)
{
priv->visibility_actions = g_ptr_array_new ();
}
if (priv->visibility_id != 0)
{
gtk_ui_manager_remove_ui (priv->manager, priv->visibility_id);
}
priv->visibility_id = gtk_ui_manager_new_merge_id (priv->manager);
showing = gtk_widget_get_visible (GTK_WIDGET (etoolbar));
n_toolbars = egg_toolbars_model_n_toolbars (priv->model);
for (i = 0; i < n_toolbars; i++)
{
string = g_string_sized_new (0);
n_items = egg_toolbars_model_n_items (priv->model, i);
for (k = 0, j = 0; j < n_items; j++)
{
GValue value = { 0, };
GtkAction *action;
const char *name;
name = egg_toolbars_model_item_nth (priv->model, i, j);
if (name == NULL) continue;
action = find_action (etoolbar, name);
if (action == NULL) continue;
g_value_init (&value, G_TYPE_STRING);
g_object_get_property (G_OBJECT (action), "label", &value);
name = g_value_get_string (&value);
if (name == NULL)
{
g_value_unset (&value);
continue;
}
k += g_utf8_strlen (name, -1) + 2;
if (j > 0)
{
g_string_append (string, ", ");
if (j > 1 && k > 25)
{
g_value_unset (&value);
break;
}
}
g_string_append (string, name);
g_value_unset (&value);
}
if (j < n_items)
{
g_string_append (string, " ...");
}
tmp = g_string_free (string, FALSE);
for (j = 0, k = 0; tmp[j]; j++)
{
if (tmp[j] == '_') continue;
tmp[k] = tmp[j];
k++;
}
tmp[k] = 0;
/* Translaters: This string is for a toggle to display a toolbar.
* The name of the toolbar is automatically computed from the widgets
* on the toolbar, and is placed at the %s. Note the _ before the %s
* which is used to add mnemonics. We know that this is likely to
* produce duplicates, but don't worry about it. If your language
* normally has a mnemonic at the start, please use the _. If not,
* please remove. */
action_label = g_strdup_printf (_("Show “_%s”"), tmp);
g_free (tmp);
sprintf(action_name, "ToolbarToggle%d", i);
if (i >= priv->visibility_actions->len)
{
action = gtk_toggle_action_new (action_name, action_label, NULL, NULL);
g_ptr_array_add (priv->visibility_actions, action);
g_signal_connect_object (action, "toggled",
G_CALLBACK (toggled_visibility_cb),
etoolbar, 0);
gtk_action_group_add_action (priv->actions, GTK_ACTION (action));
}
else
{
action = g_ptr_array_index (priv->visibility_actions, i);
g_object_set (action, "label", action_label, NULL);
}
gtk_action_set_visible (GTK_ACTION (action), (egg_toolbars_model_get_flags (priv->model, i)
& EGG_TB_MODEL_NOT_REMOVABLE) == 0);
gtk_action_set_sensitive (GTK_ACTION (action), showing);
gtk_toggle_action_set_active (action, gtk_widget_get_visible
(get_dock_nth (etoolbar, i)));
for (list = priv->visibility_paths; list != NULL; list = g_list_next (list))
{
gtk_ui_manager_add_ui (priv->manager, priv->visibility_id,
(const char *)list->data, action_name, action_name,
GTK_UI_MANAGER_MENUITEM, FALSE);
}
g_free (action_label);
}
gtk_ui_manager_ensure_update (priv->manager);
while (i < priv->visibility_actions->len)
{
action = g_ptr_array_index (priv->visibility_actions, i);
g_ptr_array_remove_index_fast (priv->visibility_actions, i);
gtk_action_group_remove_action (priv->actions, GTK_ACTION (action));
i++;
}
}
void
gtkhtml_editor_update_context (GtkhtmlEditor *editor)
{
GtkHTML *html;
HTMLType type;
HTMLObject *object;
GtkUIManager *manager;
GtkActionGroup *action_group;
GList *list;
gboolean visible;
guint merge_id;
html = gtkhtml_editor_get_html (editor);
manager = gtkhtml_editor_get_ui_manager (editor);
gtk_html_update_styles (html);
/* Update context menu item visibility. */
object = html->engine->cursor->object;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
visible = (type == HTML_TYPE_IMAGE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_IMAGE), visible);
visible = (type == HTML_TYPE_LINKTEXT);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_LINK), visible);
visible = (type == HTML_TYPE_RULE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_RULE), visible);
visible = (type == HTML_TYPE_TEXT);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_TEXT), visible);
visible =
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_IMAGE)) ||
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_LINK)) ||
gtk_action_get_visible (ACTION (CONTEXT_PROPERTIES_TEXT));
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_PARAGRAPH), visible);
/* Set to visible if any of these are true:
* - Selection is active and contains a link.
* - Cursor is on a link.
* - Cursor is on an image that has a URL or target.
*/
visible =
(html_engine_is_selection_active (html->engine) &&
html_engine_selection_contains_link (html->engine)) ||
(type == HTML_TYPE_LINKTEXT) ||
(type == HTML_TYPE_IMAGE &&
(HTML_IMAGE (object)->url != NULL ||
HTML_IMAGE (object)->target != NULL));
gtk_action_set_visible (ACTION (CONTEXT_REMOVE_LINK), visible);
/* Get the parent object. */
object = (object != NULL) ? object->parent : NULL;
/* Get the grandparent object. */
object = (object != NULL) ? object->parent : NULL;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
visible = (type == HTML_TYPE_TABLECELL);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_CELL), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_COLUMN), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_ROW), visible);
gtk_action_set_visible (ACTION (CONTEXT_DELETE_TABLE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_COLUMN_AFTER), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_COLUMN_BEFORE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_ROW_ABOVE), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_ROW_BELOW), visible);
gtk_action_set_visible (ACTION (CONTEXT_INSERT_TABLE), visible);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_CELL), visible);
/* Get the great grandparent object. */
object = (object != NULL) ? object->parent : NULL;
if (object != NULL)
type = HTML_OBJECT_TYPE (object);
else
type = HTML_TYPE_NONE;
/* Note the |= (cursor must be in a table cell). */
visible |= (type == HTML_TYPE_TABLE);
gtk_action_set_visible (ACTION (CONTEXT_PROPERTIES_TABLE), visible);
/********************** Spell Check Suggestions **********************/
object = html->engine->cursor->object;
action_group = editor->priv->suggestion_actions;
/* Remove the old content from the context menu. */
merge_id = editor->priv->spell_suggestions_merge_id;
if (merge_id > 0) {
gtk_ui_manager_remove_ui (manager, merge_id);
editor->priv->spell_suggestions_merge_id = 0;
}
/* Clear the action group for spelling suggestions. */
list = gtk_action_group_list_actions (action_group);
while (list != NULL) {
GtkAction *action = list->data;
gtk_action_group_remove_action (action_group, action);
list = g_list_delete_link (list, list);
}
/* Decide if we should show spell checking items. */
visible =
!html_engine_is_selection_active (html->engine) &&
object != NULL && html_object_is_text (object) &&
!html_engine_spell_word_is_valid (html->engine);
action_group = editor->priv->spell_check_actions;
gtk_action_group_set_visible (action_group, visible);
/* Exit early if spell checking items are invisible. */
if (!visible)
return;
list = editor->priv->active_spell_checkers;
merge_id = gtk_ui_manager_new_merge_id (manager);
editor->priv->spell_suggestions_merge_id = merge_id;
/* Handle a single active language as a special case. */
if (g_list_length (list) == 1) {
editor_inline_spelling_suggestions (editor, list->data);
return;
}
/* Add actions and context menu content for active languages. */
g_list_foreach (list, (GFunc) editor_spell_checkers_foreach, editor);
}
static void
anjuta_docman_update_documents_menu (AnjutaDocman* docman)
{
AnjutaDocmanPriv *priv = docman->priv;
GtkUIManager* ui = GTK_UI_MANAGER (anjuta_shell_get_ui (ANJUTA_PLUGIN (priv->plugin)->shell,
NULL));
GList *actions, *l;
gint n, i;
guint id;
GSList *group = NULL;
g_return_if_fail (priv->documents_action_group != NULL);
if (priv->documents_merge_id != 0)
gtk_ui_manager_remove_ui (ui,
priv->documents_merge_id);
actions = gtk_action_group_list_actions (priv->documents_action_group);
for (l = actions; l != NULL; l = l->next)
{
g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data),
G_CALLBACK (on_document_toggled),
docman);
gtk_action_group_remove_action (priv->documents_action_group,
GTK_ACTION (l->data));
}
g_list_free (actions);
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (docman));
id = (n > 0) ? gtk_ui_manager_new_merge_id (ui) : 0;
for (i = 0; i < n; i++)
{
AnjutaDocmanPage* page;
GtkRadioAction *action;
gchar *action_name;
const gchar *tab_name;
gchar *accel;
page = anjuta_docman_get_nth_page (docman, i);
/* NOTE: the action is associated to the position of the tab in
* the notebook not to the tab itself! This is needed to work
* around the gtk+ bug #170727: gtk leaves around the accels
* of the action. Since the accel depends on the tab position
* the problem is worked around, action with the same name always
* get the same accel.
*/
action_name = g_strdup_printf ("Tab_%d", i);
tab_name = gtk_label_get_label (GTK_LABEL (page->label));
/* alt + 1, 2, 3... 0 to switch to the first ten tabs */
accel = (i < 10) ? g_strdup_printf ("<alt>%d", (i + 1) % 10) : NULL;
action = gtk_radio_action_new (action_name,
tab_name,
NULL,
NULL,
i);
if (group != NULL)
gtk_radio_action_set_group (action, group);
/* note that group changes each time we add an action, so it must be updated */
group = gtk_radio_action_get_group (action);
gtk_action_group_add_action_with_accel (priv->documents_action_group,
GTK_ACTION (action),
accel);
g_signal_connect (action,
"toggled",
G_CALLBACK (on_document_toggled),
docman);
gtk_ui_manager_add_ui (ui,
id,
MENU_PLACEHOLDER,
action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
if (i == gtk_notebook_get_current_page (GTK_NOTEBOOK (docman)))
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
g_object_unref (action);
g_free (action_name);
g_free (accel);
}
anjuta_docman_update_documents_menu_status (docman);
priv->documents_merge_id = id;
}
