static void
toggle_italic (GtkToggleButton *button, gpointer data)
{
GMenuModel *model;
GActionGroup *group;
GSimpleAction *action;
gboolean adding;
GMenuModel *m;
GtkTreeView *tv = data;
GtkTreeModel *store;
model = g_object_get_data (G_OBJECT (button), "model");
group = g_object_get_data (G_OBJECT (button), "group");
store = gtk_tree_view_get_model (tv);
adding = gtk_toggle_button_get_active (button);
m = g_menu_model_get_item_link (model, g_menu_model_get_n_items (model) - 1, G_MENU_LINK_SECTION);
if (adding)
{
action = g_simple_action_new_stateful ("italic", NULL, g_variant_new_boolean (FALSE));
g_action_map_add_action (G_ACTION_MAP (group), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (activate_toggle), NULL);
g_object_unref (action);
action_list_add (store, "italic");
g_menu_insert (G_MENU (m), 1, "Italic", "italic");
}
else
{
g_action_map_remove_action (G_ACTION_MAP (group), "italic");
action_list_remove (store, "italic");
g_menu_remove (G_MENU (m), 1);
}
}
void
gw_application_set_win_menubar (GwApplication *application, GMenuModel *menumodel)
{
//Sanity checks
g_return_if_fail (application != NULL);
g_return_if_fail (menumodel != NULL);
if (g_menu_model_get_n_items (menumodel) == 0) return;
//Declarations
GMenuModel *menubar;
gint length;
//Initializations
menubar = gtk_application_get_menubar (GTK_APPLICATION (application));
g_return_if_fail (menubar != NULL);
length = g_menu_model_get_n_items (menubar);
//Clear the menubar
while (length-- > 0) g_menu_remove (G_MENU (menubar), 0);
//Add the menuitem linking the menus
{
GMenuItem *menuitem = g_menu_item_new_section (NULL, menumodel);
if (menuitem != NULL)
{
g_menu_append_item (G_MENU (menubar), menuitem);
g_object_unref (menuitem); menuitem = NULL;
}
gw_application_add_accelerators (application, menubar);
}
}
/*
* The GMenu @menu is modified adding to the section @submodel_name
* the item @item.
*/
void
nautilus_gmenu_add_item_in_submodel (GMenu *menu,
GMenuItem *item,
const gchar *submodel_name,
gboolean prepend)
{
GMenuModel *submodel;
g_return_if_fail (G_IS_MENU (menu));
g_return_if_fail (G_IS_MENU_ITEM (item));
submodel = find_gmenu_model (G_MENU_MODEL (menu), submodel_name);
g_return_if_fail (submodel != NULL);
if (prepend)
{
g_menu_prepend_item (G_MENU (submodel), item);
}
else
{
g_menu_append_item (G_MENU (submodel), item);
}
g_object_unref (submodel);
}
/*
* The original GMenu is modified adding to the section @submodel_name
* the items in @gmenu_to_merge.
* @gmenu_to_merge should be a list of menu items.
*/
void
nautilus_gmenu_merge (GMenu *original,
GMenu *gmenu_to_merge,
const gchar *submodel_name,
gboolean prepend)
{
gint i, n_items;
GMenuModel *submodel;
GMenuItem *item;
g_return_if_fail (G_IS_MENU (original));
g_return_if_fail (G_IS_MENU (gmenu_to_merge));
submodel = find_gmenu_model (G_MENU_MODEL (original), submodel_name);
g_return_if_fail (submodel != NULL);
n_items = g_menu_model_get_n_items (G_MENU_MODEL (gmenu_to_merge));
for (i = 0; i < n_items; i++)
{
item = g_menu_item_new_from_model (G_MENU_MODEL (gmenu_to_merge), i);
if (prepend)
{
g_menu_prepend_item (G_MENU (submodel), item);
}
else
{
g_menu_append_item (G_MENU (submodel), item);
}
g_object_unref (item);
}
g_object_unref (submodel);
}
static void
impl_activate (PeasActivatable *plugin)
{
TotemDiscRecorderPlugin *pi = TOTEM_DISC_RECORDER_PLUGIN (plugin);
TotemDiscRecorderPluginPrivate *priv = pi->priv;
GMenu *menu;
char *path;
/* make sure brasero is in the path */
path = g_find_program_in_path ("brasero");
if (!path)
return;
g_free (path);
priv->totem = g_object_get_data (G_OBJECT (plugin), "object");
g_signal_connect (priv->totem,
"file-opened",
G_CALLBACK (totem_disc_recorder_file_opened),
plugin);
g_signal_connect (priv->totem,
"file-closed",
G_CALLBACK (totem_disc_recorder_file_closed),
plugin);
/* Create the actions */
priv->dvd_action = g_simple_action_new ("media-optical-video-new", NULL);
g_signal_connect (G_OBJECT (priv->dvd_action), "activate",
G_CALLBACK (totem_disc_recorder_plugin_burn), plugin);
g_action_map_add_action (G_ACTION_MAP (priv->totem), G_ACTION (priv->dvd_action));
priv->copy_action = g_simple_action_new ("media-optical-copy", NULL);
g_signal_connect (G_OBJECT (priv->copy_action), "activate",
G_CALLBACK (totem_disc_recorder_plugin_copy), plugin);
g_action_map_add_action (G_ACTION_MAP (priv->totem), G_ACTION (priv->copy_action));
priv->copy_vcd_action = g_simple_action_new ("media-optical-copy-vcd", NULL);
g_signal_connect (G_OBJECT (priv->copy_vcd_action), "activate",
G_CALLBACK (totem_disc_recorder_plugin_copy), plugin);
g_action_map_add_action (G_ACTION_MAP (priv->totem), G_ACTION (priv->copy_vcd_action));
/* Install the menu */
menu = totem_object_get_menu_section (priv->totem, "burn-placeholder");
menu_append_hidden (G_MENU (menu), _("_Create Video Disc…"), "app.media-optical-video-new");
menu_append_hidden (G_MENU (menu), _("Copy Vide_o DVD…"), "app.media-optical-copy");
menu_append_hidden (G_MENU (menu), _("Copy (S)VCD…"), "app.media-optical-copy-vcd");
if (!totem_object_is_paused (priv->totem) && !totem_object_is_playing (priv->totem)) {
set_menu_items_state (pi, FALSE, FALSE, FALSE);
} else {
char *mrl;
mrl = totem_object_get_current_mrl (priv->totem);
totem_disc_recorder_file_opened (priv->totem, mrl, pi);
g_free (mrl);
}
}
static void
toggle_speed (GtkToggleButton *button, gpointer data)
{
GMenuModel *model;
GActionGroup *group;
GSimpleAction *action;
gboolean adding;
GMenuModel *m;
GMenu *submenu;
GtkTreeView *tv = data;
GtkTreeModel *store;
model = g_object_get_data (G_OBJECT (button), "model");
group = g_object_get_data (G_OBJECT (button), "group");
store = gtk_tree_view_get_model (tv);
adding = gtk_toggle_button_get_active (button);
m = g_menu_model_get_item_link (model, 1, G_MENU_LINK_SECTION);
if (adding)
{
action = g_simple_action_new ("faster", NULL);
g_action_map_add_action (G_ACTION_MAP (group), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (activate_action), NULL);
g_object_unref (action);
action = g_simple_action_new ("slower", NULL);
g_action_map_add_action (G_ACTION_MAP (group), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (activate_action), NULL);
g_object_unref (action);
action_list_add (store, "faster");
action_list_add (store, "slower");
submenu = g_menu_new ();
g_menu_append (submenu, "Faster", "faster");
g_menu_append (submenu, "Slower", "slower");
g_menu_append_submenu (G_MENU (m), "Speed", G_MENU_MODEL (submenu));
}
else
{
g_action_map_remove_action (G_ACTION_MAP (group), "faster");
g_action_map_remove_action (G_ACTION_MAP (group), "slower");
action_list_remove (store, "faster");
action_list_remove (store, "slower");
g_menu_remove (G_MENU (m), g_menu_model_get_n_items (m) - 1);
}
}
GeditMenuExtension *
_gedit_app_extend_menu (GeditApp *app,
const gchar *extension_point)
{
GeditAppPrivate *priv;
GMenuModel *model;
GMenuModel *section;
g_return_val_if_fail (GEDIT_IS_APP (app), NULL);
g_return_val_if_fail (extension_point != NULL, NULL);
priv = gedit_app_get_instance_private (app);
/* First look in the window menu */
section = find_extension_point_section (priv->window_menu, extension_point);
/* otherwise look in the app menu */
if (section == NULL)
{
model = gtk_application_get_app_menu (GTK_APPLICATION (app));
if (model != NULL)
{
section = find_extension_point_section (model, extension_point);
}
}
return section != NULL ? gedit_menu_extension_new (G_MENU (section)) : NULL;
}
static void
disable_plugin (const gchar *name)
{
GMenuModel *plugin_menu;
g_print ("Disabling '%s' plugin\n", name);
plugin_menu = find_plugin_menu ();
if (plugin_menu)
{
const gchar *id;
gint i;
for (i = 0; i < g_menu_model_get_n_items (plugin_menu); i++)
{
if (g_menu_model_get_item_attribute (plugin_menu, i, "id", "s", &id) &&
g_strcmp0 (id, name) == 0)
{
g_menu_remove (G_MENU (plugin_menu), i);
g_print ("Menus of '%s' plugin removed\n", name);
}
}
}
else
g_warning ("Plugin menu not found\n");
g_action_map_remove_action (G_ACTION_MAP (g_application_get_default ()), name);
g_print ("Actions of '%s' plugin removed\n", name);
if (g_strcmp0 (name, "red") == 0)
is_red_plugin_enabled = FALSE;
else
is_black_plugin_enabled = FALSE;
}
static void
panel_applet_menu_popup (PanelApplet *applet,
guint button,
guint32 time)
{
GtkWidget *menu;
GMenu *gmenu;
GList *children, *l;
gboolean visible = FALSE;
gmenu = G_MENU (gtk_builder_get_object (applet->priv->builder, "panel-applet-popup"));
menu = gtk_menu_new_from_model (G_MENU_MODEL (gmenu));
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (applet), NULL);
children = gtk_container_get_children (GTK_CONTAINER (menu));
for (l = children; l != NULL; l = l->next) {
visible = gtk_widget_get_visible (GTK_WIDGET (l->data));
if (visible)
break;
}
g_list_free (children);
if (!visible)
return;
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL,
(GtkMenuPositionFunc) panel_applet_position_menu,
applet,
button, time);
}
RBSource *
rb_mtp_source_new (RBShell *shell,
GObject *plugin,
#if defined(HAVE_GUDEV)
GUdevDevice *udev_device,
#else
const char *udi,
#endif
LIBMTP_raw_device_t *device)
{
RBMtpSource *source = NULL;
RhythmDBEntryType *entry_type;
RhythmDB *db = NULL;
GSettings *settings;
GtkBuilder *builder;
GMenu *toolbar;
char *name = NULL;
g_object_get (shell, "db", &db, NULL);
name = g_strdup_printf ("MTP-%u-%d", device->bus_location, device->devnum);
entry_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE,
"db", db,
"name", name,
"save-to-disk", FALSE,
"category", RHYTHMDB_ENTRY_NORMAL,
NULL);
g_free (name);
g_object_unref (db);
builder = rb_builder_load_plugin_file (plugin, "mtp-toolbar.ui", NULL);
toolbar = G_MENU (gtk_builder_get_object (builder, "mtp-toolbar"));
rb_application_link_shared_menus (RB_APPLICATION (g_application_get_default ()), toolbar);
settings = g_settings_new ("org.gnome.rhythmbox.plugins.mtpdevice");
source = RB_MTP_SOURCE (g_object_new (RB_TYPE_MTP_SOURCE,
"plugin", plugin,
"entry-type", entry_type,
"shell", shell,
"visibility", TRUE,
"raw-device", device,
#if defined(HAVE_GUDEV)
"udev-device", udev_device,
#else
"udi", udi,
#endif
"load-status", RB_SOURCE_LOAD_STATUS_LOADING,
"settings", g_settings_get_child (settings, "source"),
"encoding-settings", g_settings_get_child (settings, "encoding"),
"toolbar-menu", toolbar,
"name", _("Media Player"),
NULL));
g_object_unref (settings);
g_object_unref (builder);
rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type);
return RB_SOURCE (source);
}
void
bookmarks__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
g_action_map_add_action_entries (G_ACTION_MAP (browser),
actions,
G_N_ELEMENTS (actions),
browser);
{
GtkWidget *button;
GMenuModel *menu;
button = _gtk_menu_button_new_for_header_bar ("user-bookmarks-symbolic");
gtk_widget_set_tooltip_text (button, _("Bookmarks"));
data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/bookmarks/data/ui/bookmarks-menu.ui");
data->system_bookmarks_menu = G_MENU (gtk_builder_get_object (data->builder, "system-bookmarks"));
data->entry_points_menu = G_MENU (gtk_builder_get_object (data->builder, "entry-points"));
data->bookmarks_menu = G_MENU (gtk_builder_get_object (data->builder, "bookmarks"));
menu = G_MENU_MODEL (gtk_builder_get_object (data->builder, "bookmarks-menu"));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
_gtk_window_add_accelerators_from_menu ((GTK_WINDOW (browser)), menu);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (gth_browser_get_headerbar_section (browser, GTH_BROWSER_HEADER_SECTION_BROWSER_LOCATIONS)), button, FALSE, FALSE, 0);
}
data->browser = browser;
data->bookmarks_changed_id = g_signal_connect (gth_main_get_default_monitor (),
"bookmarks-changed",
G_CALLBACK (bookmarks_changed_cb),
data);
data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (),
"entry-points-changed",
G_CALLBACK (entry_points_changed_cb),
data);
}
static void
toggle_sumerian (GtkToggleButton *button, gpointer data)
{
GMenuModel *model;
gboolean adding;
GMenuModel *m;
model = g_object_get_data (G_OBJECT (button), "model");
adding = gtk_toggle_button_get_active (button);
m = g_menu_model_get_item_link (model, g_menu_model_get_n_items (model) - 1, G_MENU_LINK_SECTION);
m = g_menu_model_get_item_link (m, g_menu_model_get_n_items (m) - 1, G_MENU_LINK_SUBMENU);
if (adding)
g_menu_append (G_MENU (m), "Sumerian", "lang::sumerian");
else
g_menu_remove (G_MENU (m), g_menu_model_get_n_items (m) - 1);
}
void
gw_menumodel_set_links (GMenuModel *menumodel, const gchar *LABEL, const gchar *NEW_LABEL, const gchar *LINK_TYPE, GMenuModel *link)
{
//Sanity checks
g_return_if_fail (menumodel != NULL);
g_return_if_fail (LABEL != NULL);
g_return_if_fail (LINK_TYPE != NULL);
//Declarations
gint total_items;
gint index;
gchar *label;
gboolean valid;
GMenuItem *menuitem;
GMenuModel *sublink;
//Initializations
total_items = g_menu_model_get_n_items (menumodel);
for (index = 0; index < total_items; index++)
{
valid = g_menu_model_get_item_attribute (menumodel, index, G_MENU_ATTRIBUTE_LABEL, "s", &label, NULL);
if (valid == TRUE && label != NULL)
{
if (label != NULL && strcmp (label, LABEL) == 0)
{
menuitem = g_menu_item_new (NEW_LABEL, NULL);
g_menu_item_set_link (menuitem, LINK_TYPE, link);
g_menu_remove (G_MENU (menumodel), index);
g_menu_insert_item (G_MENU (menumodel), index, menuitem);
g_object_unref (menuitem); menuitem = NULL;
}
g_free (label); label = NULL;
}
//Recursive work
sublink = g_menu_model_get_item_link (menumodel, index, G_MENU_LINK_SUBMENU);
if (sublink != NULL) gw_menumodel_set_links (sublink, LABEL, NEW_LABEL, LINK_TYPE, link);
sublink = g_menu_model_get_item_link (menumodel, index, G_MENU_LINK_SECTION);
if (sublink != NULL) gw_menumodel_set_links (sublink, LABEL, NEW_LABEL, LINK_TYPE, link);
}
}
void
nautilus_gmenu_replace_section (GMenu *menu,
const gchar *section_id,
GMenuModel *section)
{
GMenuModel *orig_section;
GMenuItem *item;
gint idx;
orig_section = find_gmenu_model (G_MENU_MODEL (menu), section_id);
g_return_if_fail (orig_section != NULL);
g_menu_remove_all (G_MENU (orig_section));
for (idx = 0; idx < g_menu_model_get_n_items (section); idx++) {
item = g_menu_item_new_from_model (section, idx);
g_menu_append_item (G_MENU (orig_section), item);
g_object_unref (item);
}
g_object_unref (orig_section);
}
static void
photos_application_init_app_menu (PhotosApplication *self)
{
GMenu *menu;
GtkBuilder *builder;
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/photos/app-menu.ui", NULL);
menu = G_MENU (gtk_builder_get_object (builder, "app-menu"));
gtk_application_set_app_menu (GTK_APPLICATION (self), G_MENU_MODEL (menu));
g_object_unref (builder);
}
/**
* irc_context_get_menu:
*
* Returns: (transfer full): New menu currently valid for context
*/
GMenuModel *
irc_context_get_menu (IrcContext *self)
{
GMenuModel *menu = IRC_CONTEXT_GET_IFACE(self)->get_menu(self);
// Always have a close entry
GMenu *shared_menu = g_menu_new ();
const char *id = irc_context_get_id (self);
g_autofree char *action = g_strdup_printf ("context.close('%s')", id);
g_menu_append (shared_menu, _("Close"), action);
g_menu_append_section (G_MENU(menu), NULL, G_MENU_MODEL(shared_menu));
return menu;
}
void
list_tools__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GtkBuilder *builder;
GMenuModel *menu;
GtkWidget *button;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->browser = browser;
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
g_action_map_add_action_entries (G_ACTION_MAP (browser),
actions,
G_N_ELEMENTS (actions),
browser);
builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/list_tools/data/ui/tools-menu.ui");
gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_TOOLS, G_MENU (gtk_builder_get_object (builder, "tools1")));
gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_MORE_TOOLS, G_MENU (gtk_builder_get_object (builder, "tools2")));
gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_TOOLS3, G_MENU (gtk_builder_get_object (builder, "tools3")));
menu = G_MENU_MODEL (gtk_builder_get_object (builder, "tools-menu"));
/* browser tools */
button = _gtk_menu_button_new_for_header_bar ();
g_signal_connect (button, "toggled", G_CALLBACK (tools_menu_button_toggled_cb), data);
gtk_widget_set_tooltip_text (button, _("Tools"));
gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name ("tools-symbolic", GTK_ICON_SIZE_MENU));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
gtk_widget_show_all (button);
gtk_box_pack_start (GTK_BOX (gth_browser_get_headerbar_section (browser, GTH_BROWSER_HEADER_SECTION_BROWSER_TOOLS)), button, FALSE, FALSE, 0);
g_object_unref (builder);
}
static void
enable_plugin (const gchar *name)
{
GMenuModel *plugin_menu;
GAction *action;
g_print ("Enabling '%s' plugin\n", name);
action = (GAction *)g_simple_action_new (name, NULL);
g_signal_connect (action, "activate", G_CALLBACK (plugin_action), (gpointer)name);
g_action_map_add_action (G_ACTION_MAP (g_application_get_default ()), action);
g_print ("Actions of '%s' plugin added\n", name);
g_object_unref (action);
plugin_menu = find_plugin_menu ();
if (plugin_menu)
{
GMenu *section;
GMenuItem *item;
gchar *label;
gchar *action_name;
section = g_menu_new ();
label = g_strdup_printf ("Turn text %s", name);
action_name = g_strconcat ("app.", name, NULL);
g_menu_insert (section, 0, label, action_name);
g_free (label);
g_free (action_name);
item = g_menu_item_new_section (NULL, (GMenuModel*)section);
g_menu_item_set_attribute (item, "id", "s", name);
g_menu_append_item (G_MENU (plugin_menu), item);
g_object_unref (item);
g_object_unref (section);
g_print ("Menus of '%s' plugin added\n", name);
}
else
g_warning ("Plugin menu not found\n");
if (g_strcmp0 (name, "red") == 0)
is_red_plugin_enabled = TRUE;
else
is_black_plugin_enabled = TRUE;
}
static void
actions_changed_cb (G_GNUC_UNUSED GtkWidget *widget,
GMenuModel *model,
gpointer data)
{
GMenu *menu = NULL;
g_return_if_fail (EKIGA_IS_WINDOW (data));
EkigaWindow *self = EKIGA_WINDOW (data);
menu = G_MENU (gtk_builder_get_object (self->priv->builder, "menubar"));
g_menu_remove_all (menu);
/* Those are Actions from the selected Presentity and Heap */
if (model) {
g_menu_insert_section (menu, 0, NULL, model);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->menu_button), G_MENU_MODEL (menu));
}
else
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->menu_button), NULL);
}
static void
impl_activate (PeasActivatable *plugin)
{
GtkWindow *window;
TotemSkiptoPlugin *pi = TOTEM_SKIPTO_PLUGIN (plugin);
TotemSkiptoPluginPrivate *priv = pi->priv;
GMenu *menu;
GMenuItem *item;
priv->totem = g_object_get_data (G_OBJECT (plugin), "object");
priv->handler_id_stream_length = g_signal_connect (G_OBJECT (priv->totem),
"notify::stream-length",
G_CALLBACK (property_notify_cb),
pi);
priv->handler_id_seekable = g_signal_connect (G_OBJECT (priv->totem),
"notify::seekable",
G_CALLBACK (property_notify_cb),
pi);
/* Key press handler */
window = totem_object_get_main_window (priv->totem);
priv->handler_id_key_press = g_signal_connect (G_OBJECT(window),
"key-press-event",
G_CALLBACK (on_window_key_press_event),
pi);
g_object_unref (window);
/* Install the menu */
priv->action = g_simple_action_new ("skip-to", NULL);
g_signal_connect (G_OBJECT (priv->action), "activate",
G_CALLBACK (skip_to_action_callback), plugin);
g_action_map_add_action (G_ACTION_MAP (priv->totem), G_ACTION (priv->action));
menu = totem_object_get_menu_section (priv->totem, "skipto-placeholder");
item = g_menu_item_new (_("_Skip To…"), "app.skip-to");
g_menu_item_set_attribute (item, "accel", "s", "<Ctrl>K");
g_menu_append_item (G_MENU (menu), item);
totem_skipto_update_from_state (priv->totem, pi);
}
static void
eog_zoom_entry_populate_free_zoom_section (EogZoomEntry *zoom_entry)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (zoom_levels); i++) {
GMenuItem *item;
gchar *name;
if (zoom_levels[i] > EOG_SCROLL_VIEW_MAX_ZOOM_FACTOR)
break;
name = eog_zoom_entry_format_zoom_value (zoom_levels[i]);
item = g_menu_item_new (name, NULL);
g_menu_item_set_action_and_target (item, "win.zoom-set",
"d", zoom_levels[i]);
g_menu_append_item (G_MENU (zoom_entry->priv->zoom_free_section), item);
g_object_unref (item);
g_free (name);
}
}
GeditMenuExtension *
gedit_window_activatable_extend_gear_menu (GeditWindowActivatable *activatable,
const gchar *extension_point)
{
GeditMenuExtension *menu = NULL;
GeditWindow *window;
GMenuModel *model;
gint i, n_items;
g_return_val_if_fail (GEDIT_IS_WINDOW_ACTIVATABLE (activatable), NULL);
g_return_val_if_fail (extension_point != NULL, NULL);
g_object_get (G_OBJECT (activatable), "window", &window, NULL);
model = _gedit_window_get_gear_menu (window);
g_object_unref (window);
n_items = g_menu_model_get_n_items (model);
for (i = 0; i < n_items; i++)
{
gchar *id = NULL;
if (g_menu_model_get_item_attribute (model, i, "id", "s", &id) &&
strcmp (id, extension_point) == 0)
{
GMenuModel *section;
section = g_menu_model_get_item_link (model, i, G_MENU_LINK_SECTION);
menu = _gedit_menu_extension_new (G_MENU (section));
}
g_free (id);
}
return menu;
}
static void
startup_cb (GApplication *application,
gpointer data)
{
GtkBuilder *builder = gtk_builder_new ();
GMenuModel *model;
gboolean show_app_menu;
const GActionEntry app_entries[] =
{
{ "group-by", activate_action, "s", "\"script\"", NULL },
{ "show-only-glyphs-in-font", activate_toggle_action, NULL, "false",
change_toggle_state },
{ "zoom-in", activate_action, NULL, NULL, NULL },
{ "zoom-out", activate_action, NULL, NULL, NULL },
{ "normal-size", activate_action, NULL, NULL, NULL },
{ "find", activate_action, NULL, NULL, NULL },
{ "help", activate_action, NULL, NULL, NULL },
{ "about", activate_action, NULL, NULL, NULL },
{ "close", activate_close, NULL, NULL, NULL },
};
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_entries, G_N_ELEMENTS (app_entries),
application);
gtk_builder_add_from_resource (builder, UI_RESOURCE, NULL);
/* app menu */
g_object_get (gtk_settings_get_default (),
"gtk-shell-shows-app-menu", &show_app_menu,
NULL);
if (show_app_menu) {
model = G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"));
gtk_application_set_app_menu (GTK_APPLICATION (application), model);
}
/* window menu */
#ifdef ENABLE_PRINTING
model = G_MENU_MODEL (gtk_builder_get_object (builder, "printing"));
g_menu_append (G_MENU (model), _("Page _Setup"), "win.page-setup");
/* g_menu_append (G_MENU (model), _("Print Preview"), "win.print-preview"); */
g_menu_append (G_MENU (model), _("_Print"), "win.print");
#endif
model = G_MENU_MODEL (gtk_builder_get_object (builder, "go-chapter"));
g_object_set_data (G_OBJECT (application), "go-chapter-menu", model);
model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
gtk_application_set_menubar (GTK_APPLICATION (application), model);
gtk_application_add_accelerator (GTK_APPLICATION (application),
"<Primary>Page_Down", "win.next-chapter",
NULL);
gtk_application_add_accelerator (GTK_APPLICATION (application),
"<Primary>Page_Up", "win.previous-chapter",
NULL);
gtk_application_add_accelerator (GTK_APPLICATION (application),
"F1", "app.help", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (application),
"<Primary>q", "app.close", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (application),
"<Primary>w", "app.close", NULL);
g_object_unref (builder);
}
static void
on_operations_icon_draw (GtkWidget *widget,
cairo_t *cr,
NautilusToolbar *self)
{
gfloat elapsed_progress = 0;
gint remaining_progress = 0;
gint total_progress;
gdouble ratio;
GList *progress_infos;
GList *l;
guint width;
guint height;
gboolean all_cancelled;
GdkRGBA background = {.red = 0, .green = 0, .blue = 0, .alpha = 0.2 };
GdkRGBA foreground = {.red = 0, .green = 0, .blue = 0, .alpha = 0.7 };
all_cancelled = TRUE;
progress_infos = get_filtered_progress_infos (self);
for (l = progress_infos; l != NULL; l = l->next) {
if (!nautilus_progress_info_get_is_cancelled (l->data)) {
all_cancelled = FALSE;
remaining_progress += nautilus_progress_info_get_remaining_time (l->data);
elapsed_progress += nautilus_progress_info_get_elapsed_time (l->data);
}
}
g_list_free (progress_infos);
total_progress = remaining_progress + elapsed_progress;
if (all_cancelled) {
ratio = 1.0;
} else {
if (total_progress > 0) {
ratio = MAX (0.05, elapsed_progress / total_progress);
} else {
ratio = 0.05;
}
}
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
gdk_cairo_set_source_rgba(cr, &background);
cairo_arc (cr,
width / 2.0, height / 2.0,
MIN (width, height) / 2.0,
0, 2 *G_PI);
cairo_fill (cr);
cairo_move_to (cr, width / 2.0, height / 2.0);
gdk_cairo_set_source_rgba (cr, &foreground);
cairo_arc (cr,
width / 2.0, height / 2.0,
MIN (width, height) / 2.0,
-G_PI / 2.0, ratio * 2 * G_PI - G_PI / 2.0);
cairo_fill (cr);
}
static void
on_operations_button_toggled (NautilusToolbar *self)
{
unschedule_remove_finished_operations (self);
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->priv->operations_button))) {
schedule_remove_finished_operations (self);
} else {
update_operations (self);
}
}
static void
nautilus_toolbar_init (NautilusToolbar *self)
{
GtkBuilder *builder;
self->priv = nautilus_toolbar_get_instance_private (self);
gtk_widget_init_template (GTK_WIDGET (self));
self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL);
gtk_container_add (GTK_CONTAINER (self->priv->path_bar_container),
self->priv->path_bar);
self->priv->location_entry = nautilus_location_entry_new ();
gtk_container_add (GTK_CONTAINER (self->priv->location_entry_container),
self->priv->location_entry);
builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-action-menu.xml");
self->priv->action_menu = G_MENU (gtk_builder_get_object (builder, "action-menu"));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->action_button),
G_MENU_MODEL (self->priv->action_menu));
g_object_unref (builder);
self->priv->progress_manager = nautilus_progress_info_manager_dup_singleton ();
g_signal_connect (self->priv->progress_manager, "new-progress-info",
G_CALLBACK (on_new_progress_info), self);
update_operations (self);
g_object_set_data (G_OBJECT (self->priv->back_button), "nav-direction",
GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_BACK));
g_object_set_data (G_OBJECT (self->priv->forward_button), "nav-direction",
GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_FORWARD));
g_signal_connect (self->priv->back_button, "button-press-event",
G_CALLBACK (navigation_button_press_cb), self);
g_signal_connect (self->priv->back_button, "button-release-event",
G_CALLBACK (navigation_button_release_cb), self);
g_signal_connect (self->priv->forward_button, "button-press-event",
G_CALLBACK (navigation_button_press_cb), self);
g_signal_connect (self->priv->forward_button, "button-release-event",
G_CALLBACK (navigation_button_release_cb), self);
gtk_widget_show_all (GTK_WIDGET (self));
toolbar_update_appearance (self);
}
static RBSource *
create_source_cb (RBRemovableMediaManager *rmm, GMount *mount, MPIDDevice *device_info, RBGenericPlayerPlugin *plugin)
{
RBSource *source = NULL;
GType source_type = G_TYPE_NONE;
RBShell *shell;
RhythmDB *db;
RhythmDBEntryType *entry_type;
RhythmDBEntryType *error_type;
RhythmDBEntryType *ignore_type;
GtkBuilder *builder;
GMenu *toolbar;
GVolume *volume;
GSettings *settings;
const char *name_prefix;
char *name;
char *path;
if (rb_psp_is_mount_player (mount, device_info)) {
source_type = RB_TYPE_PSP_SOURCE;
name_prefix = "psp";
} else if (rb_nokia770_is_mount_player (mount, device_info)) {
source_type = RB_TYPE_NOKIA770_SOURCE;
name_prefix = "nokia770";
} else if (rb_generic_player_is_mount_player (mount, device_info)) {
source_type = RB_TYPE_GENERIC_PLAYER_SOURCE;
name_prefix = "generic-player";
} else {
return NULL;
}
volume = g_mount_get_volume (mount);
path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_get (plugin, "object", &shell, NULL);
g_object_get (shell, "db", &db, NULL);
name = g_strdup_printf ("%s: %s", name_prefix, path);
entry_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE,
"db", db,
"name", name,
"save-to-disk", FALSE,
"category", RHYTHMDB_ENTRY_NORMAL,
NULL);
rhythmdb_register_entry_type (db, entry_type);
g_free (name);
name = g_strdup_printf ("%s (ignore): %s", name_prefix, path);
ignore_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE,
"db", db,
"name", name,
"save-to-disk", FALSE,
"category", RHYTHMDB_ENTRY_VIRTUAL,
NULL);
rhythmdb_register_entry_type (db, ignore_type);
g_free (name);
name = g_strdup_printf ("%s (errors): %s", name_prefix, path);
error_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE,
"db", db,
"name", name,
"save-to-disk", FALSE,
"category", RHYTHMDB_ENTRY_VIRTUAL,
NULL);
rhythmdb_register_entry_type (db, error_type);
g_free (name);
g_object_unref (db);
builder = rb_builder_load_plugin_file (G_OBJECT (plugin), "generic-player-toolbar.ui", NULL);
toolbar = G_MENU (gtk_builder_get_object (builder, "generic-player-toolbar"));
rb_application_link_shared_menus (RB_APPLICATION (g_application_get_default ()), toolbar);
settings = g_settings_new ("org.gnome.rhythmbox.plugins.generic-player");
source = RB_SOURCE (g_object_new (source_type,
"plugin", plugin,
"entry-type", entry_type,
"ignore-entry-type", ignore_type,
"error-entry-type", error_type,
"mount", mount,
"shell", shell,
"device-info", device_info,
"load-status", RB_SOURCE_LOAD_STATUS_LOADING,
"settings", g_settings_get_child (settings, "source"),
"encoding-settings", g_settings_get_child (settings, "encoding"),
"toolbar-menu", toolbar,
NULL));
g_object_unref (settings);
g_object_unref (builder);
rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type);
plugin->player_sources = g_list_prepend (plugin->player_sources, source);
g_signal_connect_object (G_OBJECT (source),
"deleted", G_CALLBACK (rb_generic_player_plugin_source_deleted),
plugin, 0);
g_object_unref (shell);
return source;
}
static void
impl_activate (PeasActivatable *plugin)
{
TotemMoviePropertiesPlugin *pi;
TotemObject *totem;
GtkWindow *parent;
GMenu *menu;
GMenuItem *item;
pi = TOTEM_MOVIE_PROPERTIES_PLUGIN (plugin);
totem = g_object_get_data (G_OBJECT (plugin), "object");
pi->priv->props = bacon_video_widget_properties_new ();
gtk_widget_show (pi->priv->props);
gtk_widget_set_sensitive (pi->priv->props, FALSE);
parent = totem_object_get_main_window (totem);
pi->priv->dialog = gtk_dialog_new_with_buttons (_("Properties"),
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_USE_HEADER_BAR,
NULL,
GTK_RESPONSE_CLOSE,
NULL);
g_object_unref (parent);
g_signal_connect (pi->priv->dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
g_signal_connect (pi->priv->dialog, "response",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (pi->priv->dialog))),
pi->priv->props);
/* Properties action */
pi->priv->props_action = g_simple_action_new ("properties", NULL);
g_signal_connect (G_OBJECT (pi->priv->props_action), "activate",
G_CALLBACK (properties_action_cb), pi);
g_action_map_add_action (G_ACTION_MAP (totem), G_ACTION (pi->priv->props_action));
gtk_application_add_accelerator (GTK_APPLICATION (totem),
"<Primary>p",
"app.properties",
NULL);
/* FIXME: Handle GDK_KEY_View */
/* Install the menu */
menu = totem_object_get_menu_section (totem, "properties-placeholder");
item = g_menu_item_new (_("_Properties"), "app.properties");
g_menu_item_set_attribute (item, "accel", "s", "<Primary>p");
g_menu_append_item (G_MENU (menu), item);
g_object_unref (item);
g_signal_connect (G_OBJECT (totem),
"file-opened",
G_CALLBACK (totem_movie_properties_plugin_file_opened),
plugin);
g_signal_connect (G_OBJECT (totem),
"file-closed",
G_CALLBACK (totem_movie_properties_plugin_file_closed),
plugin);
g_signal_connect (G_OBJECT (totem),
"metadata-updated",
G_CALLBACK (totem_movie_properties_plugin_metadata_updated),
plugin);
pi->priv->handler_id_stream_length = g_signal_connect (G_OBJECT (totem),
"notify::stream-length",
G_CALLBACK (stream_length_notify_cb),
plugin);
}
static void
rb_playlist_source_constructed (GObject *object)
{
GObject *shell_player;
RBPlaylistSource *source;
RBShell *shell;
RhythmDB *db;
RhythmDBQueryModel *query_model;
GtkBuilder *builder;
GSettings *settings;
RB_CHAIN_GOBJECT_METHOD (rb_playlist_source_parent_class, constructed, object);
source = RB_PLAYLIST_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &db,
"shell-player", &shell_player,
NULL);
rb_playlist_source_set_db (source, db);
g_object_unref (db);
g_object_unref (shell);
/* store playlist settings using the memory backend
* this means the settings path doesn't have to be consistent,
* it just has to be unique, so the address of the source object works.
* for local playlists, we write the settings into the playlist file on disk
* to make them persistent.
*/
g_object_get (source, "settings", &settings, NULL);
if (settings == NULL) {
char *path;
path = g_strdup_printf ("/org/gnome/rhythmbox/playlist/%p/", source);
settings = g_settings_new_with_backend_and_path ("org.gnome.rhythmbox.source",
playlist_settings_backend,
path);
g_free (path);
g_object_set (source, "settings", settings, NULL);
}
g_signal_connect (settings, "changed", G_CALLBACK (playlist_settings_changed_cb), source);
g_object_unref (settings);
builder = rb_builder_load ("playlist-popup.ui", NULL);
source->priv->popup = G_MENU (gtk_builder_get_object (builder, "playlist-popup"));
rb_application_link_shared_menus (RB_APPLICATION (g_application_get_default ()), source->priv->popup);
g_object_ref (source->priv->popup);
g_object_unref (builder);
source->priv->entries = g_hash_table_new_full (rb_refstring_hash, rb_refstring_equal,
(GDestroyNotify)rb_refstring_unref, NULL);
source->priv->songs = rb_entry_view_new (source->priv->db,
shell_player,
TRUE, TRUE);
g_object_unref (shell_player);
g_signal_connect_object (source->priv->songs,
"notify::sort-order",
G_CALLBACK (rb_playlist_source_songs_sort_order_changed_cb),
source, 0);
query_model = rhythmdb_query_model_new_empty (source->priv->db);
rb_playlist_source_set_query_model (source, query_model);
g_object_unref (query_model);
{
const char *title = "";
const char *strings[3] = {0};
GtkTreeViewColumn *column = gtk_tree_view_column_new ();
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"style", PANGO_STYLE_OBLIQUE,
"weight", PANGO_WEIGHT_LIGHT,
"xalign", 1.0,
NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
strings[0] = title;
strings[1] = "9999";
rb_entry_view_set_fixed_column_width (source->priv->songs, column, renderer,
strings);
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc)
rb_playlist_source_track_cell_data_func,
source, NULL);
rb_entry_view_insert_column_custom (source->priv->songs, column, title,
"PlaylistTrack", NULL, 0, NULL, 0);
}
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_GENRE, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMPOSER, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_YEAR, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_DURATION, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_QUALITY, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_RATING, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMMENT, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LOCATION, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_FIRST_SEEN, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_BPM, FALSE);
rb_entry_view_set_columns_clickable (source->priv->songs, FALSE);
rb_playlist_source_setup_entry_view (source, source->priv->songs);
gtk_container_add (GTK_CONTAINER (source), GTK_WIDGET (source->priv->songs));
gtk_widget_show_all (GTK_WIDGET (source));
}
void
export_tools__gth_browser_construct_cb (GthBrowser *browser)
{
GtkBuilder *builder;
GMenuModel *menu;
GtkWidget *button;
g_return_if_fail (GTH_IS_BROWSER (browser));
builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/export_tools/data/ui/export-menu.ui");
gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_WEB_EXPORTERS, G_MENU (gtk_builder_get_object (builder, "web-exporters")));
gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_OTHER_EXPORTERS, G_MENU (gtk_builder_get_object (builder, "other-exporters")));
menu = G_MENU_MODEL (gtk_builder_get_object (builder, "export-menu"));
button = _gtk_menu_button_new_for_header_bar ();
gtk_widget_set_tooltip_text (button, _("Export"));
gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name ("export-symbolic", GTK_ICON_SIZE_MENU));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
gtk_widget_show_all (button);
gtk_box_pack_start (GTK_BOX (gth_browser_get_headerbar_section (browser, GTH_BROWSER_HEADER_SECTION_BROWSER_TOOLS)), button, FALSE, FALSE, 0);
}
static void
fill_open_with_menu (GtkTreeView *view, GtkBuilder *builder, GtkTreePath *path)
{
GtkTreeModel *model = gtk_tree_view_get_model (view);
if (!model) {
return;
}
GtkTreeIter iter;
if (!gtk_tree_model_get_iter(model, &iter, path)) {
return;
}
DatabaseSearchEntry *entry = (DatabaseSearchEntry *)iter.user_data;
if (!entry) {
return;
}
BTreeNode * node = db_search_entry_get_node (entry);
GList *app_list = NULL;
char *content_type = NULL;
if (node->is_dir) {
content_type = g_content_type_from_mime_type ("inode/directory");
}
else {
content_type = g_content_type_guess (node->name, NULL, 0, NULL);
}
if (!content_type) {
goto clean_up;
}
app_list = g_app_info_get_all_for_type (content_type);
if (!app_list) {
goto clean_up;
}
GMenu *menu_mime = G_MENU (gtk_builder_get_object (builder,
"fsearch_listview_menu_open_with_mime_section"));
for (GList *list_iter = app_list; list_iter; list_iter = list_iter->next) {
GAppInfo *app_info = list_iter->data;
const char *display_name = g_app_info_get_display_name (app_info);
const char *app_id = g_app_info_get_id (app_info);
char detailed_action[1024] = "";
snprintf (detailed_action, sizeof (detailed_action), "win.open_with('%s')", app_id);
GMenuItem *menu_item = g_menu_item_new (display_name, detailed_action);
g_menu_item_set_icon (menu_item, g_app_info_get_icon (app_info));
g_menu_append_item (menu_mime, menu_item);
g_object_unref (menu_item);
}
clean_up:
if (content_type) {
g_free (content_type);
content_type = NULL;
}
if (app_list) {
g_list_free_full (app_list, g_object_unref);
app_list = NULL;
}
}
static gboolean
on_listview_button_press_event (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
//printf("popup menu\n");
g_return_val_if_fail (user_data != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (G_UNLIKELY (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)))) {
// clicked outside of list (e.g. column header)
return FALSE;
}
if (event->type == GDK_BUTTON_PRESS)
{
if (event->button == GDK_BUTTON_SECONDARY)
{
GtkTreeView *view = GTK_TREE_VIEW (widget);
GtkTreePath *path = NULL;
GtkTreeSelection *selection = gtk_tree_view_get_selection (view);
if ((event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& !gtk_tree_view_get_path_at_pos (view,
event->x,
event->y,
&path,
NULL,
NULL,
NULL))
{
// clicked empty area
gtk_tree_selection_unselect_all (selection);
return FALSE;
}
if (!path) {
return FALSE;
}
if (!gtk_tree_selection_path_is_selected (selection, path)) {
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path (selection, path);
}
GtkBuilder *builder = gtk_builder_new_from_resource ("/org/fsearch/fsearch/menus.ui");
fill_open_with_menu (GTK_TREE_VIEW (widget), builder, path);
GMenu *menu_root = G_MENU (gtk_builder_get_object (builder,
"fsearch_listview_popup_menu"));
GtkWidget *menu_widget = gtk_menu_new_from_model (G_MENU_MODEL (menu_root));
gtk_menu_attach_to_widget (GTK_MENU (menu_widget),
GTK_WIDGET (widget),
NULL);
gtk_menu_popup (GTK_MENU (menu_widget), NULL, NULL, NULL, NULL,
event->button, event->time);
g_object_unref (builder);
return TRUE;
}
}
else if (event->type == GDK_2BUTTON_PRESS) {
if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))) {
GtkTreeViewColumn *column = NULL;
GtkTreePath *path = NULL;
gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
event->x,
event->y,
&path,
&column,
NULL,
NULL);
if (path) {
gtk_tree_path_free(path);
}
}
}
return FALSE;
}