int vwin_menu_add_item_unique (windata_t *vwin,
const gchar *aname,
const gchar *path,
GtkActionEntry *entry)
{
GList *list = gtk_ui_manager_get_action_groups(vwin->ui);
GtkActionGroup *actions;
guint id;
while (list != NULL) {
GtkActionGroup *group = list->data;
if (!strcmp(aname, gtk_action_group_get_name(group))) {
gtk_ui_manager_remove_action_group(vwin->ui, group);
break;
}
list = list->next;
}
id = gtk_ui_manager_new_merge_id(vwin->ui);
actions = gtk_action_group_new(aname);
gtk_action_group_set_translation_domain(actions, "gretl");
gtk_action_group_add_actions(actions, entry, 1, vwin);
gtk_ui_manager_add_ui(vwin->ui, id, path, entry->name, entry->name,
GTK_UI_MANAGER_MENUITEM, FALSE);
gtk_ui_manager_insert_action_group(vwin->ui, actions, 0);
g_object_unref(actions);
return id;
}
static GtkActionGroup *get_named_group (GtkUIManager *uim,
const char *name,
int *newgroup)
{
GList *list = gtk_ui_manager_get_action_groups(uim);
GtkActionGroup *actions = NULL;
while (list != NULL) {
GtkActionGroup *group = list->data;
if (!strcmp(gtk_action_group_get_name(group), name)) {
actions = group;
break;
}
list = list->next;
}
if (actions == NULL) {
actions = gtk_action_group_new(name);
gtk_action_group_set_translation_domain(actions, "gretl");
*newgroup = 1;
} else {
*newgroup = 0;
}
return actions;
}
static void
gimp_action_group_constructed (GObject *object)
{
GimpActionGroup *group = GIMP_ACTION_GROUP (object);
const gchar *name;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (GIMP_IS_GIMP (group->gimp));
name = gtk_action_group_get_name (GTK_ACTION_GROUP (object));
if (name)
{
GimpActionGroupClass *group_class;
GList *list;
group_class = GIMP_ACTION_GROUP_GET_CLASS (object);
list = g_hash_table_lookup (group_class->groups, name);
list = g_list_append (list, object);
g_hash_table_replace (group_class->groups,
g_strdup (name), list);
}
}
static void
gimp_action_group_dispose (GObject *object)
{
const gchar *name = gtk_action_group_get_name (GTK_ACTION_GROUP (object));
if (name)
{
GimpActionGroupClass *group_class;
GList *list;
group_class = GIMP_ACTION_GROUP_GET_CLASS (object);
list = g_hash_table_lookup (group_class->groups, name);
if (list)
{
list = g_list_remove (list, object);
if (list)
g_hash_table_replace (group_class->groups,
g_strdup (name), list);
else
g_hash_table_remove (group_class->groups, name);
}
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
node_added_cb (EphyNode *parent,
EphyNode *child,
GtkActionGroup *action_group)
{
GObject *action_object;
GtkAction *action;
char name[EPHY_OPEN_TABS_ACTION_NAME_BUFFER_SIZE];
char accel[256];
EPHY_OPEN_TABS_ACTION_NAME_PRINTF (name, child);
/* FIXME !!!! */
action = gtk_action_new (name, _("Open in New _Tabs"),
_("Open the bookmarks in this topic in new tabs"), NULL);
action_object = (GObject *)action;
g_object_set_data (action_object, "ephy-node", child);
g_object_set_data (action_object, "ephy-link", EPHY_LINK (action_group));
g_signal_connect (action, "activate",
G_CALLBACK (activate_cb), NULL);
g_snprintf (accel, sizeof (accel), "<Actions>/%s/%s",
gtk_action_group_get_name (action_group),
name);
gtk_action_set_accel_path (action, accel);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
}
char *
_moo_action_make_accel_path (gpointer action)
{
GtkActionGroup *group = NULL;
MooActionCollection *collection;
const char *name, *group_name, *collection_name;
g_return_val_if_fail (MOO_IS_ACTION_BASE (action), NULL);
group = _moo_action_get_group (action);
g_return_val_if_fail (MOO_IS_ACTION_GROUP (group), NULL);
collection = _moo_action_group_get_collection (MOO_ACTION_GROUP (group));
g_return_val_if_fail (MOO_IS_ACTION_COLLECTION (collection), NULL);
name = gtk_action_get_name (GTK_ACTION (action));
group_name = gtk_action_group_get_name (group);
collection_name = moo_action_collection_get_name (collection);
g_return_val_if_fail (collection_name != NULL, NULL);
g_return_val_if_fail (name != NULL && name[0] != 0, NULL);
if (group_name)
return g_strdup_printf ("<MooAction>/%s/%s/%s", collection_name, group_name, name);
else
return g_strdup_printf ("<MooAction>/%s/%s", collection_name, name);
}
void
window_actions_update (GimpActionGroup *group,
GtkWidget *window)
{
const gchar *group_name;
gint show_menu = FALSE;
gchar *name;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GTK_IS_WINDOW (window))
{
GdkDisplay *display;
GdkScreen *screen;
gchar *screen_name;
display = gtk_widget_get_display (window);
show_menu = (gdk_display_get_n_screens (display) > 1);
#ifdef GIMP_UNSTABLE
show_menu = TRUE;
#endif
if (! show_menu)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
displays = gdk_display_manager_list_displays (manager);
show_menu = (displays->next != NULL);
g_slist_free (displays);
}
screen = gtk_widget_get_screen (window);
screen_name = gdk_screen_make_display_name (screen);
name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name);
g_free (screen_name);
SET_ACTIVE (name, TRUE);
g_free (name);
}
name = g_strdup_printf ("%s-move-to-screen-menu", group_name);
SET_VISIBLE (name, show_menu);
g_free (name);
#undef SET_ACTIVE
#undef SET_VISIBLE
}
static gboolean
gimp_action_group_check_unique_action (GimpActionGroup *group,
const gchar *action_name)
{
if (G_UNLIKELY (gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name)))
{
g_warning ("Refusing to add non-unique action '%s' to action group '%s'",
action_name,
gtk_action_group_get_name (GTK_ACTION_GROUP (group)));
return FALSE;
}
return TRUE;
}
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);
}
}
GtkActionGroup *
giggle_ui_manager_get_action_group (GtkUIManager *manager,
const char *group_name)
{
GList *groups;
groups = gtk_ui_manager_get_action_groups (manager);
while (groups) {
if (!g_strcmp0 (group_name,
gtk_action_group_get_name (groups->data)))
return groups->data;
groups = groups->next;
}
return NULL;
}
/**
* _rb_source_register_action_group:
* @source: a #RBSource
* @group_name: action group name
* @actions: array of GtkActionEntry structures for the action group
* @num_actions: number of actions in the @actions array
* @user_data: user data to use for action signal handlers
*
* Creates and registers a GtkActionGroup for the source.
*
* Return value: the created action group
*/
GtkActionGroup *
_rb_source_register_action_group (RBSource *source,
const char *group_name,
GtkActionEntry *actions,
int num_actions,
gpointer user_data)
{
GtkUIManager *uimanager;
GList *actiongroups;
GList *i;
GtkActionGroup *group;
g_return_val_if_fail (group_name != NULL, NULL);
g_object_get (source, "ui-manager", &uimanager, NULL);
actiongroups = gtk_ui_manager_get_action_groups (uimanager);
/* Don't create the action group if it's already registered */
for (i = actiongroups; i != NULL; i = i->next) {
const char *name;
name = gtk_action_group_get_name (GTK_ACTION_GROUP (i->data));
if (name != NULL && strcmp (name, group_name) == 0) {
group = GTK_ACTION_GROUP (i->data);
/* Add a reference */
g_object_ref (group);
goto out;
}
}
group = gtk_action_group_new (group_name);
gtk_action_group_set_translation_domain (group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (group,
actions, num_actions,
user_data);
gtk_ui_manager_insert_action_group (uimanager, group, 0);
out:
g_object_unref (uimanager);
return group;
}
static GtkActionGroup *
find_action_group (GtkUIManager *uimanager, const char *group_name)
{
GList *actiongroups;
GList *i;
actiongroups = gtk_ui_manager_get_action_groups (uimanager);
/* Don't create the action group if it's already registered */
for (i = actiongroups; i != NULL; i = i->next) {
const char *name;
name = gtk_action_group_get_name (GTK_ACTION_GROUP (i->data));
if (name != NULL && strcmp (name, group_name) == 0) {
return GTK_ACTION_GROUP (i->data);
}
}
return NULL;
}
int
clip_GTK_ACTIONGROUPGETNAME(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
gchar *name;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
name = (gchar *) gtk_action_group_get_name(GTK_ACTION_GROUP(cagroup->object));
LOCALE_FROM_UTF(name);
_clip_retc(ClipMachineMemory, name);
FREE_TEXT(name);
return 0;
err:
return 1;
}
GimpActionGroup *
gimp_ui_manager_get_action_group (GimpUIManager *manager,
const gchar *name)
{
GList *list;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
g_return_val_if_fail (name != NULL, NULL);
for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
if (! strcmp (name, gtk_action_group_get_name (GTK_ACTION_GROUP (group))))
return group;
}
return NULL;
}
static void
window_actions_display_opened (GdkDisplayManager *manager,
GdkDisplay *display,
GimpActionGroup *group)
{
GimpRadioActionEntry *entries;
const gchar *help_id;
const gchar *group_name;
GSList *radio_group;
gint n_screens;
gint i;
help_id = g_object_get_data (G_OBJECT (group), "change-to-screen-help-id");
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
entries = g_new0 (GimpRadioActionEntry, n_screens);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
gchar *screen_name;
screen_name = gdk_screen_make_display_name (screen);
entries[i].name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
entries[i].stock_id = GIMP_STOCK_MOVE_TO_SCREEN;
entries[i].label = g_strdup_printf (_("Screen %s"), screen_name);
entries[i].accelerator = NULL;
entries[i].tooltip = g_strdup_printf (_("Move this window to "
"screen %s"), screen_name);
entries[i].value = g_quark_from_string (screen_name);
entries[i].help_id = help_id;
g_free (screen_name);
}
radio_group = g_object_get_data (G_OBJECT (group),
"change-to-screen-radio-group");
radio_group = gimp_action_group_add_radio_actions (group, entries, n_screens,
radio_group, 0,
G_CALLBACK (window_move_to_screen_cmd_callback));
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
entries[i].name);
if (action)
g_object_set_data (G_OBJECT (action), "screen", screen);
g_free ((gchar *) entries[i].name);
g_free ((gchar *) entries[i].tooltip);
g_free ((gchar *) entries[i].label);
}
g_free (entries);
g_signal_connect_object (display, "closed",
G_CALLBACK (window_actions_display_closed),
G_OBJECT (group), 0);
}
static int
find_name (GtkActionGroup *action_group,
const char *name)
{
return strcmp (gtk_action_group_get_name (action_group), name);
}
gboolean
update(ParasiteActionList *actionlist)
{
GSList *i;
gtk_tree_store_clear(actionlist->priv->model);
for (i = actionlist->priv->uimanagers; i != NULL; i = g_slist_next(i))
{
GtkUIManager *uimanager;
GList *action_groups;
GList *j;
gchar *name;
uimanager = GTK_UI_MANAGER(i->data);
GtkTreeIter i_iter;
gtk_tree_store_append(actionlist->priv->model, &i_iter, NULL);
name = g_strdup_printf("UIManager at %p", uimanager);
gtk_tree_store_set(actionlist->priv->model, &i_iter,
ACTION_LABEL, name,
SORT_NAME, name,
ADDRESS, uimanager,
-1);
g_free(name);
action_groups = gtk_ui_manager_get_action_groups(uimanager);
for (j = action_groups; j != NULL; j = g_list_next(j))
{
GtkActionGroup *action_group;
GtkTreeIter j_iter;
GList *actions;
GList *k;
action_group = GTK_ACTION_GROUP(j->data);
gtk_tree_store_append(actionlist->priv->model, &j_iter, &i_iter);
name = (gchar*) gtk_action_group_get_name(action_group);
gtk_tree_store_set(actionlist->priv->model, &j_iter,
ACTION_LABEL, name,
SORT_NAME, name,
ROW_COLOR, gtk_action_group_get_sensitive(action_group)
? "black" : "grey",
ADDRESS, action_group,
-1);
actions = gtk_action_group_list_actions(action_group);
for (k = actions; k != NULL; k = g_list_next(k))
{
GtkTreeIter k_iter;
GtkAction *action;
gchar *action_label;
gchar *action_name;
gchar *action_stock;
gchar *sort_name;
action = GTK_ACTION(k->data);
g_object_get(action,
"label", &action_label,
"name", &action_name,
"stock-id", &action_stock,
NULL);
sort_name = g_strdup_printf("%s%s", name, action_name);
gtk_tree_store_append(actionlist->priv->model, &k_iter, &j_iter);
// FIXME: format the mnemonic
gtk_tree_store_set(actionlist->priv->model, &k_iter,
ACTION_LABEL, action_label,
ACTION_NAME, action_name,
ACTION_ICON, action_stock,
ROW_COLOR, gtk_action_is_sensitive(action)
? "black" : "grey",
SORT_NAME, sort_name,
ADDRESS, action,
-1);
g_free(sort_name);
g_free(action_stock);
g_free(action_name);
g_free(action_label);
}
}
}
// FIXME: I'm undecided about this, but I also don't really want to try to
// preserve the exsting expansion state of the whole tree.
gtk_tree_view_expand_all(GTK_TREE_VIEW(actionlist));
actionlist->priv->update_timeout = 0;
return FALSE;
}
