static void
bloat_pad_startup (GApplication *application)
{
GtkBuilder *builder;
G_APPLICATION_CLASS (bloat_pad_parent_class)
->startup (application);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder,
"<interface>"
" <menu id='app-menu'>"
" <section>"
" <item label='_New Window' action='app.new' accel='<Primary>n'/>"
" </section>"
" <section>"
" <item label='_About Bloatpad' action='app.about'/>"
" </section>"
" <section>"
" <item label='_Quit' action='app.quit' accel='<Primary>q'/>"
" </section>"
" </menu>"
" <menu id='menubar'>"
" <submenu label='_Edit'>"
" <section>"
" <item label='_Copy' action='win.copy' accel='<Primary>c'/>"
" <item label='_Paste' action='win.paste' accel='<Primary>v'/>"
" </section>"
" </submenu>"
" <submenu label='_View'>"
" <section>"
" <item label='_Fullscreen' action='win.fullscreen'/>"
" </section>"
" </submenu>"
" </menu>"
"</interface>", -1, NULL);
gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
gtk_application_set_menubar (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")));
g_object_unref (builder);
}
static void refimpl_app_startup(GApplication* application) {
RefImplApp* app = REFIMPL_APP(application);
G_APPLICATION_CLASS(refimpl_app_parent_class)->startup(application);
g_action_map_add_action_entries(G_ACTION_MAP(app), app_entries, G_N_ELEMENTS(app_entries), app);
if (refimpl_app_has_app_menu(app)) {
GtkBuilder* builder;
GError* error = NULL;
builder = gtk_builder_new();
if (!gtk_builder_add_from_resource(builder,
"/com/bobtacoindustries/N3888_RefImpl/refimpl_menu.ui",
&error)) {
g_warning("Loading menu builder file failed. Message: %s", error->message);
g_error_free(error);
}
else {
GMenuModel* appMenu;
appMenu = G_MENU_MODEL(gtk_builder_get_object(builder, "app_menu"));
gtk_application_set_app_menu(GTK_APPLICATION(application), appMenu);
}
g_object_unref(builder);
}
//setup_accelerators(app);
}
/* 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));
}
void
initialize_app_menu (GApplication *application)
{
GtkBuilder *builder;
GSettings *settings;
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_menu_entries,
G_N_ELEMENTS (app_menu_entries),
application);
builder = _gtk_builder_new_from_resource ("app-menu.ui");
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
g_object_unref (builder);
settings = fr_application_get_settings (FR_APPLICATION (application), FILE_ROLLER_SCHEMA_UI);
g_simple_action_set_state (GET_ACTION (PREF_UI_VIEW_SIDEBAR),
g_variant_new_boolean (g_settings_get_boolean (settings, PREF_UI_VIEW_SIDEBAR)));
settings = fr_application_get_settings (FR_APPLICATION (application), FILE_ROLLER_SCHEMA_LISTING);
g_simple_action_set_state (GET_ACTION (PREF_LISTING_LIST_MODE),
g_variant_new_string (_g_enum_type_get_value (FR_TYPE_WINDOW_LIST_MODE,
g_settings_get_enum (settings, PREF_LISTING_LIST_MODE))->value_nick));
g_signal_connect (fr_application_get_settings (FR_APPLICATION (application), FILE_ROLLER_SCHEMA_UI),
"changed::" PREF_UI_VIEW_SIDEBAR,
G_CALLBACK (pref_view_sidebar_changed),
application);
g_signal_connect (fr_application_get_settings (FR_APPLICATION (application), FILE_ROLLER_SCHEMA_LISTING),
"changed::" PREF_LISTING_LIST_MODE,
G_CALLBACK (pref_list_mode_changed),
application);
}
static void
logview_app_init_actions (LogviewApp *app)
{
GtkBuilder *builder = gtk_builder_new ();
GMenuModel *app_menu;
g_action_map_add_action_entries (G_ACTION_MAP (app), action_entries,
G_N_ELEMENTS (action_entries), app);
gtk_builder_add_from_resource (builder, "/org/gnome/logview/logview-app-menu.ui", NULL);
app_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"));
gtk_application_set_app_menu (GTK_APPLICATION (app), app_menu);
/* menu accel */
SIMPLE_ACCEL (app, "F10", "win.gear-menu");
/* action accels */
SIMPLE_ACCEL (app, "<Control>f", "win.search");
SIMPLE_ACCEL (app, "<Control>o", "win.open");
SIMPLE_ACCEL (app, "<Control>w", "win.close");
SIMPLE_ACCEL (app, "<Control>c", "win.copy");
SIMPLE_ACCEL (app, "<Control>a", "win.select_all");
SIMPLE_ACCEL (app, "<Control>plus", "win.zoom_in");
SIMPLE_ACCEL (app, "<Control>minus", "win.zoom_out");
SIMPLE_ACCEL (app, "<Control>0", "win.zoom_normal");
/* additional zoom accels */
SIMPLE_ACCEL (app, "<Control>KP_Add", "win.zoom_in");
SIMPLE_ACCEL (app, "<Control>KP_Subtract", "win.zoom_out");
SIMPLE_ACCEL (app, "<Control>KP_0", "win.zoom_normal");
g_object_unref (builder);
g_object_unref (app_menu);
}
static void
nautilus_application_init_actions (NautilusApplication *self)
{
GtkBuilder *builder;
GError *error = NULL;
const gchar *debug_no_app_menu;
g_action_map_add_action_entries (G_ACTION_MAP (self),
app_entries, G_N_ELEMENTS (app_entries),
self);
gtk_application_add_accelerator (GTK_APPLICATION (self), "F10", "win.gear-menu", NULL);
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/nautilus/nautilus-app-menu.ui", &error);
if (error == NULL) {
gtk_application_set_app_menu (GTK_APPLICATION (self),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
} else {
g_critical ("Unable to add the application menu: %s\n", error->message);
g_error_free (error);
}
g_object_unref (builder);
debug_no_app_menu = g_getenv ("NAUTILUS_DEBUG_NO_APP_MENU");
if (debug_no_app_menu) {
DEBUG ("Disabling app menu GtkSetting as requested...");
g_object_set (gtk_settings_get_default (),
"gtk-shell-shows-app-menu", FALSE,
NULL);
}
}
static void
twitux_app_init_app_menu (GApplication *application)
{
GtkBuilder *builder;
GError *error = NULL;
gchar *menu_file;
g_action_map_add_action_entries (G_ACTION_MAP (application),
twitux_app_action_entries, G_N_ELEMENTS (twitux_app_action_entries),
application);
builder = gtk_builder_new ();
menu_file = twitux_utils_lookup_file ("twitux-app-menu.xml");
gtk_builder_add_from_file (builder, menu_file, &error);
if (error == NULL) {
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder,
"app-menu")));
gtk_application_set_menubar (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder,
"app-menubar")));
} else {
g_critical ("Unable to setup the application menu: %s\n", error->message);
g_error_free (error);
}
g_free (menu_file);
g_object_unref (builder);
}
static void
eog_application_init_app_menu (EogApplication *application)
{
EogApplicationPrivate *priv = application->priv;
GtkBuilder *builder;
GError *error = NULL;
GAction *action;
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_entries, G_N_ELEMENTS (app_entries),
application);
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, EOG_DATA_DIR"/eog-app-menu.xml", &error);
if (error == NULL) {
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder,
"app-menu")));
} else {
g_critical ("Unable to add the application menu: %s\n", error->message);
g_error_free (error);
}
action = g_action_map_lookup_action (G_ACTION_MAP (application),
"view-gallery");
g_settings_bind_with_mapping (priv->ui_settings,
EOG_CONF_UI_IMAGE_GALLERY, action,
"state", G_SETTINGS_BIND_DEFAULT,
_settings_map_get_bool_variant,
_settings_map_set_variant,
NULL, NULL);
action = g_action_map_lookup_action (G_ACTION_MAP (application),
"toolbar");
g_settings_bind_with_mapping (priv->ui_settings,
EOG_CONF_UI_TOOLBAR, action, "state",
G_SETTINGS_BIND_DEFAULT,
_settings_map_get_bool_variant,
_settings_map_set_variant,
NULL, NULL);
action = g_action_map_lookup_action (G_ACTION_MAP (application),
"view-sidebar");
g_settings_bind_with_mapping (priv->ui_settings,
EOG_CONF_UI_SIDEBAR, action, "state",
G_SETTINGS_BIND_DEFAULT,
_settings_map_get_bool_variant,
_settings_map_set_variant,
NULL, NULL);
action = g_action_map_lookup_action (G_ACTION_MAP (application),
"view-statusbar");
g_settings_bind_with_mapping (priv->ui_settings,
EOG_CONF_UI_STATUSBAR, action, "state",
G_SETTINGS_BIND_DEFAULT,
_settings_map_get_bool_variant,
_settings_map_set_variant,
NULL, NULL);
g_object_unref (builder);
}
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 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
screenshot_application_startup (GApplication *app)
{
ScreenshotApplication *self = SCREENSHOT_APPLICATION (app);
GtkBuilder *builder;
GMenuModel *menu;
G_APPLICATION_CLASS (screenshot_application_parent_class)->startup (app);
gtk_window_set_default_icon_name (SCREENSHOOTER_ICON);
screenshooter_init_stock_icons ();
g_action_map_add_action_entries (G_ACTION_MAP (self), action_entries,
G_N_ELEMENTS (action_entries), self);
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/screenshot/screenshot-app-menu.ui", NULL);
menu = G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"));
gtk_application_set_app_menu (GTK_APPLICATION (self), menu);
g_object_unref (builder);
g_object_unref (menu);
/* interactive mode: trigger the dialog and wait for the response */
if (screenshot_config->interactive)
screenshot_show_interactive_dialog (self);
else
screenshot_start (self);
}
static void
terminal_app_startup (GApplication *application)
{
const GActionEntry app_menu_actions[] = {
{ "preferences", app_menu_preferences_cb, NULL, NULL, NULL },
{ "help", app_menu_help_cb, NULL, NULL, NULL },
{ "about", app_menu_about_cb, NULL, NULL, NULL },
{ "quit", app_menu_quit_cb, NULL, NULL, NULL }
};
gs_unref_object GtkBuilder *builder;
GError *error = NULL;
G_APPLICATION_CLASS (terminal_app_parent_class)->startup (application);
/* Need to set the WM class (bug #685742) */
gdk_set_program_class("Gnome-terminal");
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_menu_actions, G_N_ELEMENTS (app_menu_actions),
application);
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder,
TERMINAL_RESOURCES_PATH_PREFIX "ui/terminal-appmenu.ui",
&error);
g_assert_no_error (error);
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu")));
_terminal_debug_print (TERMINAL_DEBUG_SERVER, "Startup complete\n");
}
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
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);
}
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)
{
GtkBuilder *builder;
GMenuModel *appmenu;
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/ui/widget-factory.ui", NULL);
appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
g_object_unref (builder);
}
static void
startup (GApplication *app)
{
GtkBuilder *builder;
GMenuModel *appmenu;
gchar *ids[] = { "appmenu", NULL };
builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (builder, "/ui/main.ui", ids, NULL);
appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
g_object_unref (builder);
}
void bjb_app_menu_set(GApplication *application)
{
GtkBuilder *builder;
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_entries,
G_N_ELEMENTS (app_entries),
application);
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/bijiben/app-menu.ui", NULL);
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
g_object_unref (builder);
}
static void
glarea_app_startup (GApplication *app)
{
GtkBuilder *builder;
GMenuModel *app_menu;
G_APPLICATION_CLASS (glarea_app_parent_class)->startup (app);
g_action_map_add_action_entries (G_ACTION_MAP (app),
app_entries, G_N_ELEMENTS (app_entries),
app);
builder = gtk_builder_new_from_resource ("/io/bassi/glarea/glarea-app-menu.ui");
app_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu"));
gtk_application_set_app_menu (GTK_APPLICATION (app), app_menu);
g_object_unref (builder);
}
static void
startup_wizard(GApplication *app,
gpointer user_data)
{
g_action_map_add_action_entries(G_ACTION_MAP (app),
app_entries, G_N_ELEMENTS (app_entries),
app);
GMenu *app_menu = g_menu_new();
g_menu_append(app_menu, _("Preferences"), "app.preferences");
GMenu *service_app_menu_sec = g_menu_new();
g_menu_append(service_app_menu_sec, _("Quit"), "app.quit");
g_menu_append_section(app_menu, /*no title*/NULL, G_MENU_MODEL(service_app_menu_sec));
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL(app_menu));
}
static void
gw_application_load_app_menu (GwApplication *application)
{
//Sanity checks
g_return_if_fail (application != NULL);
//Declarations
GtkBuilder *builder;
GMenuModel *model;
GtkSettings *settings;
gboolean loaded;
gboolean os_shows_app_menu;
gboolean os_shows_win_menu;
const gchar *filename;
//Initializations
builder = NULL;
model = NULL;
loaded = FALSE;
settings = gtk_settings_get_default ();
g_object_get (settings, "gtk-shell-shows-app-menu", &os_shows_app_menu, NULL);
g_object_get (settings, "gtk-shell-shows-menubar", &os_shows_win_menu, NULL);
gw_application_map_actions (G_ACTION_MAP (application), application);
if (os_shows_app_menu && os_shows_win_menu) //Mac OS X style
filename = "application-menumodel-macosx.ui";
else if (os_shows_app_menu != os_shows_win_menu) //Gnome 3 style
filename = "application-menumodel-gnome.ui";
else //Windows style
filename = NULL;
if (filename == NULL) goto errored;
builder = gtk_builder_new (); if (builder == NULL) goto errored;
loaded = gw_application_load_xml (builder, filename); if (loaded == FALSE) goto errored;
model = G_MENU_MODEL (gtk_builder_get_object (builder, "menu")); if (model == NULL) goto errored;
gtk_application_set_app_menu (GTK_APPLICATION (application), model);
gw_application_initialize_menumodel_links (application);
errored:
if (builder != NULL) g_object_unref (builder);
}
static void
startup (GApplication *app)
{
GtkBuilder *builder;
GMenuModel *appmenu;
GMenuModel *menubar;
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/application/menus.ui", NULL);
appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
menubar = (GMenuModel *)gtk_builder_get_object (builder, "menubar");
gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
g_object_unref (builder);
}
static void example_app_startup(GApplication *app)
{
GtkBuilder *builder;
GMenuModel *app_menu;
const gchar *quit_accels[2] = { "<Ctrl>Q", NULL };
G_APPLICATION_CLASS(example_app_parent_class)->startup(app);
g_action_map_add_action_entries(G_ACTION_MAP(app), app_entries,
G_N_ELEMENTS(app_entries), app);
gtk_application_set_accels_for_action(GTK_APPLICATION(app), "app.quit",
quit_accels);
builder = gtk_builder_new_from_resource("/org/gtk/exampleapp/app-menu.ui");
app_menu = G_MENU_MODEL(gtk_builder_get_object(builder, "appmenu"));
gtk_application_set_app_menu(GTK_APPLICATION(app), app_menu);
g_object_unref(builder);
}
void
nautilus_init_application_actions (NautilusApplication *app)
{
GtkBuilder *builder;
GError *error = NULL;
gboolean show_sidebar;
const gchar *debug_no_app_menu;
g_action_map_add_action_entries (G_ACTION_MAP (app),
app_entries, G_N_ELEMENTS (app_entries),
app);
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/nautilus/nautilus-app-menu.ui", &error);
if (error == NULL) {
gtk_application_set_app_menu (GTK_APPLICATION (app),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
} else {
g_critical ("Unable to add the application menu: %s\n", error->message);
g_error_free (error);
}
g_object_unref (builder);
debug_no_app_menu = g_getenv ("NAUTILUS_DEBUG_NO_APP_MENU");
if (debug_no_app_menu) {
DEBUG ("Disabling app menu GtkSetting as requested...");
g_object_set (gtk_settings_get_default (),
"gtk-shell-shows-app-menu", FALSE,
NULL);
}
show_sidebar = g_settings_get_boolean (nautilus_window_state,
NAUTILUS_WINDOW_STATE_START_WITH_SIDEBAR);
g_action_group_change_action_state (G_ACTION_GROUP (app),
"show-hide-sidebar",
g_variant_new_boolean (show_sidebar));
nautilus_application_add_accelerator (G_APPLICATION (app), "app.show-hide-sidebar", "F9");
nautilus_application_add_accelerator (G_APPLICATION (app), "app.bookmarks", "<control>b");
}
static void
initialize_app_menu (GApplication *application)
{
gboolean show_app_menu;
GtkBuilder *builder;
g_object_get (gtk_settings_get_default (),
"gtk-shell-shows-app-menu", &show_app_menu,
NULL);
if (! show_app_menu)
return;
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_menu_entries,
G_N_ELEMENTS (app_menu_entries),
application);
builder = _gtk_builder_new_from_resource ("app-menu.ui");
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
g_object_unref (builder);
}
static void
dss_app_startup (GApplication * app)
{
GtkBuilder *builder;
GMenuModel *app_menu;
const gchar *quit_accels[2] = { "<Ctrl>Q", NULL };
G_APPLICATION_CLASS (dss_app_parent_class)->startup (app);
/* Setup app menu and accels */
g_action_map_add_action_entries (G_ACTION_MAP (app), app_entries,
G_N_ELEMENTS (app_entries), app);
gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit",
quit_accels);
builder = gtk_builder_new_from_resource (APPMENU_FILE);
app_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu"));
gtk_application_set_app_menu (GTK_APPLICATION (app), app_menu);
g_object_unref (builder);
/* Initialize gstreamer only once per application */
gst_init (NULL, NULL);
}
static void
initialize_app_menu (GApplication *application)
{
GooApplication *self = (GooApplication *) application;
GtkBuilder *builder;
g_action_map_add_action_entries (G_ACTION_MAP (application),
goo_application_actions,
G_N_ELEMENTS (goo_application_actions),
application);
builder = _gtk_builder_new_from_resource ("app-menu.ui");
gtk_application_set_app_menu (GTK_APPLICATION (application),
G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_PLAYALL)),
g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_PLAYALL)));
g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_REPEAT)),
g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_REPEAT)));
g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_SHUFFLE)),
g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_SHUFFLE)));
g_signal_connect (self->priv->settings,
"changed::" PREF_PLAYLIST_PLAYALL,
G_CALLBACK (pref_playlist_playall_changed),
self);
g_signal_connect (self->priv->settings,
"changed::" PREF_PLAYLIST_SHUFFLE,
G_CALLBACK (pref_playlist_shuffle_changed),
self);
g_signal_connect (self->priv->settings,
"changed::" PREF_PLAYLIST_REPEAT,
G_CALLBACK (pref_playlist_repeat_changed),
self);
g_object_unref (builder);
}
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
GyahtzeeCreateMainWindow (void)
{
GtkWidget *hbox, *vbox;
GtkWidget *toolbar;
GtkWidget *tmp;
GtkWidget *dicebox;
GtkAccelGroup *accel_group;
GtkBuilder *builder;
GtkUIManager *ui_manager;
int i, j;
window = gtk_application_window_new (application);
gtk_window_set_application (GTK_WINDOW (window), application);
gtk_window_set_title (GTK_WINDOW (window), _(appName));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), TRUE);
//games_conf_add_window (GTK_WINDOW (window), NULL);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (quit_game), NULL);
g_signal_connect (G_OBJECT (window), "key_press_event",
G_CALLBACK (key_press), NULL);
statusbar = gtk_statusbar_new ();
ui_manager = gtk_ui_manager_new ();
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder, builder_description, -1, NULL);
games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar);
/*---- Menus ----*/
create_menus (ui_manager);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
/*---- Content ----*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);
gtk_widget_show (statusbar);
/* Retreive dice pixmaps from memory or files */
LoadDicePixmaps ();
/* Put all the dice in a vertical column */
dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
gtk_widget_show (dicebox);
rollLabel = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
gtk_widget_show (rollLabel);
gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);
mbutton = gtk_button_new_with_label (_("Roll!"));
gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
g_signal_connect (G_OBJECT (mbutton), "clicked",
G_CALLBACK (roll_dice), NULL);
gtk_widget_show (GTK_WIDGET (mbutton));
toolbar = gtk_toolbar_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);
for (i = 0; i < NUMBER_OF_DICE; i++) {
tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
}
diceBox[i] = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
g_signal_connect (G_OBJECT (diceBox[i]), "clicked",
G_CALLBACK (modify_dice), &DiceValues[i]);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (diceBox[i]), -1);
gtk_widget_show (GTK_WIDGET (diceBox[i]));
gtk_widget_show (tmp);
/*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
}
gtk_widget_show (toolbar);
/* Scores displayed in score list */
ScoreList = create_score_list ();
gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
setup_score_list (ScoreList);
gtk_widget_show (ScoreList);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (window);
GyahtzeeNewGame ();
}
/*********************************************************************** Menu */
void
bmd_construct_menu (GtkApplication *app, gpointer data)
{
GtkWidget *headerbar;
// the application menu displayed in the GNOME panel
GMenu *appmenu;
GMenu *editmenu;
GtkWidget *openbutton;
GtkWidget *savebutton;
// the menu displayed as a popover below the gears button
GMenu *gearmenu;
GtkWidget *gearmenubutton;
GtkWidget *gearicon;
bmd_widgets *a = (bmd_widgets *) data;
// define keyboard accelerators
const gchar *open_accels[2] = { "<Ctrl>O", NULL };
const gchar *save_accels[2] = { "<Ctrl>S", NULL };
const gchar *quit_accels[2] = { "<Ctrl>Q", NULL };
const gchar *add_accels[2] = { "<Ctrl>A", NULL };
const gchar *del_accels[2] = { "<Ctrl>D", NULL };
const gchar *find_accels[2] = { "<Ctrl>F", NULL };
const gchar *help_accels[2] = { "F1", NULL };
// create and fill in the application menu in the GNOME panel
appmenu = g_menu_new();
g_menu_append (appmenu, "About", "app.about");
g_menu_append (appmenu, "Help", "app.help");
g_menu_append (appmenu, "_Quit", "app.quit");
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu));
g_object_unref (appmenu);
// create a headerbar
headerbar = gtk_header_bar_new ();
gtk_widget_show (headerbar);
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Book Management");
gtk_header_bar_set_subtitle (GTK_HEADER_BAR (headerbar), "Simple Demo Application");
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE);
gtk_window_set_titlebar (GTK_WINDOW (a->window), headerbar);
// create an OPEN button, add it to the headerbar and connect the callbacks
openbutton = gtk_button_new_with_label ("Open");
gtk_header_bar_pack_start (GTK_HEADER_BAR (headerbar), openbutton);
gtk_actionable_set_action_name (GTK_ACTIONABLE (openbutton), "app.open");
// create the gear menu button
gearmenubutton = gtk_menu_button_new();
gearicon = gtk_image_new_from_icon_name ("emblem-system-symbolic",
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image (GTK_BUTTON (gearmenubutton), gearicon);
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), gearmenubutton);
// create a menu for the gear button
gearmenu = g_menu_new();
g_menu_append (gearmenu, "Save As ...", "app.saveAs");
editmenu = g_menu_new();
g_menu_append (editmenu, "_Find", "app.find");
g_menu_append (editmenu, "_Add", "app.add");
g_menu_append (editmenu, "_Delete", "app.delete");
g_menu_append_section (gearmenu, NULL, G_MENU_MODEL (editmenu));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (gearmenubutton),
G_MENU_MODEL (gearmenu));
g_object_unref (editmenu);
g_object_unref (gearmenu);
// create an SAVE button, add it to the headerbar and connect the callbacks
savebutton = gtk_button_new_with_label ("Save");
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), savebutton);
gtk_actionable_set_action_name (GTK_ACTIONABLE (savebutton), "app.save");
// connect keyboard accelerators
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.open", open_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.save", save_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.quit", quit_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.add", add_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.delete", del_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.find", find_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.help", help_accels);
}
