static void
_brio_application_set_app_menu (GApplication *app)
{
GMenu *app_menu = g_menu_new ();
GSimpleAction *about;
GSimpleAction *quit;
about = g_simple_action_new ("about", NULL);
g_signal_connect (about,
"activate",
G_CALLBACK (_brio_application_show_about),
app);
g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (about));
g_menu_append (app_menu, _("About"), "app.about");
quit = g_simple_action_new ("quit", NULL);
g_signal_connect (quit,
"activate",
G_CALLBACK (_brio_application_quit),
app);
g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (quit));
g_menu_append (app_menu, _("Quit"), "app.quit");
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (app_menu));
}
static void
application_startup_cb (GApplication *application,
GnomeControlCenter *shell)
{
GMenu *menu, *section;
GAction *action;
action = G_ACTION (g_simple_action_new ("help", NULL));
g_action_map_add_action (G_ACTION_MAP (application), action);
g_signal_connect (action, "activate", G_CALLBACK (help_activated), shell);
action = G_ACTION (g_simple_action_new ("quit", NULL));
g_action_map_add_action (G_ACTION_MAP (application), action);
g_signal_connect (action, "activate", G_CALLBACK (quit_activated), shell);
menu = g_menu_new ();
section = g_menu_new ();
g_menu_append (section, _("Help"), "app.help");
g_menu_append (section, _("Quit"), "app.quit");
g_menu_append_section (menu, NULL, G_MENU_MODEL (section));
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (menu));
gtk_application_add_accelerator (GTK_APPLICATION (application),
"F1", "app.help", NULL);
/* nothing else to do here, we don't want to show a window before
* we've looked at the commandline
*/
}
static GSimpleActionGroup *
create_action_group(ReaderWindowPrivate *priv)
{
GSimpleActionGroup *actions = g_simple_action_group_new();
gboolean side_pane = cainteoir_settings_get_boolean(priv->settings, "index", "visible", TRUE);
priv->index_pane_action = g_simple_action_new_stateful("side-pane", nullptr, g_variant_new_boolean(side_pane));
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->index_pane_action));
g_signal_connect(priv->index_pane_action, "activate", G_CALLBACK(on_index_pane_toggle_action), priv);
priv->open_action = g_simple_action_new("open", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->open_action));
g_signal_connect(priv->open_action, "activate", G_CALLBACK(on_open_file_action), priv);
priv->play_stop_action = g_simple_action_new("play-stop", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->play_stop_action));
g_signal_connect(priv->play_stop_action, "activate", G_CALLBACK(on_play_stop_action), priv);
priv->record_action = g_simple_action_new("record", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->record_action));
g_signal_connect(priv->record_action, "activate", G_CALLBACK(on_record_action), priv);
return actions;
}
static void
shell_add_actions (GApplication *application)
{
GActionMap *action_map;
GSimpleAction *action;
action_map = G_ACTION_MAP (application);
/* Add actions that remote instances can invoke. */
action = g_simple_action_new ("new-window", G_VARIANT_TYPE_STRING);
g_signal_connect (
action, "activate",
G_CALLBACK (shell_action_new_window_cb), application);
g_action_map_add_action (action_map, G_ACTION (action));
g_object_unref (action);
action = g_simple_action_new (
"handle-uris", G_VARIANT_TYPE_STRING_ARRAY);
g_signal_connect (
action, "activate",
G_CALLBACK (shell_action_handle_uris_cb), application);
g_action_map_add_action (action_map, G_ACTION (action));
g_object_unref (action);
action = g_simple_action_new ("quit", NULL);
g_signal_connect (
action, "activate",
G_CALLBACK (shell_action_quit_cb), application);
g_action_map_add_action (action_map, G_ACTION (action));
g_object_unref (action);
}
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
cc_application_startup (GApplication *application)
{
CcApplication *self = CC_APPLICATION (application);
GMenu *menu;
GMenu *section;
GSimpleAction *action;
G_APPLICATION_CLASS (cc_application_parent_class)->startup (application);
#ifdef HAVE_CHEESE
if (gtk_clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
{
g_critical ("Unable to initialize Clutter");
return;
}
#endif /* HAVE_CHEESE */
/* register a symbolic icon size for use in sidebar lists */
gtk_icon_size_register ("cc-sidebar-list", 24, 24);
action = g_simple_action_new ("help", NULL);
g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (help_activated), self);
g_object_unref (action);
action = g_simple_action_new ("quit", NULL);
g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (cc_application_quit), self);
g_object_unref (action);
/* Launch panel by id. The parameter is a (panel_id, array_of_panel_parameters)
* tuple. The GVariant-containing array usually is just the same array of
* strings that would be generated by passing panel-specific arguments on
* the command line. */
action = g_simple_action_new ("launch-panel", G_VARIANT_TYPE ("(sav)"));
g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
g_signal_connect (action, "activate", G_CALLBACK (launch_panel_activated), self);
g_object_unref (action);
menu = g_menu_new ();
section = g_menu_new ();
g_menu_append (section, _("Help"), "app.help");
g_menu_append (section, _("Quit"), "app.quit");
g_menu_append_section (menu, NULL, G_MENU_MODEL (section));
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (menu));
gtk_application_add_accelerator (GTK_APPLICATION (application),
"F1", "app.help", NULL);
self->priv->window = cc_window_new (GTK_APPLICATION (application));
}
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);
}
}
static void
gcal_application_set_app_menu (GApplication *app)
{
GcalApplicationPrivate *priv;
GMenu *app_menu;
GMenu *view_as;
GSimpleAction *about;
GSimpleAction *quit;
g_return_if_fail (GCAL_IS_APPLICATION (app));
priv = GCAL_APPLICATION (app)->priv;
app_menu = g_menu_new ();
priv->view = g_simple_action_new_stateful (
"view",
G_VARIANT_TYPE_STRING,
g_settings_get_value (priv->settings, "active-view"));
g_signal_connect (priv->view,
"activate",
G_CALLBACK (gcal_application_change_view),
app);
g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (priv->view));
view_as = g_menu_new ();
g_menu_append (view_as, _("Weeks"), "app.view::week");
g_menu_append (view_as, _("Months"), "app.view::month");
g_menu_append_section (app_menu, _("View as"), G_MENU_MODEL (view_as));
about = g_simple_action_new ("about", NULL);
g_signal_connect (about,
"activate",
G_CALLBACK (gcal_application_show_about),
app);
g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (about));
g_menu_append (app_menu, _("About"), "app.about");
quit = g_simple_action_new ("quit", NULL);
g_signal_connect (quit,
"activate",
G_CALLBACK (gcal_application_quit),
app);
g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (quit));
g_menu_append (app_menu, _("Quit"), "app.quit");
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (app_menu));
}
static void
startup (GApplication *app,
gpointer user_data)
{
GSimpleAction *new_action;
GSimpleAction *quit_action;
new_action = g_simple_action_new ("new", NULL);
g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
quit_action = g_simple_action_new ("quit", NULL);
g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
}
static void
activate (GtkApplication *app,
gpointer user_data)
{
GtkWidget *window;
GSimpleAction *about_action;
/* Create a window with a title and a default size */
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "AboutDialog Example");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
/* Create a new simple action, giving it a NULL parameter type. It will
* always be NULL for actions invoked from a menu. (e.g clicking on an "ok"
* or "cancel" button)
*/
about_action = g_simple_action_new ("about", NULL);
/* Connect the "activate" signal to the appropriate callback function.
* It will indicate that the action was just activated.
*/
g_signal_connect (about_action, "activate", G_CALLBACK (about_cb),
GTK_WINDOW (window));
/* Adds the about_action to the overall action map. An Action map is an
* interface that contains a number of named GAction instances
* (such as about_action)
*/
g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
gtk_widget_show_all (window);
}
/* Startup function for the menu we are creating in this sample */
static void
startup (GApplication *app,
gpointer user_data)
{
GMenu *menu;
GSimpleAction *quit_action;
/* Initialize the GMenu, and add a menu item with label "About" and action
* "win.about". Also add another menu item with label "Quit" and action
* "app.quit"
*/
menu = g_menu_new ();
g_menu_append (menu, "About", "win.about");
g_menu_append (menu, "Quit", "app.quit");
/* Create a new simple action for the application. (In this case it is the
* "quit" action.
*/
quit_action = g_simple_action_new ("quit", NULL);
/* Ensure that the menu we have just created is set for the overall application */
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (menu));
g_signal_connect (quit_action,
"activate",
G_CALLBACK (quit_cb),
app);
g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
}
/* Object initialization
* Create private structure and set up default values
*/
static void xfdashboard_application_init(XfdashboardApplication *self)
{
XfdashboardApplicationPrivate *priv;
GSimpleAction *action;
priv=self->priv=XFDASHBOARD_APPLICATION_GET_PRIVATE(self);
/* Set default values */
priv->isDaemon=FALSE;
priv->isSuspended=FALSE;
priv->themeName=NULL;
priv->inited=FALSE;
priv->xfconfChannel=NULL;
priv->viewManager=NULL;
priv->searchManager=NULL;
priv->focusManager=NULL;
priv->theme=NULL;
priv->xfconfThemeChangedSignalID=0L;
priv->isQuitting=FALSE;
priv->sessionManagementClient=NULL;
/* Add callable DBUS actions for this application */
action=g_simple_action_new("Quit", NULL);
g_signal_connect(action, "activate", G_CALLBACK(xfdashboard_application_quit_forced), NULL);
g_action_map_add_action(G_ACTION_MAP(self), G_ACTION(action));
g_object_unref(action);
}
static void
drawing_area_hierarchy_changed (GtkWidget *widget,
GtkWidget *previous_toplevel)
{
DrawingArea *area = (DrawingArea *) widget;
GSimpleActionGroup *action_group;
GSimpleAction *action;
GtkWidget *toplevel;
gint i;
if (previous_toplevel && area->pad_controller)
{
gtk_widget_remove_controller (previous_toplevel,
GTK_EVENT_CONTROLLER (area->pad_controller));
area->pad_controller = NULL;
}
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (area));
if (!GTK_IS_WINDOW (toplevel))
return;
action_group = g_simple_action_group_new ();
area->pad_controller = gtk_pad_controller_new (G_ACTION_GROUP (action_group),
NULL);
for (i = 0; i < G_N_ELEMENTS (pad_actions); i++)
{
if (pad_actions[i].type == GTK_PAD_ACTION_BUTTON)
{
action = g_simple_action_new (pad_actions[i].action_name, NULL);
g_object_set_data (G_OBJECT (action), "color",
(gpointer) pad_colors[i]);
g_signal_connect (action, "activate",
G_CALLBACK (on_pad_button_activate), area);
}
else
{
action = g_simple_action_new_stateful (pad_actions[i].action_name,
G_VARIANT_TYPE_DOUBLE, NULL);
g_signal_connect (action, "activate",
G_CALLBACK (on_pad_knob_change), area);
}
g_action_map_add_action (G_ACTION_MAP (action_group), G_ACTION (action));
g_object_unref (action);
}
gtk_pad_controller_set_action_entries (area->pad_controller, pad_actions,
G_N_ELEMENTS (pad_actions));
gtk_widget_add_controller (toplevel,
GTK_EVENT_CONTROLLER (area->pad_controller));
}
static void
impl_activate (EogWindowActivatable *activatable)
{
const gchar * const accel_keys[] = { "W", NULL };
EogFitToWidthPlugin *plugin = EOG_FIT_TO_WIDTH_PLUGIN (activatable);
GMenu *model, *menu;
GMenuItem *item;
GSimpleAction *action;
GAction *ref_action;
model= eog_window_get_gear_menu_section (plugin->window,
"plugins-section");
g_return_if_fail (G_IS_MENU (model));
/* Setup and inject action */
action = g_simple_action_new (EOG_FIT_TO_WIDTH_PLUGIN_ACTION, NULL);
g_signal_connect(action, "activate",
G_CALLBACK (fit_to_width_cb), plugin->window);
g_action_map_add_action (G_ACTION_MAP (plugin->window),
G_ACTION (action));
/* Bind to the zoom-normal action's enabled property to only enable
* fit-to-width zooming if zooming is generally enabled */
ref_action = g_action_map_lookup_action (G_ACTION_MAP (plugin->window),
"zoom-normal");
if (ref_action)
g_object_bind_property (ref_action, "enabled",
action, "enabled",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_unref (action);
/* Append entry to the window's gear menu */
menu = g_menu_new ();
g_menu_append (menu, _("Fit to width"),
"win." EOG_FIT_TO_WIDTH_PLUGIN_ACTION);
item = g_menu_item_new_section (NULL, G_MENU_MODEL (menu));
g_menu_item_set_attribute (item, "id",
"s", EOG_FIT_TO_WIDTH_PLUGIN_MENU_ID);
g_menu_item_set_attribute (item, G_MENU_ATTRIBUTE_ICON,
"s", "zoom-fit-best-symbolic");
g_menu_append_item (model, item);
g_object_unref (item);
g_object_unref (menu);
/* Define accelerator keys */
gtk_application_set_accels_for_action (GTK_APPLICATION (EOG_APP),
"win." EOG_FIT_TO_WIDTH_PLUGIN_ACTION,
accel_keys);
}
static void
eog_reload_plugin_activate (EogWindowActivatable *activatable)
{
const gchar * const accel_keys[] = { "R", NULL };
EogReloadPlugin *plugin = EOG_RELOAD_PLUGIN (activatable);
GMenu *model, *menu;
GMenuItem *item;
GSimpleAction *action;
eog_debug (DEBUG_PLUGINS);
model= eog_window_get_gear_menu_section (plugin->window,
"plugins-section");
g_return_if_fail (G_IS_MENU (model));
/* Setup and inject action */
action = g_simple_action_new (EOG_RELOAD_PLUGIN_ACTION, NULL);
g_signal_connect(action, "activate",
G_CALLBACK (reload_cb), plugin->window);
g_action_map_add_action (G_ACTION_MAP (plugin->window),
G_ACTION (action));
g_object_unref (action);
g_signal_connect (G_OBJECT (eog_window_get_thumb_view (plugin->window)),
"selection-changed",
G_CALLBACK (_selection_changed_cb),
plugin);
eog_reload_plugin_update_action_state (plugin);
/* Append entry to the window's gear menu */
menu = g_menu_new ();
g_menu_append (menu, _("Reload Image"),
"win." EOG_RELOAD_PLUGIN_ACTION);
item = g_menu_item_new_section (NULL, G_MENU_MODEL (menu));
g_menu_item_set_attribute (item, "id",
"s", EOG_RELOAD_PLUGIN_MENU_ID);
g_menu_item_set_attribute (item, G_MENU_ATTRIBUTE_ICON,
"s", "view-refresh-symbolic");
g_menu_append_item (model, item);
g_object_unref (item);
g_object_unref (menu);
/* Define accelerator keys */
gtk_application_set_accels_for_action (GTK_APPLICATION (EOG_APP),
"win." EOG_RELOAD_PLUGIN_ACTION,
accel_keys);
}
void main_window_menu(GtkApplicationWindow* window, main_window* data){
GSimpleAction* action;
action = g_simple_action_new("new", NULL);
g_signal_connect(action, "activate", G_CALLBACK(new_handler), data);
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(action));
action = g_simple_action_new("open", NULL);
g_signal_connect(action, "activate", G_CALLBACK(open_handler), data);
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(action));
action = g_simple_action_new("quit", NULL);
g_signal_connect_swapped(action, "activate",
G_CALLBACK(gtk_window_close), window);
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(action));
action = g_simple_action_new("zoomin", NULL);
g_signal_connect(action, "activate", G_CALLBACK(zoom_in), data);
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(action));
action = g_simple_action_new("zoomout", NULL);
g_signal_connect(action, "activate", G_CALLBACK(zoom_out), data);
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(action));
}
/**
* Creates window menu
*/
GtkWidget
*create_windowmenu (ezeedo_wrapper_structure *ezeedo)
{
// define widgets
GtkWidget *windowmenu_button;
GtkWidget *win;
GMenu *windowmenu;
win = ezeedo->window;
// define actions
GSimpleAction *toggle_action;
// create gear menu
windowmenu = g_menu_new ();
g_menu_append (windowmenu,
"Toggle sidebar",
"win.toggle_sidebar");
// create actions
toggle_action = g_simple_action_new ("toggle_sidebar",
NULL);
g_signal_connect (toggle_action, "activate",
G_CALLBACK(toggle_sidebar), ezeedo);
g_action_map_add_action (G_ACTION_MAP(win),
G_ACTION(toggle_action));
// activate ctrl-h
const gchar* toggle_accels[2] = { "<Ctrl>H", NULL };
gtk_application_set_accels_for_action (GTK_APPLICATION(ezeedo->application),
"win.toggle_sidebar",
toggle_accels);
// create window menu
windowmenu_button = gtk_menu_button_new ();
gtk_menu_button_set_direction (GTK_MENU_BUTTON(windowmenu_button),
GTK_ARROW_NONE);
// attach window menu to button
gtk_menu_button_set_use_popover (GTK_MENU_BUTTON(windowmenu_button),
true);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON(windowmenu_button),
G_MENU_MODEL(windowmenu));
// return button with window menu
return (windowmenu_button);
}
static void
nemo_application_init (NemoApplication *application)
{
GSimpleAction *action;
application->priv =
G_TYPE_INSTANCE_GET_PRIVATE (application, NEMO_TYPE_APPLICATION,
NemoApplicationPriv);
action = g_simple_action_new ("quit", NULL);
g_action_map_add_action (G_ACTION_MAP (application), G_ACTION (action));
g_signal_connect_swapped (action, "activate",
G_CALLBACK (nemo_application_quit), application);
g_object_unref (action);
}
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
impl_activate (EogWindowActivatable *activatable)
{
EogPostrPlugin *plugin = EOG_POSTR_PLUGIN (activatable);
GMenu *model, *menu;
GMenuItem *item;
GSimpleAction *action;
eog_debug (DEBUG_PLUGINS);
g_return_if_fail (plugin->window != NULL);
model= eog_window_get_gear_menu_section (plugin->window,
"plugins-section");
g_return_if_fail (G_IS_MENU (model));
/* Setup and inject action */
action = g_simple_action_new (EOG_POSTR_PLUGIN_ACTION, NULL);
g_signal_connect(action, "activate",
G_CALLBACK (postr_cb), plugin->window);
g_action_map_add_action (G_ACTION_MAP (plugin->window),
G_ACTION (action));
g_object_unref (action);
/* Append entry to the window's gear menu */
menu = g_menu_new ();
g_menu_append (menu, _("Upload to Flickr"),
"win." EOG_POSTR_PLUGIN_ACTION);
item = g_menu_item_new_section (NULL, G_MENU_MODEL (menu));
g_menu_item_set_attribute (item, "id",
"s", EOG_POSTR_PLUGIN_MENU_ID);
g_menu_item_set_attribute (item, G_MENU_ATTRIBUTE_ICON,
"s", "postr");
g_menu_append_item (model, item);
g_object_unref (item);
g_object_unref (menu);
}
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
add_actions (GApplication *app)
{
GSimpleActionGroup *actions;
GSimpleAction *action;
actions = g_simple_action_group_new ();
action = g_simple_action_new ("simple-action", NULL);
g_signal_connect (action, "activate", G_CALLBACK (activate_action), app);
g_simple_action_group_insert (actions, G_ACTION (action));
g_object_unref (action);
action = g_simple_action_new_stateful ("toggle-action", NULL,
g_variant_new_boolean (FALSE));
g_signal_connect (action, "activate", G_CALLBACK (activate_toggle_action), app);
g_simple_action_group_insert (actions, G_ACTION (action));
g_object_unref (action);
g_application_set_action_group (app, G_ACTION_GROUP (actions));
g_object_unref (actions);
}
static void
activate (GtkApplication *app,
gpointer user_data)
{
GMenu *submenu;
GtkWidget *grid;
GMenu *menumodel;
GtkWidget *window;
GtkWidget *menubutton;
GSimpleAction *about_action;
window = gtk_application_window_new (app);
grid = gtk_grid_new ();
gtk_window_set_title (GTK_WINDOW (window), "MenuButton Example");
gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
menubutton = gtk_menu_button_new ();
gtk_widget_set_size_request (menubutton, 80, 35);
gtk_grid_attach (GTK_GRID (grid), menubutton, 0, 0, 1, 1);
gtk_container_add (GTK_CONTAINER (window), grid);
menumodel = g_menu_new ();
g_menu_append (menumodel, "New", "app.new");
g_menu_append (menumodel, "About", "win.about");
submenu = g_menu_new ();
g_menu_append_submenu (menumodel, "Other", G_MENU_MODEL (submenu));
g_menu_append (submenu, "Quit", "app.quit");
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menubutton), G_MENU_MODEL (menumodel));
about_action = g_simple_action_new ("about", NULL);
g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
GTK_WINDOW (window));
g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
gtk_widget_show_all (window);
}
void
Ekiga::GActorMenu::add_gio_action (Ekiga::ActionPtr a)
{
GSimpleAction *action = NULL;
/* Action is disabled or already present */
if (!a->is_enabled ())
return;
g_action_map_remove_action (G_ACTION_MAP (g_application_get_default ()),
a->get_name ().c_str ());
action = g_simple_action_new (a->get_name ().c_str (), NULL);
g_object_set_data_full (G_OBJECT (action), "action",
g_strdup (a->get_name ().c_str ()),
(GDestroyNotify) g_free);
g_action_map_add_action (G_ACTION_MAP (g_application_get_default ()),
G_ACTION (action));
g_signal_connect (action, "activate",
G_CALLBACK (action_activated),
(gpointer) this);
g_object_unref (action);
}
void
_rb_add_display_page_actions (GActionMap *map, GObject *shell, const GActionEntry *actions, gint n_entries)
{
int i;
for (i = 0; i < n_entries; i++) {
GSimpleAction *action;
const GVariantType *parameter_type;
DisplayPageActionData *page_action_data;
if (g_action_map_lookup_action (map, actions[i].name) != NULL) {
/* action was already added */
continue;
}
if (actions[i].parameter_type) {
parameter_type = G_VARIANT_TYPE (actions[i].parameter_type);
} else {
parameter_type = NULL;
}
if (actions[i].state) {
GVariant *state;
GError *error = NULL;
state = g_variant_parse (NULL, actions[i].state, NULL, NULL, &error);
if (state == NULL) {
g_critical ("could not parse state value '%s' for action "
"%s: %s",
actions[i].state, actions[i].name, error->message);
g_error_free (error);
continue;
}
action = g_simple_action_new_stateful (actions[i].name,
parameter_type,
state);
} else {
action = g_simple_action_new (actions[i].name, parameter_type);
}
if (actions[i].activate) {
GClosure *closure;
page_action_data = g_slice_new0 (DisplayPageActionData);
page_action_data->u.gaction = (DisplayPageActionActivateCallback) actions[i].activate;
page_action_data->shell = shell;
g_object_add_weak_pointer (shell, &page_action_data->shell);
closure = g_cclosure_new (G_CALLBACK (display_page_action_activate_cb),
page_action_data,
(GClosureNotify) display_page_action_data_destroy);
g_signal_connect_closure (action, "activate", closure, FALSE);
}
if (actions[i].change_state) {
GClosure *closure;
page_action_data = g_slice_new0 (DisplayPageActionData);
page_action_data->u.gactionstate = (DisplayPageActionChangeStateCallback) actions[i].change_state;
page_action_data->shell = shell;
g_object_add_weak_pointer (shell, &page_action_data->shell);
closure = g_cclosure_new (G_CALLBACK (display_page_action_change_state_cb),
page_action_data,
(GClosureNotify) display_page_action_data_destroy);
g_signal_connect_closure (action, "change-state", closure, FALSE);
}
g_action_map_add_action (map, G_ACTION (action));
g_object_unref (action);
}
}
static void
photos_application_startup (GApplication *application)
{
PhotosApplication *self = PHOTOS_APPLICATION (application);
PhotosApplicationPrivate *priv = self->priv;
GError *error;
GSimpleAction *action;
GrlRegistry *registry;
GtkSettings *settings;
GVariant *state;
G_APPLICATION_CLASS (photos_application_parent_class)
->startup (application);
gegl_init (NULL, NULL);
grl_init (NULL, NULL);
registry = grl_registry_get_default ();
error = NULL;
if (!grl_registry_load_plugin_by_id (registry, "grl-flickr", &error))
{
g_warning ("Unable to load Grilo's Flickr plugin: %s", error->message);
g_error_free (error);
}
priv->settings = g_settings_new ("org.gnome.desktop.background");
priv->resource = photos_get_resource ();
g_resources_register (priv->resource);
settings = gtk_settings_get_default ();
g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL);
priv->facebook_miner = gom_miner_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.OnlineMiners.Facebook",
"/org/gnome/OnlineMiners/Facebook",
NULL,
NULL);
priv->flickr_miner = gom_miner_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.OnlineMiners.Flickr",
"/org/gnome/OnlineMiners/Flickr",
NULL,
NULL);
priv->item_mngr = photos_item_manager_dup_singleton ();
/* A dummy reference to keep it alive during the lifetime of the
* application.
*/
priv->camera_cache = photos_camera_cache_dup_singleton ();
priv->mode_cntrlr = photos_mode_controller_dup_singleton ();
action = g_simple_action_new ("about", NULL);
g_signal_connect_swapped (action, "activate", G_CALLBACK (photos_application_about), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (action));
g_object_unref (action);
priv->fs_action = g_simple_action_new ("fullscreen", NULL);
g_signal_connect_swapped (priv->fs_action, "activate", G_CALLBACK (photos_application_fullscreen), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->fs_action));
g_signal_connect_swapped (priv->mode_cntrlr,
"can-fullscreen-changed",
G_CALLBACK (photos_application_can_fullscreen_changed),
self);
state = g_variant_new ("b", FALSE);
priv->gear_action = g_simple_action_new_stateful ("gear-menu", NULL, state);
g_signal_connect (priv->gear_action, "activate", G_CALLBACK (photos_application_action_toggle), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->gear_action));
priv->open_action = g_simple_action_new ("open-current", NULL);
g_signal_connect_swapped (priv->open_action, "activate", G_CALLBACK (photos_application_open_current), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->open_action));
priv->print_action = g_simple_action_new ("print-current", NULL);
g_signal_connect_swapped (priv->print_action, "activate", G_CALLBACK (photos_application_print_current), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->print_action));
priv->properties_action = g_simple_action_new ("properties", NULL);
g_signal_connect_swapped (priv->properties_action, "activate", G_CALLBACK (photos_application_properties), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->properties_action));
priv->remote_display_action = g_simple_action_new ("remote-display-current", NULL);
g_signal_connect_swapped (priv->remote_display_action, "activate", G_CALLBACK (photos_application_remote_display_current), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->remote_display_action));
action = g_simple_action_new ("quit", NULL);
g_signal_connect_swapped (action, "activate", G_CALLBACK (photos_application_quit), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (action));
g_object_unref (action);
state = g_variant_new ("b", FALSE);
priv->search_action = g_simple_action_new_stateful ("search", NULL, state);
g_signal_connect (priv->search_action, "activate", G_CALLBACK (photos_application_action_toggle), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->search_action));
priv->sel_all_action = g_simple_action_new ("select-all", NULL);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->sel_all_action));
priv->sel_none_action = g_simple_action_new ("select-none", NULL);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->sel_none_action));
priv->set_bg_action = g_simple_action_new ("set-background", NULL);
g_signal_connect_swapped (priv->set_bg_action, "activate", G_CALLBACK (photos_application_set_bg), self);
g_action_map_add_action (G_ACTION_MAP (self), G_ACTION (priv->set_bg_action));
g_signal_connect_swapped (priv->mode_cntrlr,
"window-mode-changed",
G_CALLBACK (photos_application_window_mode_changed),
self);
photos_application_init_app_menu (self);
gtk_application_add_accelerator (GTK_APPLICATION (self), "<Primary>q", "app.quit", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (self), "F11", "app.fullscreen", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (self), "F10", "app.gear-menu", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (self), "<Primary>p", "app.print-current", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (self), "<Primary>f", "app.search", NULL);
gtk_application_add_accelerator (GTK_APPLICATION (self), "<Primary>a", "app.select-all", NULL);
}
/**
* Sets up the application when it first starts
*/
void
startup (GApplication *app,
gpointer user_data)
{
// get ezeedo from user data
ezeedo_wrapper_structure *ezeedo;
ezeedo = user_data;
// define widgets
GMenu *menu;
GMenu *section;
// define actions
GSimpleAction *preferences_action;
GSimpleAction *quit_action;
// create application menu
menu = g_menu_new ();
// create section
section = g_menu_new ();
// contruct application menu
g_menu_append (section,
"About",
"win.about");
g_menu_append (section,
"Quit",
"app.quit");
g_menu_append (menu,
"Preferences",
"app.preferences");
g_menu_append_section (menu,
NULL,
G_MENU_MODEL (section));
// create actions
preferences_action = g_simple_action_new ("preferences",
NULL);
g_signal_connect (preferences_action, "activate",
G_CALLBACK(show_preferences_dialog), ezeedo);
g_action_map_add_action (G_ACTION_MAP(app),
G_ACTION(preferences_action));
// activate ctrl-q
const gchar* quit_accels[2] = { "<Ctrl>Q", NULL };
gtk_application_set_accels_for_action (GTK_APPLICATION(app),
"app.quit",
quit_accels);
quit_action = g_simple_action_new ("quit",
NULL);
g_signal_connect (quit_action, "activate",
G_CALLBACK (quit_application), ezeedo);
g_action_map_add_action (G_ACTION_MAP(app),
G_ACTION(quit_action));
// Set menu for the overall application
gtk_application_set_app_menu (GTK_APPLICATION(app),
G_MENU_MODEL(menu));
return;
}
/**
* Creates empty main application window
*/
GtkWidget
*create_mainwindow (ezeedo_wrapper_structure *ezeedo)
{
// define widgets
GtkWidget *window;
GtkWidget *headerbar;
GtkWidget *windowmenu_button;
GtkWidget *stack;
GtkWidget *stackswitcher;
GtkWidget *todo_stack;
GtkWidget *todo_paned;
GtkWidget *todolist_scrollbox;
GtkWidget *todolist_box;
GtkWidget *categories_scrollbox;
GtkWidget *categories_box;
GtkWidget *task_entry;
GtkWidget *done_stack;
GtkWidget *donelist_scrollbox;
GtkWidget *donelist_box;
GtkWidget *archive_button;
// define action
GSimpleAction *about_action;
// get window size and position from gsettings store
GSettings *settings;
gint width;
gint height;
gint x;
gint y;
gint sidebar_size;
settings = g_settings_new ("org.y20k.ezeedo");
width = g_settings_get_int (settings,
"main-window-width");
height = g_settings_get_int (settings,
"main-window-height");
x = g_settings_get_int (settings,
"main-window-position-y");
y = g_settings_get_int (settings,
"main-window-position-y");
sidebar_size = g_settings_get_int (settings,
"sidebar-size");
g_object_unref (settings);
// create main window with title and default size
window = gtk_application_window_new (ezeedo->application);
gtk_window_set_title (GTK_WINDOW (window),
"Ezeedo");
gtk_window_set_icon_name (GTK_WINDOW (window),
EZEEDOICON);
gtk_window_set_default_size (GTK_WINDOW (window),
width,
height);
gtk_window_move (GTK_WINDOW (window),
x,
y);
// create headerbar and stack switcher
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(headerbar),
true);
stackswitcher = gtk_stack_switcher_new ();
// create stack for todo and done
stack = gtk_stack_new ();
// create stack for todolist
todo_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create paned container for left and right columns of todo tab
todo_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED(todo_paned),
sidebar_size);
// create categories scrollbox and box for left pane
categories_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
categories_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create todolist scrollbox and box for right pane
todolist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
todolist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create task entry
task_entry = gtk_entry_new ();
gtk_widget_set_margin_start (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_end (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_top (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET(task_entry),
10);
gtk_entry_set_placeholder_text (GTK_ENTRY(task_entry),
"Enter new task");
gtk_entry_set_max_length (GTK_ENTRY(task_entry),
TASKLENGTH);
gtk_widget_grab_focus (task_entry);
// create stack for donelist
done_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create donelist scrollbox and box
donelist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
donelist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create archive button
archive_button = gtk_button_new_with_label ("Archive all done tasks");
gtk_widget_set_margin_start (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_end (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_top (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET (archive_button),
10);
// add some widgets to ezeedo wrapper structure
ezeedo->window = window;
ezeedo->todo_paned = todo_paned;
ezeedo->categories_box = categories_box;
ezeedo->todolist_box = todolist_box;
ezeedo->donelist_box = donelist_box;
// create window menu
windowmenu_button = create_windowmenu (ezeedo);
// create about action and connect about action signal
about_action = g_simple_action_new ("about",
NULL);
g_action_map_add_action (G_ACTION_MAP (window),
G_ACTION (about_action));
g_signal_connect (about_action, "activate",
G_CALLBACK (show_about_window), window);
// detect entry signal
g_signal_connect (task_entry, "activate",
G_CALLBACK (add_task_entry), ezeedo);
// detect archive button pressed
g_signal_connect (archive_button, "clicked",
G_CALLBACK (display_info_dialog), "Task archival is not supported yet.");
// detect window close
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (close_window), ezeedo);
// construct headerbar for main window
gtk_window_set_titlebar (GTK_WINDOW(window),
headerbar);
gtk_header_bar_pack_start (GTK_HEADER_BAR(headerbar),
stackswitcher);
gtk_header_bar_pack_end (GTK_HEADER_BAR(headerbar),
windowmenu_button);
// add stack to main window
gtk_container_add (GTK_CONTAINER(window),
stack);
// set stack switcher and populate stack with todolist and donelist
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER(stackswitcher),
GTK_STACK(stack));
gtk_stack_add_titled (GTK_STACK(stack),
todo_stack,
"To do",
"To do");
gtk_stack_add_titled (GTK_STACK(stack),
done_stack,
"Done",
"Done");
// construct main todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
todo_paned);
gtk_paned_add1 (GTK_PANED(todo_paned),
categories_scrollbox);
gtk_paned_add2 (GTK_PANED(todo_paned),
todolist_scrollbox);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(todolist_scrollbox),
todolist_box);
// add task entry to todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
task_entry);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(categories_scrollbox),
categories_box);
// construct main donelist stack
gtk_container_add (GTK_CONTAINER(done_stack),
donelist_scrollbox);
gtk_container_add (GTK_CONTAINER(donelist_scrollbox),
donelist_box);
return (window);
}
static void rotation_plugin_real_activate (PeasActivatable* base) {
RotationPlugin * self;
TotemObject* t = NULL;
GObject* _tmp0_ = NULL;
GObject* _tmp1_ = NULL;
gchar* mrl = NULL;
TotemObject* _tmp2_ = NULL;
gchar* _tmp3_ = NULL;
GMenu* menu = NULL;
TotemObject* _tmp4_ = NULL;
GMenu* _tmp5_ = NULL;
GMenu* _tmp6_ = NULL;
TotemObject* _tmp7_ = NULL;
GtkWidget* _tmp8_ = NULL;
BaconVideoWidget* _tmp9_ = NULL;
GSimpleAction* _tmp10_ = NULL;
GSimpleAction* _tmp11_ = NULL;
TotemObject* _tmp12_ = NULL;
GSimpleAction* _tmp13_ = NULL;
TotemObject* _tmp14_ = NULL;
GSimpleAction* _tmp15_ = NULL;
GSimpleAction* _tmp16_ = NULL;
TotemObject* _tmp17_ = NULL;
GSimpleAction* _tmp18_ = NULL;
TotemObject* _tmp19_ = NULL;
GMenuItem* item = NULL;
const gchar* _tmp20_ = NULL;
GMenuItem* _tmp21_ = NULL;
GMenuItem* _tmp22_ = NULL;
GMenu* _tmp23_ = NULL;
GMenuItem* _tmp24_ = NULL;
const gchar* _tmp25_ = NULL;
GMenuItem* _tmp26_ = NULL;
GMenuItem* _tmp27_ = NULL;
GMenu* _tmp28_ = NULL;
GMenuItem* _tmp29_ = NULL;
const gchar* _tmp30_ = NULL;
const gchar* _tmp33_ = NULL;
TotemObject* _tmp35_ = NULL;
TotemObject* _tmp36_ = NULL;
self = (RotationPlugin*) base;
g_object_get ((PeasActivatable*) self, "object", &_tmp0_, NULL);
_tmp1_ = _tmp0_;
t = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, totem_object_get_type (), TotemObject);
_tmp2_ = t;
_tmp3_ = totem_object_get_current_mrl (_tmp2_);
mrl = _tmp3_;
_tmp4_ = t;
_tmp5_ = totem_object_get_menu_section (_tmp4_, "rotation-placeholder");
_tmp6_ = _g_object_ref0 (_tmp5_);
menu = _tmp6_;
_tmp7_ = t;
_tmp8_ = totem_object_get_video_widget (_tmp7_);
_tmp9_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, BACON_TYPE_VIDEO_WIDGET) ? ((BaconVideoWidget*) _tmp8_) : NULL;
if (_tmp9_ == NULL) {
_g_object_unref0 (_tmp8_);
}
_g_object_unref0 (self->priv->bvw);
self->priv->bvw = _tmp9_;
_tmp10_ = g_simple_action_new ("rotate-left", NULL);
_g_object_unref0 (self->priv->rotate_left_action);
self->priv->rotate_left_action = _tmp10_;
_tmp11_ = self->priv->rotate_left_action;
g_signal_connect_object (_tmp11_, "activate", (GCallback) _rotation_plugin_cb_rotate_left_g_simple_action_activate, self, 0);
_tmp12_ = t;
_tmp13_ = self->priv->rotate_left_action;
g_action_map_add_action ((GActionMap*) _tmp12_, (GAction*) _tmp13_);
_tmp14_ = t;
gtk_application_add_accelerator ((GtkApplication*) _tmp14_, "<Primary><Shift>R", "app.rotate-left", NULL);
_tmp15_ = g_simple_action_new ("rotate-right", NULL);
_g_object_unref0 (self->priv->rotate_right_action);
self->priv->rotate_right_action = _tmp15_;
_tmp16_ = self->priv->rotate_right_action;
g_signal_connect_object (_tmp16_, "activate", (GCallback) _rotation_plugin_cb_rotate_right_g_simple_action_activate, self, 0);
_tmp17_ = t;
_tmp18_ = self->priv->rotate_right_action;
g_action_map_add_action ((GActionMap*) _tmp17_, (GAction*) _tmp18_);
_tmp19_ = t;
gtk_application_add_accelerator ((GtkApplication*) _tmp19_, "<Primary>R", "app.rotate-right", NULL);
_tmp20_ = _ ("_Rotate ↷");
_tmp21_ = g_menu_item_new (_tmp20_, "app.rotate-right");
item = _tmp21_;
_tmp22_ = item;
g_menu_item_set_attribute (_tmp22_, "accel", "s", "<Primary>R", NULL);
_tmp23_ = menu;
_tmp24_ = item;
g_menu_append_item (_tmp23_, _tmp24_);
_tmp25_ = _ ("Rotate ↶");
_tmp26_ = g_menu_item_new (_tmp25_, "app.rotate-left");
_g_object_unref0 (item);
item = _tmp26_;
_tmp27_ = item;
g_menu_item_set_attribute (_tmp27_, "accel", "s", "<Primary><Shift>R", NULL);
_tmp28_ = menu;
_tmp29_ = item;
g_menu_append_item (_tmp28_, _tmp29_);
_tmp30_ = mrl;
if (_tmp30_ == NULL) {
GSimpleAction* _tmp31_ = NULL;
GSimpleAction* _tmp32_ = NULL;
_tmp31_ = self->priv->rotate_right_action;
g_simple_action_set_enabled (_tmp31_, FALSE);
_tmp32_ = self->priv->rotate_left_action;
g_simple_action_set_enabled (_tmp32_, FALSE);
}
_tmp33_ = mrl;
if (_tmp33_ != NULL) {
const gchar* _tmp34_ = NULL;
_tmp34_ = mrl;
rotation_plugin_try_restore_state (self, _tmp34_, ____lambda6__gasync_ready_callback, g_object_ref (self));
}
_tmp35_ = t;
g_signal_connect_object (_tmp35_, "file-closed", (GCallback) _rotation_plugin_cb_file_closed_totem_object_file_closed, self, 0);
_tmp36_ = t;
g_signal_connect_object (_tmp36_, "file-opened", (GCallback) _rotation_plugin_cb_file_opened_totem_object_file_opened, self, 0);
_g_object_unref0 (item);
_g_object_unref0 (menu);
_g_free0 (mrl);
_g_object_unref0 (t);
}
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);
}