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;
}
