static gboolean activate_result_cb (GcalShellSearchProvider *search_provider, GDBusMethodInvocation *invocation, gchar *result, gchar **terms, guint32 timestamp, GcalShellSearchProvider2 *skel) { GcalShellSearchProviderPrivate *priv; GApplication *application; GcalEvent *event; GDateTime *dtstart; priv = search_provider->priv; application = g_application_get_default (); event = gcal_manager_get_event_from_shell_search (priv->manager, result); dtstart = gcal_event_get_date_start (event); gcal_application_set_uuid (GCAL_APPLICATION (application), result); gcal_application_set_initial_date (GCAL_APPLICATION (application), dtstart); g_application_activate (application); g_clear_object (&event); return TRUE; }
static gboolean launch_search_cb (GcalShellSearchProvider *search_provider, GDBusMethodInvocation *invocation, gchar **terms, guint32 timestamp, GcalShellSearchProvider2 *skel) { GApplication *application; gchar *terms_joined; GList *windows; application = g_application_get_default (); g_application_activate (application); terms_joined = g_strjoinv (" ", terms); windows = g_list_reverse (gtk_application_get_windows (GTK_APPLICATION (application))); if (windows != NULL) { gcal_window_set_search_mode (GCAL_WINDOW (windows->data), TRUE); gcal_window_set_search_query (GCAL_WINDOW (windows->data), terms_joined); g_list_free (windows); } g_free (terms_joined); return TRUE; }
static gboolean activate_result_cb (GcalShellSearchProvider *search_provider, GDBusMethodInvocation *invocation, gchar *result, gchar **terms, guint32 timestamp, GcalShellSearchProvider2 *skel) { GcalShellSearchProviderPrivate *priv; GApplication *application; GcalEventData *data; ECalComponentDateTime dtstart; priv = search_provider->priv; application = g_application_get_default (); data = gcal_manager_get_event_from_shell_search (priv->manager, result); e_cal_component_get_dtstart (data->event_component, &dtstart); if (dtstart.tzid != NULL) dtstart.value->zone = icaltimezone_get_builtin_timezone_from_tzid (dtstart.tzid); gcal_application_set_uuid (GCAL_APPLICATION (application), result); gcal_application_set_initial_date (GCAL_APPLICATION (application), dtstart.value); e_cal_component_free_datetime (&dtstart); g_application_activate (application); g_object_unref (data->event_component); g_free (data); return TRUE; }
static void new_activated (GSimpleAction *action, GVariant *parameter, gpointer user_data) { g_application_activate (user_data); }
static void photos_application_activate_item (PhotosApplication *self, GObject *item) { PhotosApplicationPrivate *priv = self->priv; photos_application_create_window (self); photos_base_manager_set_active_object (priv->item_mngr, item); g_application_activate (G_APPLICATION (self)); /* TODO: Forward the search terms when we exit the preview */ }
static int gw_application_command_line (GApplication *application, GApplicationCommandLine *command_line) { //Declarations LwDictionary *dictionary; GwSearchWindow *window; GwDictionaryList *dictionarylist; GwApplicationPrivate *priv; gint argc; gchar **argv; gint position; //Initializations priv = GW_APPLICATION (application)->priv; dictionarylist = gw_application_get_installed_dictionarylist (GW_APPLICATION (application)); argv = NULL; if (command_line != NULL) { argv = g_application_command_line_get_arguments (command_line, &argc); gw_application_parse_args (GW_APPLICATION (application), &argc, &argv); } g_application_activate (G_APPLICATION (application)); window = gw_application_get_last_focused_searchwindow (GW_APPLICATION (application)); if (window == NULL) return 0; dictionary = lw_dictionarylist_get_dictionary_fuzzy (LW_DICTIONARYLIST (dictionarylist), priv->arg_dictionary); //Set the initial dictionary if (dictionary != NULL) { position = lw_dictionarylist_get_position (LW_DICTIONARYLIST (dictionarylist), dictionary); gw_searchwindow_set_dictionary (window, position); } //Set the initial query text if it was passed as an argument to the program if (priv->arg_query != NULL) { gw_searchwindow_entry_set_text (window, priv->arg_query); gw_searchwindow_search_cb (GTK_WIDGET (window), window); } //Cleanup if (argv != NULL) g_strfreev (argv); argv = NULL; return 0; }
static void photos_application_launch_search (PhotosApplication *self, const gchar* const *terms, guint timestamp) { PhotosApplicationPrivate *priv = self->priv; GVariant *state; gchar *str; photos_application_create_window (self); photos_mode_controller_set_window_mode (priv->mode_cntrlr, PHOTOS_WINDOW_MODE_OVERVIEW); str = g_strjoinv (" ", (gchar **) terms); photos_search_controller_set_string (priv->state->srch_cntrlr, str); g_free (str); state = g_variant_new ("b", TRUE); g_action_group_change_action_state (G_ACTION_GROUP (self), "search", state); priv->activation_timestamp = timestamp; g_application_activate (G_APPLICATION (self)); }
int fcitx_config_app_handle_command_line (GApplication *application, GApplicationCommandLine *command_line, gpointer user_data ) { int argc; gchar** argv = g_application_command_line_get_arguments(command_line, &argc); g_application_activate(G_APPLICATION (application)); GList* list = gtk_application_get_windows (GTK_APPLICATION(application)); if (list) { FcitxMainWindow* mainWindow = FCITX_MAIN_WINDOW (list->data); FcitxAddon* addon = NULL; if (argc >= 2 && argv[1]) addon = find_addon_by_name(mainWindow->addons, argv[1]); if (addon) { GtkWidget* dialog = fcitx_config_dialog_new(addon, GTK_WINDOW(mainWindow)); if (dialog) gtk_widget_show_all(GTK_WIDGET(dialog)); } } g_strfreev(argv); return 0; }
/* Timeout callback to check for activation or suspend via hot corner */ static gboolean _xfdashboard_hot_corner_check_hot_corner(gpointer inUserData) { XfdashboardHotCorner *self; XfdashboardHotCornerPrivate *priv; XfdashboardWindowTrackerWindow *activeWindow; GdkDevice *pointerDevice; gint pointerX, pointerY; XfdashboardWindowTrackerMonitor *primaryMonitor; XfdashboardHotCornerBox monitorRect; XfdashboardHotCornerBox hotCornerRect; GDateTime *currentTime; GTimeSpan timeDiff; XfdashboardHotCornerSettingsActivationCorner activationCorner; gint activationRadius; gint64 activationDuration; g_return_val_if_fail(XFDASHBOARD_IS_HOT_CORNER(inUserData), G_SOURCE_CONTINUE); self=XFDASHBOARD_HOT_CORNER(inUserData); priv=self->priv; /* Get all settings now which are used within this function */ activationCorner=xfdashboard_hot_corner_settings_get_activation_corner(priv->settings); activationRadius=xfdashboard_hot_corner_settings_get_activation_radius(priv->settings); activationDuration=xfdashboard_hot_corner_settings_get_activation_duration(priv->settings); /* Do nothing if current window is fullscreen but not this application */ activeWindow=xfdashboard_window_tracker_get_active_window(priv->windowTracker); if(activeWindow && xfdashboard_window_tracker_window_is_fullscreen(activeWindow) && !xfdashboard_window_tracker_window_is_stage(activeWindow)) { return(G_SOURCE_CONTINUE); } /* Get current position of pointer */ #if GTK_CHECK_VERSION(3, 20, 0) pointerDevice=gdk_seat_get_pointer(priv->seat); #else pointerDevice=gdk_device_manager_get_client_pointer(priv->deviceManager); #endif if(!pointerDevice) { g_critical(_("Could not get pointer to determine pointer position")); return(G_SOURCE_CONTINUE); } gdk_window_get_device_position(priv->rootWindow, pointerDevice, &pointerX, &pointerY, NULL); /* Get position and size of primary monitor */ primaryMonitor=xfdashboard_window_tracker_get_primary_monitor(priv->windowTracker); if(primaryMonitor) { gint w, h; xfdashboard_window_tracker_monitor_get_geometry(primaryMonitor, &monitorRect.x1, &monitorRect.y1, &w, &h); monitorRect.x2=monitorRect.x1+w; monitorRect.y2=monitorRect.y1+h; } else { /* Set position to 0,0 and size to screen size */ monitorRect.x1=monitorRect.y1=0; monitorRect.x2=xfdashboard_window_tracker_get_screen_width(priv->windowTracker); monitorRect.y2=xfdashboard_window_tracker_get_screen_height(priv->windowTracker); } /* Get rectangle where pointer must be inside to activate hot corner */ switch(activationCorner) { case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_RIGHT: hotCornerRect.x2=monitorRect.x2; hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1); hotCornerRect.y1=monitorRect.y1; hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2); break; case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_LEFT: hotCornerRect.x1=monitorRect.x1; hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2); hotCornerRect.y2=monitorRect.y2; hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1); break; case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_RIGHT: hotCornerRect.x2=monitorRect.x2; hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1); hotCornerRect.y2=monitorRect.y2; hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1); break; case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_LEFT: default: hotCornerRect.x1=monitorRect.x1; hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2); hotCornerRect.y1=monitorRect.y1; hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2); break; } /* Check if pointer is in configured hot corner for a configured interval. * If it is not reset entered time and return immediately without doing anything. */ if(pointerX<hotCornerRect.x1 || pointerX>=hotCornerRect.x2 || pointerY<hotCornerRect.y1 || pointerY>=hotCornerRect.y2) { /* Reset entered time */ if(priv->enteredTime) { g_date_time_unref(priv->enteredTime); priv->enteredTime=NULL; } /* Return without doing anything */ return(G_SOURCE_CONTINUE); } /* If no entered time was registered yet we assume the pointer is in hot corner * for the first time. So remember entered time for next polling interval. */ if(!priv->enteredTime) { /* Remember entered time */ priv->enteredTime=g_date_time_new_now_local(); /* Reset handled flag to get duration checked next time */ priv->wasHandledRecently=FALSE; /* Return without doing anything */ return(G_SOURCE_CONTINUE); } /* If handled flag is set then do nothing to avoid flapping between activation * and suspending application once the activation duration was reached. */ if(priv->wasHandledRecently) return(G_SOURCE_CONTINUE); /* We know the time the pointer entered hot corner. Check if pointer have stayed * in hot corner for the duration to activate/suspend application. If duration * was not reached yet, just return immediately. */ currentTime=g_date_time_new_now_local(); timeDiff=g_date_time_difference(currentTime, priv->enteredTime); g_date_time_unref(currentTime); if(timeDiff<(activationDuration*G_TIME_SPAN_MILLISECOND)) return(G_SOURCE_CONTINUE); /* Activation duration reached so activate application if suspended or suspend it * if active currently. */ if(!xfdashboard_application_is_suspended(priv->application)) { xfdashboard_application_suspend_or_quit(priv->application); } else { g_application_activate(G_APPLICATION(priv->application)); } /* Set flag that activation was handled recently */ priv->wasHandledRecently=TRUE; return(G_SOURCE_CONTINUE); }
static gint gedit_app_command_line (GApplication *application, GApplicationCommandLine *cl) { GeditAppPrivate *priv; GVariantDict *options; const gchar *encoding_charset; const gchar **remaining_args; priv = gedit_app_get_instance_private (GEDIT_APP (application)); options = g_application_command_line_get_options_dict (cl); g_variant_dict_lookup (options, "new-window", "b", &priv->new_window); g_variant_dict_lookup (options, "new-document", "b", &priv->new_document); g_variant_dict_lookup (options, "geometry", "s", &priv->geometry); if (g_variant_dict_contains (options, "wait")) { priv->command_line = cl; } if (g_variant_dict_lookup (options, "encoding", "&s", &encoding_charset)) { priv->encoding = gtk_source_encoding_get_from_charset (encoding_charset); if (priv->encoding == NULL) { g_application_command_line_printerr (cl, _("%s: invalid encoding."), encoding_charset); } } /* Parse filenames */ if (g_variant_dict_lookup (options, G_OPTION_REMAINING, "^a&ay", &remaining_args)) { gint i; for (i = 0; remaining_args[i]; i++) { if (*remaining_args[i] == '+') { if (*(remaining_args[i] + 1) == '\0') { /* goto the last line of the document */ priv->line_position = G_MAXINT; priv->column_position = 0; } else { get_line_column_position (remaining_args[i] + 1, &priv->line_position, &priv->column_position); } } else if (*remaining_args[i] == '-' && *(remaining_args[i] + 1) == '\0') { priv->stdin_stream = g_application_command_line_get_stdin (cl); } else { GFile *file; file = g_application_command_line_create_file_for_arg (cl, remaining_args[i]); priv->file_list = g_slist_prepend (priv->file_list, file); } } priv->file_list = g_slist_reverse (priv->file_list); g_free (remaining_args); } g_application_activate (application); clear_options (GEDIT_APP (application)); return 0; }
static gboolean logview_app_local_command_line (GApplication *application, gchar ***arguments, gint *exit_status) { gchar **argv; gint argc, idx, len = 0; gchar **remaining = NULL; gboolean version = FALSE; GError *error = NULL; GFile **files = NULL; GOptionContext *context; const GOptionEntry entries[] = { { "version", '\0', 0, G_OPTION_ARG_NONE, &version, N_("Show the version of the program."), NULL }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[URI...]") }, { NULL } }; *exit_status = EXIT_SUCCESS; context = g_option_context_new (_("A system log viewer for GNOME.")); g_option_context_add_main_entries (context, entries, 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 System Log " PACKAGE_VERSION "\n"); goto out; } 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; } /* 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 (len > 0) g_application_open (application, files, len, ""); else g_application_activate (application); for (idx = 0; idx < len; idx++) g_object_unref (files[idx]); g_free (files); out: g_option_context_free (context); return TRUE; }
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 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; }