dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/widgets/gimpuimanager.c

1246 lines
39 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpuimanager.c
* Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "config/gimpxmlparser.h"
#include "core/gimp.h"
#include "gimpaction.h"
#include "gimpactiongroup.h"
#include "gimpradioaction.h"
#include "gimphelp.h"
#include "gimphelp-ids.h"
#include "gimpmenu.h"
#include "gimpmenumodel.h"
#include "gimpmenushell.h"
#include "gimptoggleaction.h"
#include "gimpuimanager.h"
#include "gimp-intl.h"
enum
{
PROP_0,
PROP_NAME,
PROP_GIMP
};
enum
{
UPDATE,
SHOW_TOOLTIP,
HIDE_TOOLTIP,
UI_ADDED,
UI_REMOVED,
LAST_SIGNAL
};
typedef struct
{
gchar *path;
gchar *action_name;
gboolean top;
} GimpUIManagerMenuItem;
static void gimp_ui_manager_constructed (GObject *object);
static void gimp_ui_manager_dispose (GObject *object);
static void gimp_ui_manager_finalize (GObject *object);
static void gimp_ui_manager_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_ui_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gimp_ui_manager_real_update (GimpUIManager *manager,
gpointer update_data);
static GimpUIManagerUIEntry *
gimp_ui_manager_entry_get (GimpUIManager *manager,
const gchar *ui_path);
static GimpUIManagerUIEntry *
gimp_ui_manager_entry_ensure (GimpUIManager *manager,
const gchar *path);
static void gimp_ui_manager_store_builder_path (GMenuModel *model,
GMenuModel *original);
static GtkBuilder * gimp_ui_manager_load_builder (const gchar *filename,
const gchar *root);
static void gimp_ui_manager_parse_start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error);
static void gimp_ui_manager_parse_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error);
static void gimp_ui_manager_parse_ui_text (GMarkupParseContext *context,
const gchar *text,
gsize text_len,
gpointer user_data,
GError **error);
static void gimp_ui_manager_delete_popdown_data (GtkWidget *widget,
GimpUIManager *manager);
static void gimp_ui_manager_menu_item_free (GimpUIManagerMenuItem *item);
static void gimp_ui_manager_popup_hidden (GtkMenuShell *popup,
gpointer user_data);
static gboolean gimp_ui_manager_popup_destroy (GtkWidget *popup);
static void gimp_ui_manager_image_action_added (GimpActionGroup *group,
gchar *action_name,
GimpUIManager *manager);
static void gimp_ui_manager_image_action_removed (GimpActionGroup *group,
gchar *action_name,
GimpUIManager *manager);
static void gimp_ui_manager_image_accels_changed (GimpAction *action,
const gchar **accels,
GimpUIManager *manager);
G_DEFINE_TYPE (GimpUIManager, gimp_ui_manager, GIMP_TYPE_OBJECT)
#define parent_class gimp_ui_manager_parent_class
static guint manager_signals[LAST_SIGNAL] = { 0 };
static void
gimp_ui_manager_class_init (GimpUIManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = gimp_ui_manager_constructed;
object_class->dispose = gimp_ui_manager_dispose;
object_class->finalize = gimp_ui_manager_finalize;
object_class->set_property = gimp_ui_manager_set_property;
object_class->get_property = gimp_ui_manager_get_property;
klass->update = gimp_ui_manager_real_update;
manager_signals[UPDATE] =
g_signal_new ("update",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpUIManagerClass, update),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
manager_signals[SHOW_TOOLTIP] =
g_signal_new ("show-tooltip",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpUIManagerClass, show_tooltip),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_STRING);
manager_signals[HIDE_TOOLTIP] =
g_signal_new ("hide-tooltip",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpUIManagerClass, hide_tooltip),
NULL, NULL, NULL,
G_TYPE_NONE, 0,
G_TYPE_NONE);
manager_signals[UI_ADDED] =
g_signal_new ("ui-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpUIManagerClass, ui_added),
NULL, NULL, NULL,
G_TYPE_NONE, 3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
manager_signals[UI_REMOVED] =
g_signal_new ("ui-removed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GimpUIManagerClass, ui_removed),
NULL, NULL, NULL,
G_TYPE_NONE, 2,
G_TYPE_STRING,
G_TYPE_STRING);
g_object_class_install_property (object_class, PROP_NAME,
g_param_spec_string ("name",
NULL, NULL,
NULL,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_GIMP,
g_param_spec_object ("gimp",
NULL, NULL,
GIMP_TYPE_GIMP,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
klass->managers = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
}
static void
gimp_ui_manager_init (GimpUIManager *manager)
{
manager->name = NULL;
manager->gimp = NULL;
manager->action_groups = NULL;
manager->store_action_paths = FALSE;
}
static void
gimp_ui_manager_constructed (GObject *object)
{
GimpUIManager *manager = GIMP_UI_MANAGER (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
if (manager->name)
{
GimpUIManagerClass *manager_class;
GList *list;
manager_class = GIMP_UI_MANAGER_GET_CLASS (object);
list = g_hash_table_lookup (manager_class->managers, manager->name);
list = g_list_append (list, manager);
g_hash_table_replace (manager_class->managers,
g_strdup (manager->name), list);
}
}
static void
gimp_ui_manager_dispose (GObject *object)
{
GimpUIManager *manager = GIMP_UI_MANAGER (object);
if (manager->name)
{
GimpUIManagerClass *manager_class;
GList *list;
manager_class = GIMP_UI_MANAGER_GET_CLASS (object);
list = g_hash_table_lookup (manager_class->managers, manager->name);
if (list)
{
list = g_list_remove (list, manager);
if (list)
g_hash_table_replace (manager_class->managers,
g_strdup (manager->name), list);
else
g_hash_table_remove (manager_class->managers, manager->name);
}
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gimp_ui_manager_finalize (GObject *object)
{
GimpUIManager *manager = GIMP_UI_MANAGER (object);
GList *list;
for (list = manager->registered_uis; list; list = g_list_next (list))
{
GimpUIManagerUIEntry *entry = list->data;
g_free (entry->ui_path);
g_free (entry->basename);
g_clear_object (&entry->builder);
g_slice_free (GimpUIManagerUIEntry, entry);
}
g_clear_pointer (&manager->registered_uis, g_list_free);
g_clear_pointer (&manager->name, g_free);
g_list_free_full (manager->action_groups, g_object_unref);
g_list_free_full (manager->ui_items,
(GDestroyNotify) gimp_ui_manager_menu_item_free);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_ui_manager_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GimpUIManager *manager = GIMP_UI_MANAGER (object);
switch (prop_id)
{
case PROP_NAME:
g_free (manager->name);
manager->name = g_value_dup_string (value);
break;
case PROP_GIMP:
manager->gimp = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gimp_ui_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GimpUIManager *manager = GIMP_UI_MANAGER (object);
switch (prop_id)
{
case PROP_NAME:
g_value_set_string (value, manager->name);
break;
case PROP_GIMP:
g_value_set_object (value, manager->gimp);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gimp_ui_manager_real_update (GimpUIManager *manager,
gpointer update_data)
{
GList *list;
for (list = gimp_ui_manager_get_action_groups (manager);
list;
list = g_list_next (list))
{
gimp_action_group_update (list->data, update_data);
}
}
/**
* gimp_ui_manager_new:
* @gimp: the @Gimp instance this ui manager belongs to
* @name: the UI manager's name.
*
* Creates a new #GimpUIManager object.
*
* Returns: the new #GimpUIManager
*/
GimpUIManager *
gimp_ui_manager_new (Gimp *gimp,
const gchar *name)
{
GimpUIManager *manager;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
manager = g_object_new (GIMP_TYPE_UI_MANAGER,
"name", name,
"gimp", gimp,
NULL);
return manager;
}
GList *
gimp_ui_managers_from_name (const gchar *name)
{
GimpUIManagerClass *manager_class;
GList *list;
g_return_val_if_fail (name != NULL, NULL);
manager_class = g_type_class_ref (GIMP_TYPE_UI_MANAGER);
list = g_hash_table_lookup (manager_class->managers, name);
g_type_class_unref (manager_class);
return list;
}
void
gimp_ui_manager_update (GimpUIManager *manager,
gpointer update_data)
{
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_signal_emit (manager, manager_signals[UPDATE], 0, update_data);
}
void
gimp_ui_manager_add_action_group (GimpUIManager *manager,
GimpActionGroup *group)
{
if (! g_list_find (manager->action_groups, group))
manager->action_groups = g_list_prepend (manager->action_groups, g_object_ref (group));
/* Special-case the <Image> UI Manager which should be unique and represent
* global application actions.
*/
if (g_strcmp0 (manager->name, "<Image>") == 0)
{
gchar **actions = g_action_group_list_actions (G_ACTION_GROUP (group));
for (int i = 0; i < g_strv_length (actions); i++)
gimp_ui_manager_image_action_added (group, actions[i], manager);
g_signal_connect_object (group, "action-added",
G_CALLBACK (gimp_ui_manager_image_action_added),
manager, 0);
g_signal_connect_object (group, "action-removed",
G_CALLBACK (gimp_ui_manager_image_action_removed),
manager, 0);
g_strfreev (actions);
}
}
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 = gimp_ui_manager_get_action_groups (manager);
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
if (! strcmp (name, gimp_action_group_get_name (group)))
return group;
}
return NULL;
}
GList *
gimp_ui_manager_get_action_groups (GimpUIManager *manager)
{
return manager->action_groups;
}
GimpMenuModel *
gimp_ui_manager_get_model (GimpUIManager *manager,
const gchar *path)
{
GimpUIManagerUIEntry *entry;
GimpMenuModel *model;
GMenuModel *gmodel;
GimpMenuModel *submodel;
gchar *root;
gchar *submenus;
root = g_strdup (path);
submenus = strstr (root + 1, "/");
if (submenus != NULL)
{
*submenus = '\0';
if (*(++submenus) == '\0')
submenus = NULL;
}
entry = gimp_ui_manager_entry_ensure (manager, path);
g_return_val_if_fail (entry != NULL, NULL);
if (entry->builder == NULL)
{
const gchar *menus_path_override = g_getenv ("GIMP_TESTING_MENUS_PATH");
gchar *full_basename;
gchar *filename;
full_basename = g_strconcat (entry->basename, ".ui", NULL);
/* 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_path_override)
{
GList *paths = gimp_path_parse (menus_path_override, 2, FALSE, NULL);
GList *list;
for (list = paths; list; list = g_list_next (list))
{
filename = g_build_filename (list->data, full_basename, NULL);
if (! list->next ||
g_file_test (filename, G_FILE_TEST_EXISTS))
break;
g_clear_pointer (&filename, g_free);
}
g_list_free_full (paths, g_free);
}
else
{
filename = g_build_filename (gimp_data_directory (), "menus", full_basename, NULL);
}
g_return_val_if_fail (filename != NULL, NULL);
if (manager->gimp->be_verbose)
g_print ("Loading menu '%s' for %s\n",
gimp_filename_to_utf8 (filename), entry->ui_path);
/* The model is owned by the builder which I have to keep around. */
entry->builder = gimp_ui_manager_load_builder (filename, root);
g_free (filename);
g_free (full_basename);
}
gmodel = G_MENU_MODEL (gtk_builder_get_object (entry->builder, root));
g_return_val_if_fail (G_IS_MENU (gmodel), NULL);
model = gimp_menu_model_new (manager, gmodel);
submodel = gimp_menu_model_get_submodel (model, submenus);
g_object_unref (model);
g_free (root);
return submodel;
}
void
gimp_ui_manager_remove_ui (GimpUIManager *manager,
const gchar *action_name)
{
GList *iter = manager->ui_items;
g_return_if_fail (action_name != NULL);
for (; iter != NULL; iter = iter->next)
{
GimpUIManagerMenuItem *item = iter->data;
if (g_strcmp0 (item->action_name, action_name) == 0)
{
g_signal_emit (manager, manager_signals[UI_REMOVED], 0,
item->path, item->action_name);
manager->ui_items = g_list_delete_link (manager->ui_items, iter);
gimp_ui_manager_menu_item_free (item);
break;
}
}
}
void
gimp_ui_manager_remove_uis (GimpUIManager *manager,
const gchar *action_name_prefix)
{
GList *iter = manager->ui_items;
while (iter != NULL)
{
GimpUIManagerMenuItem *item = iter->data;
GList *current_iter = iter;
/* Increment nearly in case we delete the list item. */
iter = iter->next;
if (action_name_prefix == NULL ||
g_str_has_prefix (item->action_name, action_name_prefix))
{
g_signal_emit (manager, manager_signals[UI_REMOVED], 0,
item->path, item->action_name);
manager->ui_items = g_list_delete_link (manager->ui_items,
current_iter);
gimp_ui_manager_menu_item_free (item);
}
}
}
void
gimp_ui_manager_add_ui (GimpUIManager *manager,
const gchar *path,
const gchar *action_name,
gboolean top)
{
GimpUIManagerMenuItem *item;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (path != NULL);
g_return_if_fail (action_name != NULL);
item = g_slice_new0 (GimpUIManagerMenuItem);
item->path = g_strdup (path);
item->action_name = g_strdup (action_name);
item->top = top;
manager->ui_items = g_list_prepend (manager->ui_items, item);
g_signal_emit (manager, manager_signals[UI_ADDED], 0,
path, action_name, top);
}
void
gimp_ui_manager_foreach_ui (GimpUIManager *manager,
GimpUIMenuCallback callback,
gpointer user_data)
{
for (GList *iter = g_list_last (manager->ui_items); iter; iter = iter->prev)
{
GimpUIManagerMenuItem *item = iter->data;
callback (manager, item->path, item->action_name, item->top, user_data);
}
}
GimpAction *
gimp_ui_manager_find_action (GimpUIManager *manager,
const gchar *group_name,
const gchar *action_name)
{
GimpActionGroup *group;
GimpAction *action = NULL;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
g_return_val_if_fail (action_name != NULL, NULL);
if (g_strcmp0 (group_name, "app") == 0)
{
GApplication *app = manager->gimp->app;
action = (GimpAction *) g_action_map_lookup_action (G_ACTION_MAP (app), action_name);
}
else if (group_name)
{
group = gimp_ui_manager_get_action_group (manager, group_name);
if (group)
action = gimp_action_group_get_action (group, action_name);
}
else
{
GList *list;
gchar *dot;
dot = strstr (action_name, ".");
if (dot == NULL)
{
/* No group specified. */
for (list = gimp_ui_manager_get_action_groups (manager);
list;
list = g_list_next (list))
{
group = list->data;
action = gimp_action_group_get_action (group, action_name);
if (action)
break;
}
}
else
{
gchar *gname;
gname = g_strndup (action_name, dot - action_name);
action = gimp_ui_manager_find_action (manager, gname, dot + 1);
g_free (gname);
}
}
return action;
}
gboolean
gimp_ui_manager_activate_action (GimpUIManager *manager,
const gchar *group_name,
const gchar *action_name)
{
GimpAction *action;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), FALSE);
g_return_val_if_fail (action_name != NULL, FALSE);
action = gimp_ui_manager_find_action (manager, group_name, action_name);
if (action)
gimp_action_activate (action);
return (action != NULL);
}
gboolean
gimp_ui_manager_toggle_action (GimpUIManager *manager,
const gchar *group_name,
const gchar *action_name,
gboolean active)
{
GimpAction *action;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), FALSE);
g_return_val_if_fail (action_name != NULL, FALSE);
action = gimp_ui_manager_find_action (manager, group_name, action_name);
if (GIMP_IS_TOGGLE_ACTION (action))
gimp_toggle_action_set_active (GIMP_TOGGLE_ACTION (action),
active ? TRUE : FALSE);
return GIMP_IS_TOGGLE_ACTION (action);
}
void
gimp_ui_manager_ui_register (GimpUIManager *manager,
const gchar *ui_path,
const gchar *basename,
GimpUIManagerSetupFunc setup_func)
{
GimpUIManagerUIEntry *entry;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
g_return_if_fail (basename != NULL);
g_return_if_fail (gimp_ui_manager_entry_get (manager, ui_path) == NULL);
entry = g_slice_new0 (GimpUIManagerUIEntry);
entry->ui_path = g_strdup (ui_path);
entry->basename = g_strdup (basename);
entry->setup_func = setup_func;
entry->setup_done = FALSE;
entry->builder = NULL;
manager->registered_uis = g_list_prepend (manager->registered_uis, entry);
}
void
gimp_ui_manager_ui_popup_at_widget (GimpUIManager *manager,
const gchar *ui_path,
GimpUIManager *child_ui_manager,
const gchar *child_ui_path,
GtkWidget *widget,
GdkGravity widget_anchor,
GdkGravity menu_anchor,
const GdkEvent *trigger_event,
GDestroyNotify popdown_func,
gpointer popdown_data)
{
GimpMenuModel *model;
GtkWidget *menu;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
menu = gimp_menu_new (manager);
gtk_menu_attach_to_widget (GTK_MENU (menu), widget, NULL);
model = gimp_ui_manager_get_model (manager, ui_path);
g_return_if_fail (model != NULL);
gimp_menu_shell_fill (GIMP_MENU_SHELL (menu), model, TRUE);
g_object_unref (model);
if (! menu)
return;
if (child_ui_manager != NULL && child_ui_path != NULL)
{
GimpMenuModel *child_model;
GtkWidget *child_menu;
/* TODO GMenu: the "icon" attribute set in the .ui file should be visible. */
child_model = gimp_ui_manager_get_model (child_ui_manager, child_ui_path);
child_menu = gimp_menu_new (child_ui_manager);
gimp_menu_shell_fill (GIMP_MENU_SHELL (child_menu), child_model, FALSE);
g_object_unref (child_model);
gimp_menu_merge (GIMP_MENU (menu), GIMP_MENU (child_menu), TRUE);
}
if (popdown_func && popdown_data)
{
g_object_set_data_full (G_OBJECT (manager), "popdown-data",
popdown_data, popdown_func);
g_signal_connect (menu, "selection-done",
G_CALLBACK (gimp_ui_manager_delete_popdown_data),
manager);
}
gtk_menu_popup_at_widget (GTK_MENU (menu), widget,
widget_anchor,
menu_anchor,
trigger_event);
g_signal_connect (menu, "hide",
G_CALLBACK (gimp_ui_manager_popup_hidden),
NULL);
}
void
gimp_ui_manager_ui_popup_at_pointer (GimpUIManager *manager,
const gchar *ui_path,
GtkWidget *attached_widget,
const GdkEvent *trigger_event,
GDestroyNotify popdown_func,
gpointer popdown_data)
{
GimpMenuModel *model;
GtkWidget *menu;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
model = gimp_ui_manager_get_model (manager, ui_path);
menu = gimp_menu_new (manager);
gtk_menu_attach_to_widget (GTK_MENU (menu), attached_widget, NULL);
gimp_menu_shell_fill (GIMP_MENU_SHELL (menu), model, TRUE);
g_object_unref (model);
if (! menu)
return;
if (popdown_func && popdown_data)
{
g_object_set_data_full (G_OBJECT (manager), "popdown-data",
popdown_data, popdown_func);
g_signal_connect (menu, "selection-done",
G_CALLBACK (gimp_ui_manager_delete_popdown_data),
manager);
}
gtk_menu_popup_at_pointer (GTK_MENU (menu), trigger_event);
g_signal_connect (menu, "hide",
G_CALLBACK (gimp_ui_manager_popup_hidden),
NULL);
}
void
gimp_ui_manager_ui_popup_at_rect (GimpUIManager *manager,
const gchar *ui_path,
GtkWidget *attached_widget,
GdkWindow *window,
const GdkRectangle *rect,
GdkGravity rect_anchor,
GdkGravity menu_anchor,
const GdkEvent *trigger_event,
GDestroyNotify popdown_func,
gpointer popdown_data)
{
GimpMenuModel *model;
GtkWidget *menu;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
model = gimp_ui_manager_get_model (manager, ui_path);
menu = gimp_menu_new (manager);
gtk_menu_attach_to_widget (GTK_MENU (menu), attached_widget, NULL);
gimp_menu_shell_fill (GIMP_MENU_SHELL (menu), model, TRUE);
g_object_unref (model);
if (! menu)
return;
if (popdown_func && popdown_data)
{
g_object_set_data_full (G_OBJECT (manager), "popdown-data",
popdown_data, popdown_func);
g_signal_connect (menu, "selection-done",
G_CALLBACK (gimp_ui_manager_delete_popdown_data),
manager);
}
gtk_menu_popup_at_rect (GTK_MENU (menu), window,
rect, rect_anchor, menu_anchor,
trigger_event);
g_signal_connect (menu, "hide",
G_CALLBACK (gimp_ui_manager_popup_hidden),
NULL);
}
/* private functions */
static GimpUIManagerUIEntry *
gimp_ui_manager_entry_get (GimpUIManager *manager,
const gchar *ui_path)
{
GList *list;
gchar *path;
path = g_strdup (ui_path);
if (strlen (path) > 1)
{
gchar *p = strchr (path + 1, '/');
if (p)
*p = '\0';
}
for (list = manager->registered_uis; list; list = g_list_next (list))
{
GimpUIManagerUIEntry *entry = list->data;
if (! strcmp (entry->ui_path, path))
{
g_free (path);
return entry;
}
}
g_free (path);
return NULL;
}
static GimpUIManagerUIEntry *
gimp_ui_manager_entry_ensure (GimpUIManager *manager,
const gchar *path)
{
GimpUIManagerUIEntry *entry;
entry = gimp_ui_manager_entry_get (manager, path);
if (! entry)
{
g_warning ("%s: no entry registered for \"%s\"", G_STRFUNC, path);
return NULL;
}
if (entry->setup_func && ! entry->setup_done)
{
entry->setup_func (manager, entry->ui_path);
entry->setup_done = TRUE;
}
return entry;
}
static void
gimp_ui_manager_store_builder_path (GMenuModel *model,
GMenuModel *original)
{
gint n_items = 0;
g_return_if_fail (g_menu_model_get_n_items (model) == g_menu_model_get_n_items (original));
n_items = (model != NULL ? g_menu_model_get_n_items (model) : 0);
for (gint i = 0; i < n_items; i++)
{
GMenuModel *subsection;
GMenuModel *submenu;
GMenuModel *en_submodel = NULL;
subsection = g_menu_model_get_item_link (G_MENU_MODEL (model), i, G_MENU_LINK_SECTION);
submenu = g_menu_model_get_item_link (G_MENU_MODEL (model), i, G_MENU_LINK_SUBMENU);
if (subsection != NULL)
{
en_submodel = g_menu_model_get_item_link (G_MENU_MODEL (original), i, G_MENU_LINK_SECTION);
gimp_ui_manager_store_builder_path (subsection, en_submodel);
}
else if (submenu != NULL)
{
gchar *label = NULL;
en_submodel = g_menu_model_get_item_link (G_MENU_MODEL (original),
i, G_MENU_LINK_SUBMENU);
gimp_ui_manager_store_builder_path (submenu, en_submodel);
g_menu_model_get_item_attribute (G_MENU_MODEL (model), i,
G_MENU_ATTRIBUTE_LABEL, "s", &label);
if (label != NULL)
{
gchar *en_label = NULL;
g_menu_model_get_item_attribute (G_MENU_MODEL (original), i,
G_MENU_ATTRIBUTE_LABEL, "s", &en_label);
g_object_set_data_full (G_OBJECT (submenu), "gimp-ui-manager-menu-model-en-label",
en_label, (GDestroyNotify) g_free);
}
g_free (label);
}
g_clear_object (&submenu);
g_clear_object (&subsection);
g_clear_object (&en_submodel);
}
}
static GtkBuilder *
gimp_ui_manager_load_builder (const gchar *filename,
const gchar *root)
{
const GMarkupParser markup_parser =
{
gimp_ui_manager_parse_start_element,
gimp_ui_manager_parse_end_element,
gimp_ui_manager_parse_ui_text,
NULL, /* passthrough */
NULL /* error */
};
GtkBuilder *builder;
GtkBuilder *en_builder;
gchar *contents;
GimpXmlParser *xml_parser;
GString *new_xml;
GMenuModel *model;
GMenuModel *en_model;
GError *error = NULL;
/* First load the localized version. */
if (! g_file_get_contents (filename, &contents, NULL, &error))
{
g_warning ("%s: failed to read \"%s\"", G_STRFUNC, filename);
g_clear_error (&error);
return NULL;
}
builder = gtk_builder_new_from_string (contents, -1);
/* Now transform the source XML as non-translatable and load it again. */
new_xml = g_string_new (NULL);
xml_parser = gimp_xml_parser_new (&markup_parser, new_xml);
gimp_xml_parser_parse_buffer (xml_parser, contents, -1, &error);
gimp_xml_parser_free (xml_parser);
g_free (contents);
contents = g_string_free (new_xml, FALSE);
if (error != NULL)
{
g_warning ("%s: error parsing XML file \"%s\"", G_STRFUNC, filename);
g_clear_error (&error);
g_free (contents);
return builder;
}
en_builder = gtk_builder_new_from_string (contents, -1);
g_free (contents);
model = G_MENU_MODEL (gtk_builder_get_object (builder, root));
en_model = G_MENU_MODEL (gtk_builder_get_object (en_builder, root));
gimp_ui_manager_store_builder_path (model, en_model);
g_clear_object (&en_builder);
return builder;
}
static void
gimp_ui_manager_parse_start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
GString *new_xml = user_data;
g_string_append_printf (new_xml, "<%s", element_name);
for (gint i = 0; attribute_names[i] != NULL; i++)
{
if (g_strcmp0 (attribute_names[i], "translatable") == 0 ||
g_strcmp0 (attribute_names[i], "context") == 0)
continue;
g_string_append_printf (new_xml, " %s=\"%s\"",
attribute_names[i], attribute_values[i]);
}
g_string_append_printf (new_xml, ">");
}
static void
gimp_ui_manager_parse_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
GString *new_xml = user_data;
g_string_append_printf (new_xml, "</%s>", element_name);
}
static void
gimp_ui_manager_parse_ui_text (GMarkupParseContext *context,
const gchar *text,
gsize text_len,
gpointer user_data,
GError **error)
{
GString *new_xml = user_data;
gchar *unchanged = g_markup_escape_text (text, text_len);
g_string_append (new_xml, unchanged);
g_free (unchanged);
}
static void
gimp_ui_manager_delete_popdown_data (GtkWidget *widget,
GimpUIManager *manager)
{
g_signal_handlers_disconnect_by_func (widget,
gimp_ui_manager_delete_popdown_data,
manager);
g_object_set_data (G_OBJECT (manager), "popdown-data", NULL);
}
static void
gimp_ui_manager_menu_item_free (GimpUIManagerMenuItem *item)
{
g_free (item->path);
g_free (item->action_name);
g_slice_free (GimpUIManagerMenuItem, item);
}
static void
gimp_ui_manager_popup_hidden (GtkMenuShell *popup,
gpointer user_data)
{
/* Destroying the popup would happen after we finish all other events related
* to this popup. Otherwise the action which might have been activated will
* not run because it happens after hiding.
*/
g_idle_add ((GSourceFunc) gimp_ui_manager_popup_destroy, g_object_ref (popup));
}
static gboolean
gimp_ui_manager_popup_destroy (GtkWidget *popup)
{
gtk_menu_detach (GTK_MENU (popup));
g_object_unref (popup);
return G_SOURCE_REMOVE;
}
static void
gimp_ui_manager_image_action_added (GimpActionGroup *group,
gchar *action_name,
GimpUIManager *manager)
{
GimpAction *action;
const gchar **accels;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
/* The action should not already exist in the application. */
g_return_if_fail (g_action_map_lookup_action (G_ACTION_MAP (manager->gimp->app), action_name) == NULL);
action = gimp_action_group_get_action (group, action_name);
g_return_if_fail (action != NULL);
g_action_map_add_action (G_ACTION_MAP (manager->gimp->app), G_ACTION (action));
g_signal_connect_object (action, "accels-changed",
G_CALLBACK (gimp_ui_manager_image_accels_changed),
manager, 0);
accels = gimp_action_get_accels (action);
if (accels && g_strv_length ((gchar **) accels) > 0)
gimp_ui_manager_image_accels_changed (action, gimp_action_get_accels (action), manager);
}
static void
gimp_ui_manager_image_action_removed (GimpActionGroup *group,
gchar *action_name,
GimpUIManager *manager)
{
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (manager->gimp->app), action_name);
if (action != NULL)
{
g_action_map_remove_action (G_ACTION_MAP (manager->gimp->app), action_name);
g_signal_handlers_disconnect_by_func (action,
G_CALLBACK (gimp_ui_manager_image_accels_changed),
manager);
}
}
static void
gimp_ui_manager_image_accels_changed (GimpAction *action,
const gchar **accels,
GimpUIManager *manager)
{
gchar *detailed_action_name;
if (GIMP_IS_RADIO_ACTION (action))
{
gint value;
g_object_get ((GObject *) action,
"value", &value,
NULL);
detailed_action_name = g_strdup_printf ("app.%s(%i)",
g_action_get_name (G_ACTION (action)),
value);
}
else
{
detailed_action_name = g_strdup_printf ("app.%s",
g_action_get_name (G_ACTION (action)));
}
gtk_application_set_accels_for_action (GTK_APPLICATION (manager->gimp->app),
detailed_action_name,
accels ? accels : (const gchar *[]) { NULL });
g_free (detailed_action_name);
}
Reference in New Issue View Git Blame Copy Permalink