void
actions_toggle_add(GtkActionGroup *act_group, const struct _actionhooks *ahs,
int count)
{
int i;
GtkToggleAction *action;
char *nel = malloc(max_path);
for (i = 0; i < count; i++) {
char *label = gettext(ahs[i].label);
action = gtk_toggle_action_new(ahs[i].name,
label, ahs[i].tooltip == NULL ? label :
gettext(ahs[i].tooltip),
ahs[i].icon == NULL ? ahs[i].name : ahs[i].icon);
sprintf(nel, "<Actions>/actions/%s", ahs[i].name);
gtk_action_set_accel_path(GTK_ACTION(action), nel);
//gtk_action_connect_accelerator(action);
g_signal_connect(G_OBJECT(action), "activate",
ahs[i].handler,
GINT_TO_POINTER(ahs[i].parameter));
gtk_action_group_add_action_with_accel(act_group,
GTK_ACTION(action),
NULL);
}
free(nel);
}
static struct menu_priv *
add_menu(struct menu_priv *menu, struct menu_methods *meth, char *name, enum menu_type type, void (*callback)(struct menu *data_menu, void *data1, void *data2), struct menu *data_menu, void *data1, void *data2)
{
struct menu_priv *ret;
char *dynname;
ret=g_new0(struct menu_priv, 1);
*meth=menu_methods;
if (! strcmp(menu->path, "/ui/MenuBar") && !strcmp(name,"Route")) {
dynname=g_strdup("Route");
} else {
dynname=g_strdup_printf("%d", menu->gui->dyn_counter++);
if (type == menu_type_toggle)
ret->action=GTK_ACTION(gtk_toggle_action_new(dynname, name, NULL, NULL));
else
ret->action=gtk_action_new(dynname, name, NULL, NULL);
if (callback)
ret->handler_id=g_signal_connect(ret->action, "activate", G_CALLBACK(activate), ret);
gtk_action_group_add_action(menu->gui->dyn_group, ret->action);
ret->merge_id=gtk_ui_manager_new_merge_id(menu->gui->menu_manager);
gtk_ui_manager_add_ui( menu->gui->menu_manager, ret->merge_id, menu->path, dynname, dynname, type == menu_type_submenu ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM, FALSE);
}
ret->gui=menu->gui;
ret->path=g_strdup_printf("%s/%s", menu->path, dynname);
ret->type=type;
ret->callback=callback;
ret->callback_menu=data_menu;
ret->callback_data1=data1;
ret->callback_data2=data2;
ret->sibling=menu->child;
menu->child=ret;
g_free(dynname);
return ret;
}
GtkActionGroup *
nautilus_window_create_toolbar_action_group (NautilusWindow *window)
{
NautilusNavigationState *navigation_state;
GtkActionGroup *action_group;
GtkAction *action;
action_group = gtk_action_group_new ("ToolbarActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION,
"name", NAUTILUS_ACTION_BACK,
"label", _("_Back"),
"stock_id", GTK_STOCK_GO_BACK,
"tooltip", _("Go to the previous visited location"),
"arrow-tooltip", _("Back history"),
"window", window,
"direction", NAUTILUS_NAVIGATION_DIRECTION_BACK,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_back_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION,
"name", NAUTILUS_ACTION_FORWARD,
"label", _("_Forward"),
"stock_id", GTK_STOCK_GO_FORWARD,
"tooltip", _("Go to the next visited location"),
"arrow-tooltip", _("Forward history"),
"window", window,
"direction", NAUTILUS_NAVIGATION_DIRECTION_FORWARD,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_forward_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = GTK_ACTION
(gtk_toggle_action_new (NAUTILUS_ACTION_SEARCH,
_("Search"),
_("Search documents and folders by name"),
NULL));
gtk_action_group_add_action (action_group, action);
gtk_action_set_icon_name (GTK_ACTION (action), "edit-find-symbolic");
gtk_action_set_is_important (GTK_ACTION (action), TRUE);
g_object_unref (action);
navigation_state = nautilus_window_get_navigation_state (window);
nautilus_navigation_state_add_group (navigation_state, action_group);
return action_group;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(window), menubar);
GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup");
GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action);
GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action));
gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile);
GtkWidget *menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu);
GtkToggleAction *toggleaction;
toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemNew);
toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemOpen);
toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemSave);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int
clip_GTK_TOGGLEACTIONNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
gchar *name = _clip_parc(ClipMachineMemory, 2);
gchar *label = _clip_parc(ClipMachineMemory, 3);
gchar *tooltip = _clip_parc(ClipMachineMemory, 4);
gchar *stock_id = _clip_parc(ClipMachineMemory, 5);
C_object *caction;
GtkToggleAction *action;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKARG(2, CHARACTER_type_of_ClipVarType);
CHECKARG(3, CHARACTER_type_of_ClipVarType);
CHECKOPT(4, CHARACTER_type_of_ClipVarType);
CHECKOPT(5, CHARACTER_type_of_ClipVarType);
LOCALE_TO_UTF(name);
LOCALE_TO_UTF(label);
if (tooltip)
LOCALE_TO_UTF(tooltip);
if (stock_id)
LOCALE_TO_UTF(stock_id);
action = gtk_toggle_action_new(name, label, tooltip, stock_id);
if (action)
{
caction = _list_get_cobject(ClipMachineMemory, action);
if (!caction)
caction = _register_object(ClipMachineMemory, action, GTK_TYPE_TOGGLE_ACTION, cv, NULL);
if (caction)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &caction->obj);
}
FREE_TEXT(name);
FREE_TEXT(label);
if (tooltip)
FREE_TEXT(tooltip);
if (stock_id)
FREE_TEXT(stock_id);
return 0;
err:
return 1;
}
static GtkAction*
create_action_for_view_menu (PgpugPane *pane)
{
g_return_if_fail (PGPUG_IS_PANE (pane));
const gchar *name = pgpug_pane_get_menu_text (pane);
GtkToggleAction *action = gtk_toggle_action_new (name, name, NULL, NULL);
gboolean is_pane_installed = gtk_widget_get_parent (pgpug_pane_get_view (pane)) != NULL;
gtk_toggle_action_set_active (action, is_pane_installed);
g_signal_connect (action, "toggled", G_CALLBACK (menu_view_item_toggled), pane);
return GTK_ACTION (action);
}
static VALUE
taction_initialize(VALUE self, VALUE name, VALUE label, VALUE tooltip, VALUE stock_id)
{
const gchar *gstockid = NULL;
if (TYPE(stock_id) == T_SYMBOL){
gstockid = rb_id2name(SYM2ID(stock_id));
} else if (TYPE(stock_id) == T_STRING){
gstockid = RVAL2CSTR(stock_id);
}
G_INITIALIZE(self, gtk_toggle_action_new(RVAL2CSTR(name),
RVAL2CSTR(label),
NIL_P(tooltip) ? NULL : RVAL2CSTR(tooltip),
gstockid));
return Qnil;
}
/*! \brief Translate a resource tree into a menu structure
*
* \param [in] menu The GHidMainMenu widget to be acted on
* \param [in] shall The base menu shell (a menu bar or popup menu)
* \param [in] res The base of the resource tree
* */
void
ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell,
const Resource *res)
{
int i, j;
const Resource *tmp_res;
gchar mnemonic = 0;
for (i = 0; i < res->c; ++i)
{
const gchar *accel = NULL;
char *menu_label;
const char *res_val;
const Resource *sub_res = res->v[i].subres;
GtkAction *action = NULL;
switch (resource_type (res->v[i]))
{
case 101: /* name, subres: passthrough */
ghid_main_menu_real_add_resource (menu, shell, sub_res);
break;
case 1: /* no name, subres */
tmp_res = resource_subres (sub_res, "a"); /* accelerator */
res_val = resource_value (sub_res, "m"); /* mnemonic */
if (res_val)
mnemonic = res_val[0];
/* The accelerator resource will have two values, like
* a={"Ctrl-Q" "Ctrl<Key>q"}
* The first Gtk ignores. The second needs to be translated. */
if (tmp_res)
accel = check_unique_accel
(translate_accelerator (tmp_res->v[1].value));
/* Now look for the first unnamed value (not a subresource) to
* figure out the name of the menu or the menuitem. */
res_val = "button";
for (j = 0; j < sub_res->c; ++j)
if (resource_type (sub_res->v[j]) == 10)
{
res_val = _(sub_res->v[j].value);
break;
}
/* Hack '_' in based on mnemonic value */
if (!mnemonic)
menu_label = g_strdup (res_val);
else
{
char *post_ = strchr (res_val, mnemonic);
if (post_ == NULL)
menu_label = g_strdup (res_val);
else
{
GString *tmp = g_string_new ("");
g_string_append_len (tmp, res_val, post_ - res_val);
g_string_append_c (tmp, '_');
g_string_append (tmp, post_);
menu_label = g_string_free (tmp, FALSE);
}
}
/* If the subresource we're processing also has unnamed
* subresources, it's a submenu, not a regular menuitem. */
if (sub_res->flags & FLAG_S)
{
/* SUBMENU */
GtkWidget *submenu = gtk_menu_new ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label);
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (shell, item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
/* add tearoff to menu */
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff);
/* recurse on the newly-added submenu */
ghid_main_menu_real_add_resource (menu,
GTK_MENU_SHELL (submenu),
sub_res);
}
else
{
/* NON-SUBMENU: MENU ITEM */
const char *checked = resource_value (sub_res, "checked");
const char *label = resource_value (sub_res, "sensitive");
const char *tip = resource_value (sub_res, "tip");
if (checked)
{
/* TOGGLE ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d",
action_counter++);
action = GTK_ACTION (gtk_toggle_action_new (name, menu_label,
tip, NULL));
/* checked=foo is a binary flag (checkbox)
* checked=foo,bar is a flag compared to a value (radio) */
gtk_toggle_action_set_draw_as_radio
(GTK_TOGGLE_ACTION (action), !!strchr (checked, ','));
}
else if (label && strcmp (label, "false") == 0)
{
/* INSENSITIVE ITEM */
GtkWidget *item = gtk_menu_item_new_with_label (menu_label);
gtk_widget_set_sensitive (item, FALSE);
gtk_menu_shell_append (shell, item);
}
else
{
/* NORMAL ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++);
action = gtk_action_new (name, menu_label, tip, NULL);
}
}
/* Connect accelerator, if there is one */
if (action)
{
GtkWidget *item;
gtk_action_set_accel_group (action, menu->accel_group);
gtk_action_group_add_action_with_accel (menu->action_group,
action, accel);
gtk_action_connect_accelerator (action);
g_signal_connect (G_OBJECT (action), "activate", menu->action_cb,
(gpointer) sub_res);
g_object_set_data (G_OBJECT (action), "resource",
(gpointer) sub_res);
item = gtk_action_create_menu_item (action);
gtk_menu_shell_append (shell, item);
menu->actions = g_list_append (menu->actions, action);
menu->special_key_cb (accel, action, sub_res);
}
/* Scan rest of resource in case there is more work */
for (j = 0; j < sub_res->c; j++)
{
const char *res_name;
/* named value = X resource */
if (resource_type (sub_res->v[j]) == 110)
{
res_name = sub_res->v[j].name;
/* translate bg, fg to background, foreground */
if (strcmp (res_name, "fg") == 0) res_name = "foreground";
if (strcmp (res_name, "bg") == 0) res_name = "background";
/* ignore special named values (m, a, sensitive) */
if (strcmp (res_name, "m") == 0
|| strcmp (res_name, "a") == 0
|| strcmp (res_name, "sensitive") == 0
|| strcmp (res_name, "tip") == 0)
break;
/* log checked and active special values */
if (action && strcmp (res_name, "checked") == 0)
g_object_set_data (G_OBJECT (action), "checked-flag",
sub_res->v[j].value);
else if (action && strcmp (res_name, "active") == 0)
g_object_set_data (G_OBJECT (action), "active-flag",
sub_res->v[j].value);
else
/* if we got this far it is supposed to be an X
* resource. For now ignore it and warn the user */
Message (_("The gtk gui currently ignores \"%s\""
"as part of a menuitem resource.\n"
"Feel free to provide patches\n"),
sub_res->v[j].value);
}
}
break;
case 10: /* no name, value */
/* If we get here, the resource is "-" or "@foo" for some foo */
if (res->v[i].value[0] == '@')
{
GList *children;
int pos;
children = gtk_container_get_children (GTK_CONTAINER (shell));
pos = g_list_length (children);
g_list_free (children);
if (strcmp (res->v[i].value, "@layerview") == 0)
{
menu->layer_view_shell = shell;
menu->layer_view_pos = pos;
}
else if (strcmp (res->v[i].value, "@layerpick") == 0)
{
menu->layer_pick_shell = shell;
menu->layer_pick_pos = pos;
}
else if (strcmp (res->v[i].value, "@routestyles") == 0)
{
menu->route_style_shell = shell;
menu->route_style_pos = pos;
}
else
Message (_("GTK GUI currently ignores \"%s\" in the menu\n"
"resource file.\n"), res->v[i].value);
}
else if (strcmp (res->v[i].value, "-") == 0)
{
GtkWidget *item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (shell, item);
}
else if (i > 0)
{
/* This is an action-less menuitem. It is really only useful
* when you're starting to build a new menu and you're looking
* to get the layout right. */
GtkWidget *item
= gtk_menu_item_new_with_label (_(res->v[i].value));
gtk_menu_shell_append (shell, item);
}
break;
}
}
}
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++;
}
}
static void
impl_activate (PeasActivatable *activatable)
{
RBVisualizerPlugin *pi = RB_VISUALIZER_PLUGIN (activatable);
RBDisplayPageGroup *page_group;
RhythmDBEntry *entry;
GtkToggleAction *fullscreen;
GtkWidget *menu;
RBShell *shell;
g_object_get (pi, "object", &shell, NULL);
pi->settings = g_settings_new ("org.gnome.rhythmbox.plugins.visualizer");
g_signal_connect_object (pi->settings, "changed", G_CALLBACK (settings_changed_cb), pi, 0);
/* create UI actions and menus and stuff */
fullscreen = gtk_toggle_action_new ("VisualizerFullscreen",
_("Fullscreen"),
_("Toggle fullscreen visual effects"),
GTK_STOCK_FULLSCREEN);
menu = rb_visualizer_create_popup_menu (fullscreen);
g_object_ref_sink (menu);
/* create visualizer page */
pi->page = rb_visualizer_page_new (G_OBJECT (pi), shell, fullscreen, menu);
g_signal_connect_object (pi->page, "start", G_CALLBACK (start_visualizer_cb), pi, 0);
g_signal_connect_object (pi->page, "stop", G_CALLBACK (stop_visualizer_cb), pi, 0);
/* don't do anything if we couldn't create a video sink (clutter is broken, etc.) */
g_object_get (pi->page, "sink", &pi->sink, NULL);
if (pi->sink == NULL) {
g_object_unref (shell);
return;
}
/* prepare style stuff for fullscreen display */
rb_visualizer_fullscreen_load_style (G_OBJECT (pi));
/* add the visualizer page to the UI */
page_group = rb_display_page_group_get_by_id ("display");
if (page_group == NULL) {
page_group = rb_display_page_group_new (G_OBJECT (shell),
"display",
_("Display"),
RB_DISPLAY_PAGE_GROUP_CATEGORY_TOOLS);
rb_shell_append_display_page (shell, RB_DISPLAY_PAGE (page_group), NULL);
}
g_object_set (pi->page, "visibility", FALSE, NULL);
rb_shell_append_display_page (shell, RB_DISPLAY_PAGE (pi->page), RB_DISPLAY_PAGE (page_group));
/* get player objects */
g_object_get (shell, "shell-player", &pi->shell_player, NULL);
g_object_get (pi->shell_player, "player", &pi->player, NULL);
/* only show the page in the page tree when playing something */
g_signal_connect_object (pi->shell_player, "playing-song-changed", G_CALLBACK (playing_song_changed_cb), pi, 0);
entry = rb_shell_player_get_playing_entry (pi->shell_player);
playing_song_changed_cb (pi->shell_player, entry, pi);
if (entry != NULL) {
rhythmdb_entry_unref (entry);
}
/* figure out how to insert the visualizer into the playback pipeline */
if (g_object_class_find_property (G_OBJECT_GET_CLASS (pi->player), "playbin")) {
rb_debug ("using playbin-based visualization");
pi->playbin_notify_id = g_signal_connect_object (pi->player,
"notify::playbin",
G_CALLBACK (playbin_notify_cb),
pi,
0);
g_object_get (pi->player, "playbin", &pi->playbin, NULL);
if (pi->playbin != NULL) {
mutate_playbin (pi, pi->playbin);
}
} else if (RB_IS_PLAYER_GST_TEE (pi->player)) {
rb_debug ("using tee-based visualization");
} else {
g_warning ("unknown player backend type");
g_object_unref (pi->player);
pi->player = NULL;
}
g_object_unref (shell);
}
GtkActionGroup *
nemo_window_create_toolbar_action_group (NemoWindow *window)
{
gboolean show_label_search_icon_toolbar;
NemoNavigationState *navigation_state;
GtkActionGroup *action_group;
GtkAction *action;
action_group = gtk_action_group_new ("ToolbarActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_BACK,
"label", _("_Back"),
"stock_id", GTK_STOCK_GO_BACK,
"tooltip", _("Go to the previous visited location"),
"arrow-tooltip", _("Back history"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_BACK,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_back_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_FORWARD,
"label", _("_Forward"),
"stock_id", GTK_STOCK_GO_FORWARD,
"tooltip", _("Go to the next visited location"),
"arrow-tooltip", _("Forward history"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_FORWARD,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_forward_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
/**
* Nemo 2.30/2.32 type actions
*/
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_UP,
"label", _("_Up"),
"stock_id", GTK_STOCK_GO_UP,
"tooltip", _("Go to parent folder"),
"arrow-tooltip", _("Forward history"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_UP,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_up_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_RELOAD,
"label", _("_Reload"),
"stock_id", GTK_STOCK_REFRESH,
"tooltip", _("Reload the current location"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_RELOAD,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_reload_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_HOME,
"label", _("_Home"),
"stock_id", GTK_STOCK_HOME,
"tooltip", _("Go to home directory"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_HOME,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_home_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_COMPUTER,
"label", _("_Computer"),
"icon_name", "computer",
"tooltip", _("Go to Computer"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_COMPUTER,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_go_to_computer_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NEMO_TYPE_NAVIGATION_ACTION,
"name", NEMO_ACTION_EDIT_LOCATION,
"label", _("Location"),
"stock_id", GTK_STOCK_EDIT,
"tooltip", _("Toggle Location bar / Path bar"),
"window", window,
"direction", NEMO_NAVIGATION_DIRECTION_EDIT,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_edit_location_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = GTK_ACTION (gtk_toggle_action_new (NEMO_ACTION_SEARCH,
_("Search"),_("Search documents and folders by name"),
NULL));
gtk_action_group_add_action (action_group, action);
gtk_action_set_icon_name (GTK_ACTION (action), "edit-find");
show_label_search_icon_toolbar = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_LABEL_SEARCH_ICON_TOOLBAR);
gtk_action_set_is_important (GTK_ACTION (action), show_label_search_icon_toolbar);
g_object_unref (action);
navigation_state = nemo_window_get_navigation_state (window);
nemo_navigation_state_add_group (navigation_state, action_group);
return action_group;
}
GtkAction * create_action_by_descriptor(const gchar *name, struct action_descriptor *data)
{
int state = data->attr.key_state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK|GDK_ALT_MASK);
int f;
// Trace("%s: %d",name,data->ui_type);
switch(data->ui_type)
{
case UI_CALLBACK_TYPE_TOGGLE:
data->action = GTK_ACTION(gtk_toggle_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip), data->attr.stock_id));
break;
case UI_CALLBACK_TYPE_DEFAULT:
data->action = gtk_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip),data->attr.stock_id);
break;
case UI_CALLBACK_TYPE_SCROLL:
if(data->sub >= 0 && data->sub <= G_N_ELEMENTS(action_scroll))
action_scroll[data->sub] = data->action = gtk_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip),data->attr.stock_id);
break;
case UI_CALLBACK_TYPE_SCRIPT:
if(data->script.text)
g_object_set_data_full(G_OBJECT(data->action),"script_text",g_strdup(data->script.text),g_free);
if(data->callback)
g_signal_connect(G_OBJECT(data->action),"activate",G_CALLBACK(data->callback),topwindow);
else
g_signal_connect(G_OBJECT(data->action),"activate",G_CALLBACK(action_script_activated),topwindow);
data->callback = 0;
break;
default:
Trace("Invalid action type %d in %s",data->ui_type,data->name);
return NULL;
}
// Trace("%s(%s), callback: %p action: %p",__FUNCTION__,name,data->callback,data->action);
if(data->callback)
g_signal_connect(G_OBJECT(data->action),data->ui_type == UI_CALLBACK_TYPE_TOGGLE ? "toggled" : "activate",G_CALLBACK(data->callback),data->user_data);
// Check for special keyboard action
for(f=0;f<G_N_ELEMENTS(keyboard_action);f++)
{
if(data->attr.key_value == keyboard_action[f].keyval && (state == keyboard_action[f].state))
{
keyboard_action[f].action = data->action;
gtk_action_group_add_action(action_group[data->group],data->action);
return data->action;
}
}
// Check for PF actions
if(data->attr.key_value >= GDK_F1 && data->attr.key_value <= GDK_F12 && !(state & (GDK_CONTROL_MASK|GDK_ALT_MASK)))
{
f = data->attr.key_value - GDK_F1;
if(state&GDK_SHIFT_MASK)
pf_action[f].shift = data->action;
else
pf_action[f].normal = data->action;
gtk_action_group_add_action(action_group[data->group],data->action);
return data->action;
}
// Register action
if(data->attr.accel)
gtk_action_group_add_action_with_accel(action_group[data->group],data->action,data->attr.accel);
else
gtk_action_group_add_action(action_group[data->group],data->action);
return data->action;
}
