gint main (gint argc, gchar *argv[]) { gtk_init (&argc, &argv); g_object_set (gtk_settings_get_default (), "gtk-application-prefer-dark-theme", TRUE, NULL); gsize size = DEFAULT_SIZE; guint32 target = DEFAULT_TARGET; const gchar *theme = DEFAULT_THEME; GOptionEntry options[] = { { "size", 's', 0, G_OPTION_ARG_INT, &size, "The size of the grid", "4" }, { "target", '\0', 0, G_OPTION_ARG_INT, &target, "The tile to reach", "2048" }, { "theme", 't', 0, G_OPTION_ARG_STRING, &theme, "The theme to use", DEFAULT_THEME }, { NULL, '\0', 0, G_OPTION_ARG_NONE, NULL, NULL, NULL } }; G_2048_CLEANUP_OPTIONS_FREE GOptionContext *ctx = g_option_context_new ("foobar"); g_option_context_add_main_entries (ctx, options, NULL); g_option_context_add_group (ctx, gtk_get_option_group (TRUE)); g_option_context_parse (ctx, &argc, &argv, NULL); GtkApplication *app = gtk_application_new ("org.gnome.g2048", G_APPLICATION_FLAGS_NONE); GApplication *gapp = G_APPLICATION (app); G_2048_CLEANUP_ERROR_FREE GError *error = NULL; G_APPLICATION_GET_CLASS (gapp)->activate = show_win; g_application_register (gapp, NULL, &error); if (error) { fprintf (stderr, "Failed to register the gtk application: %s\n", error->message); return EXIT_FAILURE; } if (g_application_get_is_remote (gapp)) { g_application_activate (gapp); return EXIT_SUCCESS; } G_2048_CLEANUP_FREE gchar *theme_path = get_theme_path (theme); if (!theme_path) theme_path = get_theme_path (DEFAULT_THEME); if (!theme_path) { g_critical ("No theme found"); exit (EXIT_FAILURE); } GtkWidget *score_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); GtkBox *hbox = GTK_BOX (score_box); gtk_box_pack_start (hbox, gtk_label_new ("Score:"), TRUE, TRUE, 0); GtkWidget *score_label = gtk_label_new ("0"); GtkLabel *label = GTK_LABEL (score_label); GdkRGBA color; gdk_rgba_parse (&color, "white"); gtk_widget_override_background_color (score_label, GTK_STATE_FLAG_NORMAL, &color); gdk_rgba_parse (&color, "black"); gtk_widget_override_color (score_label, GTK_STATE_FLAG_NORMAL, &color); gtk_label_set_width_chars (GTK_LABEL (score_label), 8); gtk_box_pack_end (hbox, score_label, TRUE, FALSE, 0); GtkWidget *box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); GtkBox *vbox = GTK_BOX (box); gtk_box_pack_start (vbox, g_2048_grid_new (size, target, theme_path, label), TRUE, TRUE, 0); gtk_box_pack_end (vbox, score_box, TRUE, TRUE, 20); GtkWidget *win = gtk_widget_new (GTK_TYPE_APPLICATION_WINDOW, "application", app, "type", GTK_WINDOW_TOPLEVEL, "window-position", GTK_WIN_POS_CENTER, "resizable", FALSE, NULL); gtk_container_add (GTK_CONTAINER (win), box); gtk_widget_show_all (win); gtk_widget_override_font (win, pango_font_description_from_string("Monospace 18")); GTK_WIDGET_GET_CLASS (win)->key_press_event = on_key; return g_application_run (gapp, argc, argv); }
static gboolean nemo_application_local_command_line (GApplication *application, gchar ***arguments, gint *exit_status) { gboolean perform_self_check = FALSE; gboolean version = FALSE; gboolean browser = FALSE; gboolean kill_shell = FALSE; gboolean no_default_window = FALSE; gboolean fix_cache = FALSE; gchar **remaining = NULL; NemoApplication *self = NEMO_APPLICATION (application); const GOptionEntry options[] = { #ifndef NEMO_OMIT_SELF_CHECK { "check", 'c', 0, G_OPTION_ARG_NONE, &perform_self_check, N_("Perform a quick set of self-check tests."), NULL }, #endif /* dummy, only for compatibility reasons */ { "browser", '\0', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &browser, NULL, NULL }, { "version", '\0', 0, G_OPTION_ARG_NONE, &version, N_("Show the version of the program."), NULL }, { "geometry", 'g', 0, G_OPTION_ARG_STRING, &self->priv->geometry, N_("Create the initial window with the given geometry."), N_("GEOMETRY") }, { "no-default-window", 'n', 0, G_OPTION_ARG_NONE, &no_default_window, N_("Only create windows for explicitly specified URIs."), NULL }, { "no-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->no_desktop, N_("Never manage the desktop (ignore the GSettings preference)."), NULL }, { "force-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->force_desktop, N_("Always manage the desktop (ignore the GSettings preference)."), NULL }, { "fix-cache", '\0', 0, G_OPTION_ARG_NONE, &fix_cache, N_("Repair the user thumbnail cache - this can be useful if you're having trouble with file thumbnails. Must be run as root"), NULL }, { "quit", 'q', 0, G_OPTION_ARG_NONE, &kill_shell, N_("Quit Nemo."), NULL }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") }, { NULL } }; GOptionContext *context; GError *error = NULL; gint argc = 0; gchar **argv = NULL; *exit_status = EXIT_SUCCESS; context = g_option_context_new (_("\n\nBrowse the file system with the file manager")); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); argv = *arguments; argc = g_strv_length (argv); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("Could not parse arguments: %s\n", error->message); g_error_free (error); *exit_status = EXIT_FAILURE; goto out; } if (version) { g_print ("nemo " PACKAGE_VERSION "\n"); goto out; } if (!do_cmdline_sanity_checks (self, perform_self_check, version, kill_shell, remaining)) { *exit_status = EXIT_FAILURE; goto out; } if (perform_self_check) { do_perform_self_checks (exit_status); goto out; } if (fix_cache) { if (geteuid () != 0) { g_printerr ("The --fix-cache option must be run with sudo or as the root user.\n"); } else { gnome_desktop_thumbnail_cache_fix_permissions (); g_print ("User thumbnail cache successfully repaired.\n"); } goto out; } DEBUG ("Parsing local command line, no_default_window %d, quit %d, " "self checks %d, no_desktop %d", no_default_window, kill_shell, perform_self_check, self->priv->no_desktop); g_application_register (application, NULL, &error); if (error != NULL) { g_printerr ("Could not register the application: %s\n", error->message); g_error_free (error); *exit_status = EXIT_FAILURE; goto out; } if (kill_shell) { DEBUG ("Killing application, as requested"); g_action_group_activate_action (G_ACTION_GROUP (application), "quit", NULL); goto out; } GFile **files; gint idx, len; len = 0; files = NULL; /* Convert args to GFiles */ if (remaining != NULL) { GFile *file; GPtrArray *file_array; file_array = g_ptr_array_new (); for (idx = 0; remaining[idx] != NULL; idx++) { file = g_file_new_for_commandline_arg (remaining[idx]); if (file != NULL) { g_ptr_array_add (file_array, file); } } len = file_array->len; files = (GFile **) g_ptr_array_free (file_array, FALSE); g_strfreev (remaining); } if (files == NULL && !no_default_window) { files = g_malloc0 (2 * sizeof (GFile *)); len = 1; files[0] = g_file_new_for_path (g_get_home_dir ()); files[1] = NULL; } /* Invoke "Open" to create new windows */ if (len > 0) { g_application_open (application, files, len, ""); } for (idx = 0; idx < len; idx++) { g_object_unref (files[idx]); } g_free (files); out: g_option_context_free (context); return TRUE; }
int main (int argc, char **argv) { GtkWidget *window; GdkScreen *screen; int monitor; GdkRectangle rect; GError *error = NULL; char *font = NULL; char **remaining = NULL; GtkApplication *application; guint status; GOptionEntry goptions[] = { { "font", 0, 0, G_OPTION_ARG_STRING, &font, N_("Font to start with; ex: 'Serif 27'"), N_("FONT") }, { "version", 0, G_OPTION_FLAG_HIDDEN | G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, { "print", 'p', 0, G_OPTION_ARG_CALLBACK, option_print_cb, "Print characters in string", "STRING" }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[STRING…]") }, { NULL } }; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Not interested in silly debug spew polluting the journal, bug #749195 */ if (g_getenv ("G_ENABLE_DIAGNOSTIC") == NULL) g_setenv ("G_ENABLE_DIAGNOSTIC", "0", TRUE); /* Set programme name explicitly (see bug #653115) */ g_set_prgname("gucharmap"); if (!gtk_init_with_args (&argc, &argv, NULL, goptions, GETTEXT_PACKAGE, &error)) { g_printerr ("%s\n", error->message); g_error_free (error); exit (1); } g_set_application_name (_("Character Map")); gtk_window_set_default_icon_name (GUCHARMAP_ICON_NAME); application = gtk_application_new ("org.gnome.Charmap", G_APPLICATION_NON_UNIQUE); g_signal_connect (application, "startup", G_CALLBACK (startup_cb), NULL); g_signal_connect (application, "activate", G_CALLBACK (gucharmap_activate), NULL); g_application_register (G_APPLICATION (application), NULL, NULL); /* Gucharmap doesn't work right with the dark theme, see #741939. * Apparently this got fixed in gtk+ some time before 3.22, so * only work around this on older versions. */ if (gtk_check_version (3, 22, 0) != NULL /* < 3.22.0 */) g_object_set (gtk_settings_get_default (), "gtk-application-prefer-dark-theme", FALSE, NULL); window = gucharmap_window_new (application); screen = gtk_window_get_screen (GTK_WINDOW (window)); monitor = gdk_screen_get_monitor_at_point (screen, 0, 0); #if GTK_CHECK_VERSION (3, 3, 5) gdk_screen_get_monitor_workarea (screen, monitor, &rect); #else gdk_screen_get_monitor_geometry (screen, monitor, &rect); #endif gtk_window_set_default_size (GTK_WINDOW (window), rect.width * 9/16, rect.height * 9/16); if (font) { gucharmap_window_set_font (GUCHARMAP_WINDOW (window), font); g_free (font); } gtk_window_present (GTK_WINDOW (window)); if (remaining) { char *str = g_strjoinv (" ", remaining); gucharmap_window_search (GUCHARMAP_WINDOW (window), str); g_free (str); g_strfreev (remaining); } status = g_application_run (G_APPLICATION (application), argc, argv); g_object_unref (application); return status; }
int main (int argc, char **argv) { GError *error; GvcApplet *applet; GApplication *app = NULL; static GOptionEntry entries[] = { { "debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL }, { "version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL }, { NULL, 0, 0, 0, NULL, NULL, NULL } }; bindtextdomain (GETTEXT_PACKAGE, "/usr/share/cinnamon/locale"); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gvc_log_init (); error = NULL; gtk_init_with_args (&argc, &argv, (char *) _(" — Cinnamon Volume Control Applet"), entries, GETTEXT_PACKAGE, &error); if (error != NULL) { g_warning ("%s", error->message); exit (1); } if (show_version) { g_print ("%s %s\n", argv [0], VERSION); exit (1); } gvc_log_set_debug (debug); if (debug == FALSE) { GError *error = NULL; app = g_application_new (GVCA_DBUS_NAME, G_APPLICATION_FLAGS_NONE); if (!g_application_register (app, NULL, &error)) { g_warning ("%s", error->message); g_error_free (error); return 1; } if (g_application_get_is_remote (app)) { g_warning ("Applet is already running, exiting"); return 0; } } gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), ICON_DATA_DIR); applet = gvc_applet_new (); gvc_applet_start (applet); gtk_main (); if (applet != NULL) { g_object_unref (applet); } if (app != NULL) { g_object_unref (app); } return 0; }
static void *gtk_thread(void *arg) { struct gtk_mod *mod = arg; GtkMenuShell *app_menu; GtkWidget *item; GError *err = NULL; struct le *le; gdk_threads_init(); gtk_init(0, NULL); g_set_application_name("baresip"); mod->app = g_application_new ("com.creytiv.baresip", G_APPLICATION_FLAGS_NONE); g_application_register (G_APPLICATION (mod->app), NULL, &err); if (err != NULL) { warning ("Unable to register GApplication: %s", err->message); g_error_free (err); err = NULL; } #ifdef USE_LIBNOTIFY notify_init("baresip"); #endif mod->status_icon = gtk_status_icon_new_from_icon_name("call-start"); gtk_status_icon_set_tooltip_text (mod->status_icon, "baresip"); g_signal_connect(G_OBJECT(mod->status_icon), "button_press_event", G_CALLBACK(status_icon_on_button_press), mod); gtk_status_icon_set_visible(mod->status_icon, TRUE); mod->contacts_inited = false; mod->dial_dialog = NULL; mod->call_windows = NULL; mod->incoming_call_menus = NULL; /* App menu */ mod->app_menu = gtk_menu_new(); app_menu = GTK_MENU_SHELL(mod->app_menu); /* Account submenu */ mod->accounts_menu = gtk_menu_new(); mod->accounts_menu_group = NULL; item = gtk_menu_item_new_with_mnemonic("_Account"); gtk_menu_shell_append(app_menu, item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->accounts_menu); /* Add accounts to submenu */ for (le = list_head(uag_list()); le; le = le->next) { struct ua *ua = le->data; accounts_menu_add_item(mod, ua); } /* Status submenu */ mod->status_menu = gtk_menu_new(); item = gtk_menu_item_new_with_mnemonic("_Status"); gtk_menu_shell_append(GTK_MENU_SHELL(app_menu), item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->status_menu); /* Open */ item = gtk_radio_menu_item_new_with_label(NULL, "Open"); g_object_set_data(G_OBJECT(item), "presence", GINT_TO_POINTER(PRESENCE_OPEN)); g_signal_connect(item, "activate", G_CALLBACK(menu_on_presence_set), mod); gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); /* Closed */ item = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM(item), "Closed"); g_object_set_data(G_OBJECT(item), "presence", GINT_TO_POINTER(PRESENCE_CLOSED)); g_signal_connect(item, "activate", G_CALLBACK(menu_on_presence_set), mod); gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* Dial */ item = gtk_menu_item_new_with_mnemonic("_Dial..."); gtk_menu_shell_append(app_menu, item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_dial), mod); /* Dial contact */ mod->contacts_menu = gtk_menu_new(); item = gtk_menu_item_new_with_mnemonic("Dial _contact"); gtk_menu_shell_append(app_menu, item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->contacts_menu); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* About */ item = gtk_menu_item_new_with_mnemonic("A_bout"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_about), mod); gtk_menu_shell_append(app_menu, item); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* Quit */ item = gtk_menu_item_new_with_mnemonic("_Quit"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_quit), mod); gtk_menu_shell_append(app_menu, item); g_action_map_add_action_entries(G_ACTION_MAP(mod->app), app_entries, G_N_ELEMENTS(app_entries), mod); info("gtk_menu starting\n"); uag_event_register( ua_event_handler, mod ); mod->run = true; gtk_main(); mod->run = false; uag_event_unregister(ua_event_handler); if (mod->dial_dialog) { mem_deref(mod->dial_dialog); mod->dial_dialog = NULL; } return NULL; }
static gboolean nautilus_application_local_command_line (GApplication *application, gchar ***arguments, gint *exit_status) { gboolean perform_self_check = FALSE; gboolean version = FALSE; gboolean browser = FALSE; gboolean kill_shell = FALSE; gboolean open_new_window = FALSE; gboolean no_default_window = FALSE; gboolean select_uris = FALSE; gchar **remaining = NULL; NautilusApplication *self = NAUTILUS_APPLICATION (application); const GOptionEntry options[] = { #ifndef NAUTILUS_OMIT_SELF_CHECK { "check", 'c', 0, G_OPTION_ARG_NONE, &perform_self_check, N_("Perform a quick set of self-check tests."), NULL }, #endif /* dummy, only for compatibility reasons */ { "browser", '\0', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &browser, NULL, NULL }, { "version", '\0', 0, G_OPTION_ARG_NONE, &version, N_("Show the version of the program."), NULL }, { "geometry", 'g', 0, G_OPTION_ARG_STRING, &self->priv->geometry, N_("Create the initial window with the given geometry."), N_("GEOMETRY") }, { "new-window", 'w', 0, G_OPTION_ARG_NONE, &open_new_window, N_("Always open a new window for browsing specified URIs"), NULL }, { "no-default-window", 'n', 0, G_OPTION_ARG_NONE, &no_default_window, N_("Only create windows for explicitly specified URIs."), NULL }, { "no-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->no_desktop, N_("Never manage the desktop (ignore the GSettings preference)."), NULL }, { "force-desktop", '\0', 0, G_OPTION_ARG_NONE, &self->priv->force_desktop, N_("Always manage the desktop (ignore the GSettings preference)."), NULL }, { "quit", 'q', 0, G_OPTION_ARG_NONE, &kill_shell, N_("Quit Nautilus."), NULL }, { "select", 's', 0, G_OPTION_ARG_NONE, &select_uris, N_("Select specified URI in parent folder."), NULL }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") }, { NULL } }; GOptionContext *context; GError *error = NULL; gint argc = 0; gchar **argv = NULL; *exit_status = EXIT_SUCCESS; nautilus_profile_start (NULL); context = g_option_context_new (_("\n\nBrowse the file system with the file manager")); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gtk_get_option_group (FALSE)); argv = *arguments; argc = g_strv_length (argv); if (!g_option_context_parse (context, &argc, &argv, &error)) { /* Translators: this is a fatal error quit message printed on the * command line */ g_printerr ("%s: %s\n", _("Could not parse arguments"), error->message); g_error_free (error); *exit_status = EXIT_FAILURE; goto out; } if (version) { g_print ("GNOME nautilus " PACKAGE_VERSION "\n"); goto out; } if (!do_cmdline_sanity_checks (self, perform_self_check, version, kill_shell, select_uris, remaining)) { *exit_status = EXIT_FAILURE; goto out; } if (perform_self_check) { do_perform_self_checks (exit_status); goto out; } DEBUG ("Parsing local command line: open_new_window %d, no_default_window %d, " "quit %d, self checks %d, no_desktop %d, show_desktop %d", open_new_window, no_default_window, kill_shell, perform_self_check, self->priv->no_desktop, self->priv->force_desktop); g_application_register (application, NULL, &error); if (error != NULL) { /* Translators: this is a fatal error quit message printed on the * command line */ g_printerr ("%s: %s\n", _("Could not register the application"), error->message); g_error_free (error); *exit_status = EXIT_FAILURE; goto out; } if (kill_shell) { DEBUG ("Killing application, as requested"); g_action_group_activate_action (G_ACTION_GROUP (application), "kill", NULL); goto out; } GFile **files; gint idx, len; len = 0; files = NULL; /* Convert args to GFiles */ if (remaining != NULL) { GFile *file; GPtrArray *file_array; file_array = g_ptr_array_new (); for (idx = 0; remaining[idx] != NULL; idx++) { file = g_file_new_for_commandline_arg (remaining[idx]); if (file != NULL) { g_ptr_array_add (file_array, file); } } len = file_array->len; files = (GFile **) g_ptr_array_free (file_array, FALSE); g_strfreev (remaining); } if (files == NULL && !no_default_window && !select_uris) { files = g_malloc0 (2 * sizeof (GFile *)); len = 1; files[0] = g_file_new_for_path (g_get_home_dir ()); files[1] = NULL; } if (len == 0) { goto out; } if (select_uris) { nautilus_application_select (self, files, len); } else { /* Invoke "Open" to create new windows */ g_application_open (application, files, len, open_new_window ? "new-window" : ""); } for (idx = 0; idx < len; idx++) { g_object_unref (files[idx]); } g_free (files); out: g_option_context_free (context); nautilus_profile_end (NULL); return TRUE; }
static gboolean screenshot_application_local_command_line (GApplication *app, gchar ***arguments, gint *exit_status) { gboolean clipboard_arg = FALSE; gboolean window_arg = FALSE; gboolean area_arg = FALSE; gboolean include_border_arg = FALSE; gboolean disable_border_arg = FALSE; gboolean include_pointer_arg = FALSE; gboolean interactive_arg = FALSE; gchar *border_effect_arg = NULL; guint delay_arg = 0; gchar *file_arg = NULL; const GOptionEntry entries[] = { { "clipboard", 'c', 0, G_OPTION_ARG_NONE, &clipboard_arg, N_("Send the grab directly to the clipboard"), NULL }, { "window", 'w', 0, G_OPTION_ARG_NONE, &window_arg, N_("Grab a window instead of the entire screen"), NULL }, { "area", 'a', 0, G_OPTION_ARG_NONE, &area_arg, N_("Grab an area of the screen instead of the entire screen"), NULL }, { "include-border", 'b', 0, G_OPTION_ARG_NONE, &include_border_arg, N_("Include the window border with the screenshot"), NULL }, { "remove-border", 'B', 0, G_OPTION_ARG_NONE, &disable_border_arg, N_("Remove the window border from the screenshot"), NULL }, { "include-pointer", 'p', 0, G_OPTION_ARG_NONE, &include_pointer_arg, N_("Include the pointer with the screenshot"), NULL }, { "delay", 'd', 0, G_OPTION_ARG_INT, &delay_arg, N_("Take screenshot after specified delay [in seconds]"), N_("seconds") }, { "border-effect", 'e', 0, G_OPTION_ARG_STRING, &border_effect_arg, N_("Effect to add to the border (shadow, border or none)"), N_("effect") }, { "interactive", 'i', 0, G_OPTION_ARG_NONE, &interactive_arg, N_("Interactively set options"), NULL }, { "file", 'f', 0, G_OPTION_ARG_FILENAME, &file_arg, N_("Save screenshot directly to this file"), N_("filename") }, { NULL }, }; GOptionContext *context; GError *error = NULL; gint argc = 0; gchar **argv = NULL; gboolean res; *exit_status = EXIT_SUCCESS; argv = *arguments; argc = g_strv_length (argv); context = g_option_context_new (_("Take a picture of the screen")); g_option_context_add_main_entries (context, entries, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_critical ("Unable to parse arguments: %s", error->message); g_error_free (error); *exit_status = EXIT_FAILURE; goto out; } res = screenshot_load_config (clipboard_arg, window_arg, area_arg, include_border_arg, disable_border_arg, include_pointer_arg, border_effect_arg, delay_arg, interactive_arg, file_arg); if (!res) { *exit_status = EXIT_FAILURE; goto out; } if (!g_application_register (app, NULL, &error)) { g_printerr ("Could not register the application: %s\n", error->message); g_error_free (error); *exit_status = EXIT_FAILURE; } out: g_option_context_free (context); g_free (border_effect_arg); g_free (file_arg); return TRUE; }
/* Main entry point */ int main(int argc, char **argv) { XfdashboardApplication *app=NULL; GError *error=NULL; gint status; #if !defined(GLIB_CHECK_VERSION) || !GLIB_CHECK_VERSION(2, 36, 0) /* Initialize GObject type system */ g_type_init(); #endif /* Check for running instance (keep only one instance) */ app=xfdashboard_application_get_default(); g_application_register(G_APPLICATION(app), NULL, &error); if(error!=NULL) { g_warning(_("Unable to register application: %s"), error->message); g_error_free(error); error=NULL; return(XFDASHBOARD_APPLICATION_ERROR_FAILED); } if(g_application_get_is_remote(G_APPLICATION(app))==TRUE) { /* Handle command-line on primary instance of application * and activate primary instance if handling command-line * was successful */ status=g_application_run(G_APPLICATION(app), argc, argv); switch(status) { case XFDASHBOARD_APPLICATION_ERROR_NONE: case XFDASHBOARD_APPLICATION_ERROR_QUIT: /* Do nothing at remote instance */ break; default: g_error(_("Initializing application failed with status code %d"), status); break; } /* Exit this instance of application */ g_object_unref(app); return(status); } /* Tell clutter to try to initialize an RGBA visual */ clutter_x11_set_use_argb_visual(TRUE); /* Initialize GTK+ and Clutter */ gtk_init(&argc, &argv); if(!clutter_init(&argc, &argv)) { g_error(_("Initializing clutter failed!")); return(1); } /* Handle command-line on primary instance */ status=g_application_run(G_APPLICATION(app), argc, argv); if(status!=XFDASHBOARD_APPLICATION_ERROR_NONE) { g_object_unref(app); return(status); } /* Start main loop */ clutter_main(); /* Clean up, release allocated resources */ g_object_unref(app); return(XFDASHBOARD_APPLICATION_ERROR_NONE); }
int main(int argc, char *args[]) { GtkApplication *application = gtk_application_new(NULL, 0); g_application_register(G_APPLICATION(application), NULL, NULL); struct capplication_handler *application_handler = alloc_application_handler(application); // Handle option context. GOptionEntry option_entries[] = { { "version", 'v', 0, G_OPTION_ARG_NONE, &application_handler->version, "Show the version of the program.", NULL }, { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &application_handler->file_name, "A file containing a matrix for sequence alignment.", NULL }, { "help", 'h', 0, G_OPTION_ARG_NONE, &application_handler->help, "Show this help description.", NULL }, {NULL} }; g_option_context_add_main_entries(application_handler->option_context, option_entries, _PROGRAM_NAME_); g_option_context_set_help_enabled(application_handler->option_context, TRUE); g_option_context_set_ignore_unknown_options(application_handler->option_context, TRUE); // Parse options. GError *error = NULL; gboolean context_result = FALSE; context_result = g_option_context_parse(application_handler->option_context, &argc, &args, &error); if (context_result) { if (application_handler->version) { g_printf("%s version %s.\n", _PROGRAM_NAME_, _PROGRAM_VERSION_); g_printf("Copyright © %s %s. All rights reserved.\n", _PROGRAM_YEAR_, _PROGRAM_AUTHOR_); } } else if (error) { printf("EE Failed to parser arguments.\n"); } g_option_context_free(application_handler->option_context); struct cwindow_handler *window_handler = alloc_window_handler(application_handler); if (gtk_application_prefers_app_menu(GTK_APPLICATION(application_handler->application))) { //gtk_application_set_app_menu(GTK_APPLICATION(application_handler->application), G_MENU_MODEL(window_handler->menu_model)); } gtk_application_add_window(GTK_APPLICATION(application_handler->application), GTK_WINDOW(window_handler->window)); gtk_widget_show_all(GTK_WIDGET(window_handler->window)); gtk_window_present(GTK_WINDOW(window_handler->window)); initialize_lua(window_handler, application_handler); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(window_handler->notebook), application_handler->tabs_position); gtk_widget_set_visible(GTK_WIDGET(window_handler->action_bar), application_handler->show_action_bar); //gtk_widget_set_visible(window_handler->menu_bar, application_handler->show_menu_bar); gtk_widget_set_visible(GTK_WIDGET(window_handler->search_and_replace_bar), FALSE); if (application_handler->file_name) { gint i = 0; while (application_handler->file_name[i]) { g_printf("MM Open file \"%s\".\n", application_handler->file_name[i]); FILE *file = fopen(application_handler->file_name[i], "r"); fseek(file, 0, SEEK_END); int size = ftell(file); char *text = (char *)malloc(sizeof(char) * size + 1); memset(text, 0, sizeof(char) * size + 1); fseek(file, 0, SEEK_SET); fread(text, sizeof(char), size, file); create_page(window_handler, application_handler->file_name[i], text); fclose(file); i++; } } update_editor(window_handler); gtk_main(); g_printf("MM Closing Lua state.\n"); lua_close(application_handler->lua); return 0; }
static gboolean g_application_real_local_command_line (GApplication *application, gchar ***arguments, int *exit_status) { if (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE) return FALSE; else { GError *error = NULL; gint n_args; if (!g_application_register (application, NULL, &error)) { g_critical ("%s", error->message); g_error_free (error); *exit_status = 1; return TRUE; } n_args = g_strv_length (*arguments); if (application->priv->flags & G_APPLICATION_IS_SERVICE) { if ((*exit_status = n_args > 1)) { g_printerr ("GApplication service mode takes no arguments.\n"); application->priv->flags &= ~G_APPLICATION_IS_SERVICE; } return TRUE; } if (n_args <= 1) { g_application_activate (application); *exit_status = 0; } else { if (~application->priv->flags & G_APPLICATION_HANDLES_OPEN) { g_critical ("This application can not open files."); *exit_status = 1; } else { GFile **files; gint n_files; gint i; n_files = n_args - 1; files = g_new (GFile *, n_files); for (i = 0; i < n_files; i++) files[i] = g_file_new_for_commandline_arg ((*arguments)[i + 1]); g_application_open (application, files, n_files, ""); for (i = 0; i < n_files; i++) g_object_unref (files[i]); g_free (files); *exit_status = 0; } } return TRUE; } }
static gboolean local_cmdline (GApplication *app, gchar ***arguments, gint *exit_status) { gint i; gchar **argv; gint argc = 0; gboolean retval = TRUE; GError *error = NULL; GOptionContext *optcontext; GOptionEntry options[] = { { "hidden", 'h', 0, G_OPTION_ARG_NONE, &hidden, N_("Don't display any dialogs; do any work (eg, importing) and exit"), NULL }, { "if-needed", 'n', 0, G_OPTION_ARG_NONE, &only_if_needed, N_("Don't display any dialogs unless there are only \"People Nearby\" accounts"), NULL }, { "select-account", 's', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_STRING, &selected_account_name, N_("Initially select given account (eg, " "gabble/jabber/foo_40example_2eorg0)"), N_("<account-id>") }, { NULL } }; optcontext = g_option_context_new (N_("- Empathy Accounts")); g_option_context_add_group (optcontext, gtk_get_option_group (FALSE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); g_option_context_set_translation_domain (optcontext, GETTEXT_PACKAGE); argv = *arguments; for (i = 0; argv[i] != NULL; i++) argc++; if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command line options.\n", error->message, argv[0]); g_warning ("Error in empathy init: %s", error->message); g_clear_error (&error); *exit_status = EXIT_FAILURE; } else { if (g_application_register (app, NULL, &error)) { g_application_activate (app); } else { g_warning ("Impossible to register empathy-application: %s", error->message); g_clear_error (&error); *exit_status = EXIT_FAILURE; } } g_option_context_free (optcontext); return retval; }
gint main (gint argc, gchar **argv) { GtkApplication *application; GApplicationFlags flags; gchar *path; GError *error = NULL; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init_with_args ( &argc, &argv, NULL, entries, GETTEXT_PACKAGE, &error); if (error != NULL) g_error ("%s", error->message); /* This installs handlers for our custom debug log levels. */ gva_get_debug_flags (); /* Change the working directory to that of the MAME executable. * Why? Because SDLMAME's default configuration uses relative * search paths such as "rompath = roms". The paths are relative * to the directory containing the MAME executable, so we must run * from that directory in order for SDLMAME's default configuration * to work. Annoying, but a common problem for users. */ path = g_path_get_dirname (MAME_PROGRAM); g_chdir (path); g_free (path); if (opt_inspect != NULL) { gchar *value; value = gva_mame_get_config_value (opt_inspect, &error); if (value != NULL) { g_print ("%s\n", value); g_free (value); } else { g_printerr ("%s\n", error->message); g_clear_error (&error); } exit (EXIT_SUCCESS); } if (opt_version) { g_print ("%s\n", PACKAGE_STRING); exit (EXIT_SUCCESS); } if (opt_which_emulator) { g_print ("%s\n", MAME_PROGRAM); exit (EXIT_SUCCESS); } /* Register the application with the session bus. */ flags = G_APPLICATION_FLAGS_NONE; application = gtk_application_new (APPLICATION_ID, flags); g_application_register (G_APPLICATION (application), NULL, &error); if (error != NULL) g_error ("%s", error->message); /* If another instance is running, exit now. */ if (g_application_get_is_remote (G_APPLICATION (application))) { gint exit_status; if (opt_build_database) { g_printerr ( "Cannot build database: " PACKAGE_NAME " is already running\n"); exit_status = EXIT_FAILURE; } else { g_application_activate (G_APPLICATION (application)); exit_status = EXIT_SUCCESS; } g_object_unref (application); exit (exit_status); } else { GtkWindow *window; window = GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW); gtk_application_add_window (application, window); } gtk_window_set_default_icon_name (PACKAGE); if (!gva_db_init (&error)) g_error ("%s", error->message); gva_main_init (); gva_play_back_init (); gva_preferences_init (); gva_properties_init (); gva_ui_init (); gva_categories_init (&error); gva_error_handle (&error); gva_history_init (&error); gva_error_handle (&error); gva_nplayers_init (&error); gva_error_handle (&error); g_idle_add (idle_start, NULL); g_idle_add (tweak_css, NULL); gtk_main (); g_object_unref (application); return EXIT_SUCCESS; }
int main (int argc, char **argv) { GOptionContext *context; GError *error = NULL; GDBusConnection *bus; GDBusProxy *mpris; GDBusProxy *queue; GApplication *app; gboolean loaded; gboolean scanned; GVariant *state; #ifdef ENABLE_NLS /* initialize i18n */ bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif /* setup */ setlocale (LC_ALL, ""); g_type_init (); g_set_prgname ("rhythmbox-client"); /* parse arguments */ context = g_option_context_new (NULL); g_option_context_add_main_entries (context, args, NULL); g_option_context_parse (context, &argc, &argv, &error); if (annoy (&error)) exit (1); rb_debug_init (debug); app = g_application_new ("org.gnome.Rhythmbox3", G_APPLICATION_IS_LAUNCHER); if (g_application_register (app, NULL, &error) == FALSE) { if (check_running) { rb_debug ("no running instance found"); exit (2); } else if (quit) { rb_debug ("no existing instance to quit"); exit (0); } rb_debug ("uh.. what?"); exit (0); } /* are we just checking if it's running? */ if (check_running) { rb_debug ("running instance found"); exit (0); } /* wait until it's ready to accept control */ state = g_action_group_get_action_state (G_ACTION_GROUP (app), "LoadURI"); if (state == NULL) { rb_debug ("couldn't get app startup state"); exit (0); } bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL); g_variant_get (state, "(bb)", &loaded, &scanned); if ((loaded && scanned) == FALSE) { GMainLoop *loop; GDBusProxy *app_proxy; rb_debug ("waiting for app startup"); loop = g_main_loop_new (NULL, FALSE); g_signal_connect (app, "action-state-changed", G_CALLBACK (state_changed_cb), loop); /* dbus implementation of GApplication doesn't do action state updates yet */ app_proxy = g_dbus_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL, "org.gnome.Rhythmbox3", "/org/gnome/Rhythmbox3", "org.gtk.Actions", NULL, &error); if (app_proxy == NULL || proxy_has_name_owner (app_proxy) == FALSE) { g_warning ("unable to wait for app startup: %s", error->message); g_clear_error (&error); } else { g_object_set_data (G_OBJECT (app_proxy), "actual-app", app); g_signal_connect (app_proxy, "g-signal", G_CALLBACK (state_changed_signal_cb), loop); g_main_loop_run (loop); rb_debug ("app is now started enough"); } } /* create proxies */ mpris = g_dbus_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL, "org.mpris.MediaPlayer2.rhythmbox", "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2.Player", NULL, &error); if (mpris == NULL || proxy_has_name_owner (mpris) == FALSE) { g_warning ("MPRIS D-Bus interface not available, some things won't work"); if (next || previous || (seek != 0) || play || do_pause || play_pause || stop || volume_up || volume_down || (set_volume > -0.01)) { exit (1); } } queue = g_dbus_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL, "org.gnome.Rhythmbox3", "/org/gnome/Rhythmbox3/PlayQueue", "org.gnome.Rhythmbox3.PlayQueue", NULL, &error); if (queue == NULL || proxy_has_name_owner (queue) == FALSE) { g_warning ("Play queue interface not available, some things won't work"); if (enqueue || clear_queue) { exit (1); } } /* activate or quit */ if (quit) { rb_debug ("quitting existing instance"); g_action_group_activate_action (G_ACTION_GROUP (app), "Quit", NULL); exit (0); } /* don't present if we're doing something else */ if (next || previous || (seek != 0) || clear_queue || play_uri || other_stuff || play || do_pause || play_pause || stop || toggle_shuffle || print_playing || print_playing_format || (set_volume > -0.01) || volume_up || volume_down || print_volume /*|| mute || unmute*/ || (set_rating > -0.01)) no_present = TRUE; /* present */ if (!no_present) { g_application_activate (app); } /* set song rating */ if (set_rating >= 0.0 && set_rating <= 5.0) { rb_debug ("rate song"); rate_song (mpris, set_rating); } if (toggle_shuffle) { rb_debug("toggle shuffle"); g_action_group_activate_action (G_ACTION_GROUP (app), "ToggleShuffle", NULL); annoy(&error); } /* skip to next or previous track */ if (next) { rb_debug ("next track"); g_dbus_proxy_call_sync (mpris, "Next", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } else if (previous) { rb_debug ("previous track"); g_dbus_proxy_call_sync (mpris, "Previous", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } /* seek in track */ if (seek != 0) { GHashTable *properties; rb_debug ("seek"); properties = get_playing_song_info (mpris); if (properties != NULL) { GVariant *v = g_hash_table_lookup (properties, "mpris:trackid"); if (v != NULL) { g_dbus_proxy_call_sync (mpris, "SetPosition", g_variant_new ("(ox)", g_variant_get_string (v, NULL), seek), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } } } /* add/enqueue */ if (clear_queue) { g_dbus_proxy_call_sync (queue, "ClearQueue", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } if (other_stuff) { int i; for (i = 0; other_stuff[i] != NULL; i++) { GFile *file; char *fileuri; file = g_file_new_for_commandline_arg (other_stuff[i]); fileuri = g_file_get_uri (file); if (fileuri == NULL) { g_warning ("couldn't convert \"%s\" to a URI", other_stuff[i]); continue; } if (enqueue) { rb_debug ("enqueueing %s", fileuri); g_dbus_proxy_call_sync (queue, "AddToQueue", g_variant_new ("(s)", fileuri), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } else { rb_debug ("importing %s", fileuri); g_action_group_activate_action (G_ACTION_GROUP (app), "LoadURI", g_variant_new ("(sb)", fileuri, FALSE)); } g_free (fileuri); g_object_unref (file); } } /* select/activate/play source */ if (select_source) { rb_debug ("selecting source %s", select_source); g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", select_source, 0)); } else if (activate_source) { rb_debug ("activating source %s", activate_source); g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", activate_source, 1)); } else if (play_source) { rb_debug ("playing source %s", play_source); g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", play_source, 2)); } /* play uri */ if (play_uri) { GFile *file; char *fileuri; file = g_file_new_for_commandline_arg (play_uri); fileuri = g_file_get_uri (file); if (fileuri == NULL) { g_warning ("couldn't convert \"%s\" to a URI", play_uri); } else { rb_debug ("loading and playing %s", fileuri); g_action_group_activate_action (G_ACTION_GROUP (app), "LoadURI", g_variant_new ("(sb)", fileuri, TRUE)); annoy (&error); } g_free (fileuri); g_object_unref (file); } /* play/pause/stop */ if (mpris) { GVariant *v; gboolean is_playing = FALSE; v = g_dbus_proxy_get_cached_property (mpris, "PlaybackStatus"); if (v != NULL) { is_playing = (g_strcmp0 (g_variant_get_string (v, NULL), "Playing") == 0); g_variant_unref (v); } if (play || do_pause || play_pause) { if (is_playing != play || play_pause) { rb_debug ("calling PlayPause to change playback state"); g_dbus_proxy_call_sync (mpris, "PlayPause", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } else { rb_debug ("no need to change playback state"); } } else if (stop) { g_warning ("not implemented yet"); } } /* get/set volume, mute/unmute */ if (set_volume > -0.01) { g_dbus_proxy_call_sync (mpris, "org.freedesktop.DBus.Properties.Set", g_variant_new ("(ssv)", "org.mpris.MediaPlayer2.Player", "Volume", g_variant_new_double (set_volume)), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); } else if (volume_up || volume_down) { GVariant *v; v = g_dbus_proxy_get_cached_property (mpris, "Volume"); if (v != NULL) { set_volume = g_variant_get_double (v) + (volume_up ? 0.1 : -0.1); g_dbus_proxy_call_sync (mpris, "org.freedesktop.DBus.Properties.Set", g_variant_new ("(ssv)", "org.mpris.MediaPlayer2.Player", "Volume", g_variant_new_double (set_volume)), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); annoy (&error); g_variant_unref (v); } } /* no mute for now? */ /* } else if (unmute || mute) { org_gnome_Rhythmbox_Player_set_mute (player_proxy, unmute ? FALSE : TRUE, &error); annoy (&error); } */ if (print_volume) { gdouble volume = 1.0; GVariant *v = g_dbus_proxy_get_cached_property (mpris, "Volume"); if (v != NULL) { volume = g_variant_get_double (v); g_variant_unref (v); } g_print (_("Playback volume is %f.\n"), volume); } /* print playing song */ if (print_playing_format) { print_playing_song (mpris, print_playing_format); } else if (print_playing) { print_playing_song_default (mpris); } if (mpris) { g_object_unref (mpris); } g_dbus_connection_flush_sync (bus, NULL, NULL); g_option_context_free (context); return 0; }