From 0e671286fc59b4a68e8640b955c07bd874486dd5 Mon Sep 17 00:00:00 2001 From: Ryan Lortie Date: Sun, 12 Jan 2014 18:14:30 -0500 Subject: [PATCH] GApplication: parse command line options Add support for parsing command line options with GApplication. You can add GOptionGroup and GOptionEntry using two new APIs: g_application_add_option_group() and g_application_add_main_option_entries(). Also add a "handle-local-options" signal that allows handling of commandline arguments in the local process without having to override local_command_line. As a special feature, you can have a %NULL @arg_data in a GOptionEntry which will cause the argument to be stored in a GVariantDict. This dictionary is available for inspection and modification by the "handle-local-options" signal and can be forwarded to the primary instance in cases of command line invocation (where it can be fetched using g_application_command_line_get_options()). https://bugzilla.gnome.org/show_bug.cgi?id=721977 --- docs/reference/gio/gio-sections.txt | 3 + gio/gapplication.c | 725 ++++++++++++++++++++++++++++-------- gio/gapplication.h | 11 +- gio/gapplicationcommandline.c | 56 +++ gio/gapplicationcommandline.h | 3 + gio/gapplicationimpl-dbus.c | 6 +- gio/gapplicationimpl.h | 2 +- 7 files changed, 655 insertions(+), 151 deletions(-) diff --git a/docs/reference/gio/gio-sections.txt b/docs/reference/gio/gio-sections.txt index 679adfd..86e7447 100644 --- a/docs/reference/gio/gio-sections.txt +++ b/docs/reference/gio/gio-sections.txt @@ -3020,6 +3020,9 @@ g_application_send_notification g_application_withdraw_notification g_application_run +g_application_add_main_option_entries +g_application_add_option_group + g_application_set_default g_application_get_default diff --git a/gio/gapplication.c b/gio/gapplication.c index b8bc914..1309ef0 100644 --- a/gio/gapplication.c +++ b/gio/gapplication.c @@ -248,6 +248,12 @@ struct _GApplicationPrivate GApplicationImpl *impl; GNotificationBackend *notifications; + + /* GOptionContext support */ + GOptionGroup *main_options; + GSList *option_groups; + GHashTable *packed_options; + gboolean options_parsed; }; enum @@ -269,6 +275,7 @@ enum SIGNAL_OPEN, SIGNAL_ACTION, SIGNAL_COMMAND_LINE, + SIGNAL_HANDLE_LOCAL_OPTIONS, NR_SIGNALS }; @@ -367,6 +374,352 @@ g_application_exported_actions_new (GApplication *application) return G_ACTION_GROUP (actions); } +/* Command line option handling {{{1 */ + +static void +free_option_entry (gpointer data) +{ + GOptionEntry *entry = data; + + switch (entry->arg) + { + case G_OPTION_ARG_STRING: + case G_OPTION_ARG_FILENAME: + g_free (*(gchar **) entry->arg_data); + break; + + case G_OPTION_ARG_STRING_ARRAY: + case G_OPTION_ARG_FILENAME_ARRAY: + g_strfreev (*(gchar ***) entry->arg_data); + break; + + default: + /* most things require no free... */ + break; + } + + /* ...except for the space that we allocated for it ourselves */ + g_free (entry->arg_data); + + g_slice_free (GOptionEntry, entry); +} + +static void +g_application_pack_option_entries (GApplication *application, + GVariantDict *dict) +{ + GHashTableIter iter; + gpointer item; + + g_hash_table_iter_init (&iter, application->priv->packed_options); + while (g_hash_table_iter_next (&iter, NULL, &item)) + { + GOptionEntry *entry = item; + GVariant *value = NULL; + + switch (entry->arg) + { + case G_OPTION_ARG_NONE: + if (*(gboolean *) entry->arg_data != 2) + value = g_variant_new_boolean (*(gboolean *) entry->arg_data); + break; + + case G_OPTION_ARG_STRING: + if (*(gchar **) entry->arg_data) + value = g_variant_new_string (*(gchar **) entry->arg_data); + break; + + case G_OPTION_ARG_INT: + if (*(gint32 *) entry->arg_data) + value = g_variant_new_int32 (*(gint32 *) entry->arg_data); + break; + + case G_OPTION_ARG_FILENAME: + if (*(gchar **) entry->arg_data) + value = g_variant_new_bytestring (*(gchar **) entry->arg_data); + break; + + case G_OPTION_ARG_STRING_ARRAY: + if (*(gchar ***) entry->arg_data) + value = g_variant_new_strv (*(const gchar ***) entry->arg_data, -1); + break; + + case G_OPTION_ARG_FILENAME_ARRAY: + if (*(gchar ***) entry->arg_data) + value = g_variant_new_bytestring_array (*(const gchar ***) entry->arg_data, -1); + break; + + case G_OPTION_ARG_DOUBLE: + if (*(gdouble *) entry->arg_data) + value = g_variant_new_double (*(gdouble *) entry->arg_data); + break; + + case G_OPTION_ARG_INT64: + if (*(gint64 *) entry->arg_data) + value = g_variant_new_int64 (*(gint64 *) entry->arg_data); + break; + + default: + g_assert_not_reached (); + } + + if (value) + g_variant_dict_insert_value (dict, entry->long_name, value); + } +} + +static GVariantDict * +g_application_parse_command_line (GApplication *application, + gchar ***arguments, + GError **error) +{ + gboolean become_service = FALSE; + GVariantDict *dict = NULL; + GOptionContext *context; + + /* Due to the memory management of GOptionGroup we can only parse + * options once. That's because once you add a group to the + * GOptionContext there is no way to get it back again. This is fine: + * local_command_line() should never get invoked more than once + * anyway. Add a sanity check just to be sure. + */ + g_return_val_if_fail (!application->priv->options_parsed, NULL); + + context = g_option_context_new (NULL); + + /* Add the main option group, if it exists */ + if (application->priv->main_options) + { + /* This consumes the main_options */ + g_option_context_set_main_group (context, application->priv->main_options); + application->priv->main_options = NULL; + } + + /* Add any other option groups if they exist. Adding them to the + * context will consume them, so we free the list as we go... + */ + while (application->priv->option_groups) + { + g_option_context_add_group (context, application->priv->option_groups->data); + application->priv->option_groups = g_slist_delete_link (application->priv->option_groups, + application->priv->option_groups); + } + + /* If the application has not registered local options and it has + * G_APPLICATION_HANDLES_COMMAND_LINE then we have to assume that + * their primary instance commandline handler may want to deal with + * the arguments. We must therefore ignore them. + */ + if (application->priv->main_options == NULL && (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE)) + g_option_context_set_ignore_unknown_options (context, TRUE); + + /* In the case that we are not explicitly marked as a service or a + * launcher then we want to add the "--gapplication-service" option to + * allow the process to be made into a service. + */ + if ((application->priv->flags & (G_APPLICATION_IS_SERVICE | G_APPLICATION_IS_LAUNCHER)) == 0) + { + GOptionGroup *option_group; + GOptionEntry entries[] = { + { "gapplication-service", '\0', 0, G_OPTION_ARG_NONE, &become_service, + N_("Enter GApplication service mode (use from D-Bus service files)") }, + { NULL } + }; + + option_group = g_option_group_new ("gapplication", + _("GApplication options"), _("Show GApplication options"), + NULL, NULL); + g_option_group_set_translation_domain (option_group, GETTEXT_PACKAGE); + g_option_group_add_entries (option_group, entries); + + g_option_context_add_group (context, option_group); + } + + /* Now we parse... */ + if (!g_option_context_parse_strv (context, arguments, error)) + goto out; + + /* Check for --gapplication-service */ + if (become_service) + application->priv->flags |= G_APPLICATION_IS_SERVICE; + + dict = g_variant_dict_new (NULL); + if (application->priv->packed_options) + { + g_application_pack_option_entries (application, dict); + g_hash_table_unref (application->priv->packed_options); + application->priv->packed_options = NULL; + } + +out: + /* Make sure we don't run again */ + application->priv->options_parsed = TRUE; + + g_option_context_free (context); + + return dict; +} + +static void +add_packed_option (GApplication *application, + GOptionEntry *entry) +{ + switch (entry->arg) + { + case G_OPTION_ARG_NONE: + entry->arg_data = g_new (gboolean, 1); + *(gboolean *) entry->arg_data = 2; + break; + + case G_OPTION_ARG_INT: + entry->arg_data = g_new0 (gint, 1); + break; + + case G_OPTION_ARG_STRING: + case G_OPTION_ARG_FILENAME: + case G_OPTION_ARG_STRING_ARRAY: + case G_OPTION_ARG_FILENAME_ARRAY: + entry->arg_data = g_new0 (gpointer, 1); + break; + + case G_OPTION_ARG_INT64: + entry->arg_data = g_new0 (gint64, 1); + break; + + case G_OPTION_ARG_DOUBLE: + entry->arg_data = g_new0 (gdouble, 1); + break; + + default: + g_return_if_reached (); + } + + if (!application->priv->packed_options) + application->priv->packed_options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_option_entry); + + g_hash_table_insert (application->priv->packed_options, + g_strdup (entry->long_name), + g_slice_dup (GOptionEntry, entry)); +} + +/** + * g_application_add_main_option_entries: + * @application: a #GApplication + * @entries: a %NULL-terminated list of #GOptionEntrys + * + * Adds main option entries to be handled by @application. + * + * This function is comparable to g_option_context_add_main_entries(). + * + * After the commandline arguments are parsed, the + * #GApplication::handle-local-options signal will be emitted. At this + * point, the application can inspect the values pointed to by @arg_data + * in the given #GOptionEntrys. + * + * Unlike #GOptionContext, #GApplication supports giving a %NULL + * @arg_data for a non-callback #GOptionEntry. This results in the + * argument in question being packed into a #GVariantDict which is also + * passed to #GApplication::handle-local-options, where it can be + * inspected and modified. If %G_APPLICATION_HANDLES_COMMAND_LINE is + * set, then the resulting dictionary is sent to the primary instance, + * where g_application_command_line_get_options_dict() will return it. + * This "packing" is done according to the type of the argument -- + * booleans for normal flags, strings for strings, bytestrings for + * filenames, etc. The packing only occurs if the flag is given (ie: we + * do not pack a "false" #GVariant in the case that a flag is missing). + * + * In general, it is recommended that all commandline arguments are + * parsed locally. The options dictionary should then be used to + * transmit the result of the parsing to the primary instance, where + * g_variant_dict_lookup() can be used. For local options, it is + * possible to either use @arg_data in the usual way, or to consult (and + * potentially remove) the option from the options dictionary. + * + * This function is new in GLib 2.40. Before then, the only real choice + * was to send all of the commandline arguments (options and all) to the + * primary instance for handling. #GApplication ignored them completely + * on the local side. Calling this function "opts in" to the new + * behaviour, and in particular, means that unrecognised options will be + * treated as errors. Unrecognised options have never been ignored when + * %G_APPLICATION_HANDLES_COMMAND_LINE is unset. + * + * If #GApplication::handle-local-options needs to see the list of + * filenames, then the use of %G_OPTION_REMAINING is recommended. If + * @arg_data is %NULL then %G_OPTION_REMAINING can be used as a key into + * the options dictionary. If you do use %G_OPTION_REMAINING then you + * need to handle these arguments for yourself because once they are + * consumed, they will no longer be visible to the default handling + * (which treats them as filenames to be opened). + * + * Since: 2.40 + */ +void +g_application_add_main_option_entries (GApplication *application, + const GOptionEntry *entries) +{ + gint i; + + g_return_if_fail (G_IS_APPLICATION (application)); + g_return_if_fail (entries != NULL); + + if (!application->priv->main_options) + application->priv->main_options = g_option_group_new (NULL, NULL, NULL, NULL, NULL); + + for (i = 0; entries[i].long_name; i++) + { + GOptionEntry my_entries[2] = { entries[i], { NULL } }; + + if (!my_entries[0].arg_data) + add_packed_option (application, &my_entries[0]); + + g_option_group_add_entries (application->priv->main_options, my_entries); + } +} + +/** + * g_application_add_option_group: + * @application: the #GApplication + * @group: a #GOptionGroup + * + * Adds a #GOptionGroup to the commandline handling of @application. + * + * This function is comparable to g_option_context_add_group(). + * + * Unlike g_application_add_main_option_entries(), this function does + * not deal with %NULL @arg_data and never transmits options to the + * primary instance. + * + * The reason for that is because, by the time the options arrive at the + * primary instance, it is typically too late to do anything with them. + * Taking the GTK option group as an example: GTK will already have been + * initialised by the time the #GApplication::command-line handler runs. + * In the case that this is not the first-running instance of the + * application, the existing instance may already have been running for + * a very long time. + * + * This means that the options from #GOptionGroup are only really usable + * in the case that the instance of the application being run is the + * first instance. Passing options like --display= + * or --gdk-debug= on future runs will have no effect + * on the existing primary instance. + * + * Calling this function will cause the options in the supplied option + * group to be parsed, but it does not cause you to be "opted in" to the + * new functionality whereby unrecognised options are rejected even if + * %G_APPLICATION_HANDLES_COMMAND_LINE was given. + * + * Since: 2.40 + **/ +void +g_application_add_option_group (GApplication *application, + GOptionGroup *group) +{ + g_return_if_fail (G_IS_APPLICATION (application)); + g_return_if_fail (group != NULL); + + application->priv->option_groups = g_slist_prepend (application->priv->option_groups, group); +} + /* vfunc defaults {{{1 */ static void g_application_real_before_emit (GApplication *application, @@ -459,64 +812,137 @@ g_application_real_command_line (GApplication *application, return 1; } +static gint +g_application_real_handle_local_options (GApplication *application, + GVariantDict *options) +{ + return -1; +} + +static GVariant * +get_platform_data (GApplication *application, + GVariant *options) +{ + GVariantBuilder *builder; + GVariant *result; + + builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + + { + gchar *cwd = g_get_current_dir (); + g_variant_builder_add (builder, "{sv}", "cwd", + g_variant_new_bytestring (cwd)); + g_free (cwd); + } + + if (application->priv->flags & G_APPLICATION_SEND_ENVIRONMENT) + { + GVariant *array; + gchar **envp; + + envp = g_get_environ (); + array = g_variant_new_bytestring_array ((const gchar **) envp, -1); + g_strfreev (envp); + + g_variant_builder_add (builder, "{sv}", "environ", array); + } + + if (options) + g_variant_builder_add (builder, "{sv}", "options", options); + + G_APPLICATION_GET_CLASS (application)-> + add_platform_data (application, builder); + + result = g_variant_builder_end (builder); + g_variant_builder_unref (builder); + + return result; +} + +static void +g_application_call_command_line (GApplication *application, + const gchar * const *arguments, + GVariant *options, + gint *exit_status) +{ + if (application->priv->is_remote) + { + GVariant *platform_data; + + platform_data = get_platform_data (application, options); + *exit_status = g_application_impl_command_line (application->priv->impl, arguments, platform_data); + } + else + { + GApplicationCommandLine *cmdline; + GVariant *v; + + v = g_variant_new_bytestring_array ((const gchar **) arguments, -1); + cmdline = g_object_new (G_TYPE_APPLICATION_COMMAND_LINE, + "arguments", v, + "options", options, + NULL); + g_signal_emit (application, g_application_signals[SIGNAL_COMMAND_LINE], 0, cmdline, exit_status); + g_object_unref (cmdline); + } +} + static gboolean g_application_real_local_command_line (GApplication *application, gchar ***arguments, int *exit_status) { - if ((application->priv->flags & (G_APPLICATION_IS_SERVICE | G_APPLICATION_IS_LAUNCHER)) == 0) + GError *error = NULL; + GVariantDict *options; + gint n_args; + + options = g_application_parse_command_line (application, arguments, &error); + if (!options) { - if ((*arguments)[0] && (*arguments)[1] && g_str_equal ((*arguments)[1], "--gapplication-service")) - { - GError *error = NULL; + g_printerr ("%s\n", error->message); + *exit_status = 1; + return TRUE; + } - if ((*arguments)[2]) - g_warning ("Additional arguments following --gapplication-service are ignored"); + g_signal_emit (application, g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS], 0, options, exit_status); - application->priv->flags |= G_APPLICATION_IS_SERVICE; - if (!g_application_register (application, NULL, &error)) - { - g_warning ("%s", error->message); - g_error_free (error); - *exit_status = 1; - } - else - *exit_status = 0; + if (*exit_status >= 0) + { + g_variant_dict_unref (options); + return TRUE; + } - return TRUE; - } + if (!g_application_register (application, NULL, &error)) + { + g_printerr ("Failed to register: %s\n", error->message); + g_variant_dict_unref (options); + g_error_free (error); + *exit_status = 1; + return TRUE; } - if ((application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE) && - !(application->priv->flags & G_APPLICATION_IS_SERVICE)) - return FALSE; + n_args = g_strv_length (*arguments); - else + if (application->priv->flags & G_APPLICATION_IS_SERVICE) { - GError *error = NULL; - gint n_args; - - if (!g_application_register (application, NULL, &error)) + if ((*exit_status = n_args > 1)) { - g_printerr ("Failed to register: %s\n", error->message); - g_error_free (error); + g_printerr ("GApplication service mode takes no arguments.\n"); + application->priv->flags &= ~G_APPLICATION_IS_SERVICE; *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; } - + else + *exit_status = 0; + } + else if (application->priv->flags & G_APPLICATION_HANDLES_COMMAND_LINE) + { + g_application_call_command_line (application, + (const gchar **) *arguments, + g_variant_dict_end (options), + exit_status); + } + else + { if (n_args <= 1) { g_application_activate (application); @@ -551,9 +977,11 @@ g_application_real_local_command_line (GApplication *application, *exit_status = 0; } } - - return TRUE; } + + g_variant_dict_unref (options); + + return TRUE; } static void @@ -699,6 +1127,12 @@ g_application_finalize (GObject *object) { GApplication *application = G_APPLICATION (object); + g_slist_free_full (application->priv->option_groups, (GDestroyNotify) g_option_group_free); + if (application->priv->main_options) + g_option_group_free (application->priv->main_options); + if (application->priv->packed_options) + g_hash_table_unref (application->priv->packed_options); + if (application->priv->impl) g_application_impl_destroy (application->priv->impl); g_free (application->priv->id); @@ -736,6 +1170,20 @@ g_application_init (GApplication *application) G_CALLBACK (g_action_group_action_removed), application); } +static gboolean +g_application_handle_local_options_accumulator (GSignalInvocationHint *ihint, + GValue *return_accu, + const GValue *handler_return, + gpointer dummy) +{ + gint value; + + value = g_value_get_int (handler_return); + g_value_set_int (return_accu, value); + + return value >= 0; +} + static void g_application_class_init (GApplicationClass *class) { @@ -754,6 +1202,7 @@ g_application_class_init (GApplicationClass *class) class->open = g_application_real_open; class->command_line = g_application_real_command_line; class->local_command_line = g_application_real_local_command_line; + class->handle_local_options = g_application_real_handle_local_options; class->add_platform_data = g_application_real_add_platform_data; class->dbus_register = g_application_real_dbus_register; class->dbus_unregister = g_application_real_dbus_unregister; @@ -870,42 +1319,67 @@ g_application_class_init (GApplicationClass *class) g_signal_accumulator_first_wins, NULL, NULL, G_TYPE_INT, 1, G_TYPE_APPLICATION_COMMAND_LINE); -} - -static GVariant * -get_platform_data (GApplication *application) -{ - GVariantBuilder *builder; - GVariant *result; - - builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); - - { - gchar *cwd = g_get_current_dir (); - g_variant_builder_add (builder, "{sv}", "cwd", - g_variant_new_bytestring (cwd)); - g_free (cwd); - } - - if (application->priv->flags & G_APPLICATION_SEND_ENVIRONMENT) - { - GVariant *array; - gchar **envp; - - envp = g_get_environ (); - array = g_variant_new_bytestring_array ((const gchar **) envp, -1); - g_strfreev (envp); - - g_variant_builder_add (builder, "{sv}", "environ", array); - } - G_APPLICATION_GET_CLASS (application)-> - add_platform_data (application, builder); - - result = g_variant_builder_end (builder); - g_variant_builder_unref (builder); + /** + * GApplication::handle-local-options: + * @application: the application + * @options: the options dictionary + * + * The ::handle-local-options signal is emitted on the local instance + * after the parsing of the commandline options has occurred. + * + * You can add options to be recognised during commandline option + * parsing using g_application_add_main_option_entries() and + * g_application_add_option_group(). + * + * Signal handlers can inspect @options (along with values pointed to + * from the @arg_data of an installed #GOptionEntrys) in order to + * decide to perform certain actions, including direct local handling + * (which may be useful for options like --version). + * + * If the options have been "handled" then a non-negative value should + * be returned. In this case, the return value is the exit status: 0 + * for success and a positive value for failure. -1 means to continue + * normal processing. + * + * In the event that the application is marked + * %G_APPLICATION_HANDLES_COMMAND_LINE the "normal processing" will + * send the @option dictionary to the primary instance where it can be + * read with g_application_command_line_get_options(). The signal + * handler can modify the dictionary before returning, and the + * modified dictionary will be sent. + * + * In the event that %G_APPLICATION_HANDLES_COMMAND_LINE is not set, + * "normal processing" will treat the remaining uncollected command + * line arguments as filenames or URIs. If there are no arguments, + * the application is activated by g_application_activate(). One or + * more arguments results in a call to g_application_open(). + * + * If you want to handle the local commandline arguments for yourself + * by converting them to calls to g_application_open() or + * g_action_group_activate_action() then you must be sure to register + * the application first. You should probably not call + * g_application_activate() for yourself, however: just return -1 and + * allow the default handler to do it for you. This will ensure that + * the --gapplication-service switch works properly + * (ie: no activation in that case). + * + * Note that this signal is emitted from the default implementation of + * local_command_line(). If you override that function and don't + * chain up then this signal will never be emitted. + * + * You can override local_command_line() if you need more powerful + * capabilities than what is provided here, but this should not + * normally be required. + * + * Since: 2.40 + **/ + g_application_signals[SIGNAL_HANDLE_LOCAL_OPTIONS] = + g_signal_new ("handle-local-options", G_TYPE_APPLICATION, G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GApplicationClass, handle_local_options), + g_application_handle_local_options_accumulator, NULL, NULL, + G_TYPE_INT, 1, G_TYPE_VARIANT_DICT); - return result; } /* Application ID validity {{{1 */ @@ -1441,7 +1915,7 @@ g_application_activate (GApplication *application) if (application->priv->is_remote) g_application_impl_activate (application->priv->impl, - get_platform_data (application)); + get_platform_data (application, NULL)); else g_signal_emit (application, g_application_signals[SIGNAL_ACTIVATE], 0); @@ -1485,7 +1959,7 @@ g_application_open (GApplication *application, if (application->priv->is_remote) g_application_impl_open (application->priv->impl, files, n_files, hint, - get_platform_data (application)); + get_platform_data (application, NULL)); else g_signal_emit (application, g_application_signals[SIGNAL_OPEN], @@ -1509,49 +1983,28 @@ g_application_open (GApplication *application, * g_win32_get_command_line() is called internally (for proper support * of Unicode commandline arguments). * - * First, the local_command_line() virtual function is invoked. - * This function always runs on the local instance. It gets passed a pointer - * to a %NULL-terminated copy of the command line and is expected to - * remove the arguments that it handled (shifting up remaining - * arguments). See for - * an example of parsing @argv manually. Alternatively, you may use the - * #GOptionContext API, but you must use g_option_context_parse_strv() - * in order to avoid memory leaks and encoding mismatches. - * - * The last argument to local_command_line() is a pointer to the @status - * variable which can used to set the exit status that is returned from - * g_application_run(). - * - * If local_command_line() returns %TRUE, the command line is expected - * to be completely handled, including possibly registering as the primary - * instance, calling g_application_activate() or g_application_open(), etc. - * - * If local_command_line() returns %FALSE then the application is registered - * and the #GApplication::command-line signal is emitted in the primary - * instance (which may or may not be this instance). The signal handler - * gets passed a #GApplicationCommandLine object that (among other things) - * contains the remaining commandline arguments that have not been handled - * by local_command_line(). - * - * If the application has the %G_APPLICATION_HANDLES_COMMAND_LINE - * flag set then the default implementation of local_command_line() - * always returns %FALSE immediately, resulting in the commandline - * always being handled in the primary instance. - * - * Otherwise, the default implementation of local_command_line() tries - * to do a couple of things that are probably reasonable for most - * applications. First, g_application_register() is called to attempt - * to register the application. If that works, then the command line - * arguments are inspected. If no commandline arguments are given, then - * g_application_activate() is called. If commandline arguments are - * given and the %G_APPLICATION_HANDLES_OPEN flag is set then they - * are assumed to be filenames and g_application_open() is called. - * - * If you need to handle commandline arguments that are not filenames, - * and you don't mind commandline handling to happen in the primary - * instance, you should set %G_APPLICATION_HANDLES_COMMAND_LINE and - * process the commandline arguments in your #GApplication::command-line - * signal handler, either manually or using the #GOptionContext API. + * #GApplication will attempt to parse the commandline arguments. You + * can add commandline flags to the list of recognised options by way of + * g_application_add_main_option_entries(). After this, the + * #GApplication::handle-local-options signal is emitted, from which the + * application can inspect the values of its #GOptionEntrys. + * + * #GApplication::handle-local-options is a good place to handle options + * such as --version, where an immediate reply from + * the local process is desired (instead of communicating with an + * already-running instance). A #GApplication::handle-local-options + * handler can stop further processing by returning a non-negative + * value, which then becomes the exit status of the process. + * + * What happens next depends on the flags: if + * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining + * commandline arguments are sent to the primary instance, where a + * #GApplication::command-line signal is emitted. Otherwise, the + * remaining commandline arguments are assumed to be a list of files. + * If there are no files listed, the application is activated via the + * #GApplication::activate signal. If there are one or more files, and + * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened + * via the #GApplication::open signal. * * If you are interested in doing more complicated local handling of the * commandline then you should implement your own #GApplication subclass @@ -1653,27 +2106,7 @@ g_application_run (GApplication *application, return 1; } - if (application->priv->is_remote) - { - GVariant *platform_data; - - platform_data = get_platform_data (application); - status = g_application_impl_command_line (application->priv->impl, - arguments, platform_data); - } - else - { - GApplicationCommandLine *cmdline; - GVariant *v; - - v = g_variant_new_bytestring_array ((const gchar **) arguments, -1); - cmdline = g_object_new (G_TYPE_APPLICATION_COMMAND_LINE, - "arguments", v, NULL); - g_signal_emit (application, - g_application_signals[SIGNAL_COMMAND_LINE], - 0, cmdline, &status); - g_object_unref (cmdline); - } + g_application_call_command_line (application, (const gchar **) arguments, NULL, &status); } g_strfreev (arguments); @@ -1779,7 +2212,7 @@ g_application_change_action_state (GActionGroup *action_group, if (application->priv->remote_actions) g_remote_action_group_change_action_state_full (application->priv->remote_actions, - action_name, value, get_platform_data (application)); + action_name, value, get_platform_data (application, NULL)); else g_action_group_change_action_state (application->priv->actions, action_name, value); @@ -1798,7 +2231,7 @@ g_application_activate_action (GActionGroup *action_group, if (application->priv->remote_actions) g_remote_action_group_activate_action_full (application->priv->remote_actions, - action_name, parameter, get_platform_data (application)); + action_name, parameter, get_platform_data (application, NULL)); else g_action_group_activate_action (application->priv->actions, action_name, parameter); diff --git a/gio/gapplication.h b/gio/gapplication.h index 7c91318..7ffaf41 100644 --- a/gio/gapplication.h +++ b/gio/gapplication.h @@ -115,9 +115,11 @@ struct _GApplicationClass void (* dbus_unregister) (GApplication *application, GDBusConnection *connection, const gchar *object_path); + gint (* handle_local_options)(GApplication *application, + GVariantDict *options); /*< private >*/ - gpointer padding[9]; + gpointer padding[8]; }; GLIB_AVAILABLE_IN_ALL @@ -157,6 +159,13 @@ GLIB_DEPRECATED void g_application_set_action_group (GApplication *application, GActionGroup *action_group); +GLIB_AVAILABLE_IN_2_40 +void g_application_add_main_option_entries (GApplication *application, + const GOptionEntry *entries); +GLIB_AVAILABLE_IN_2_40 +void g_application_add_option_group (GApplication *application, + GOptionGroup *group); + GLIB_AVAILABLE_IN_ALL gboolean g_application_get_is_registered (GApplication *application); GLIB_AVAILABLE_IN_ALL diff --git a/gio/gapplicationcommandline.c b/gio/gapplicationcommandline.c index 258baa7..748c9d4 100644 --- a/gio/gapplicationcommandline.c +++ b/gio/gapplicationcommandline.c @@ -211,6 +211,7 @@ enum { PROP_NONE, PROP_ARGUMENTS, + PROP_OPTIONS, PROP_PLATFORM_DATA, PROP_IS_REMOTE }; @@ -219,6 +220,8 @@ struct _GApplicationCommandLinePrivate { GVariant *platform_data; GVariant *arguments; + GVariant *options; + GVariantDict *options_dict; gchar *cwd; gchar **environ; @@ -253,6 +256,12 @@ grok_platform_data (GApplicationCommandLine *cmdline) cmdline->priv->environ = g_variant_dup_bytestring_array (value, NULL); } + + else if (strcmp (key, "options") == 0) + { + if (!cmdline->priv->options) + cmdline->priv->options = g_variant_ref (value); + } } static void @@ -321,6 +330,11 @@ g_application_command_line_set_property (GObject *object, cmdline->priv->arguments = g_value_dup_variant (value); break; + case PROP_OPTIONS: + g_assert (cmdline->priv->options == NULL); + cmdline->priv->options = g_value_dup_variant (value); + break; + case PROP_PLATFORM_DATA: g_assert (cmdline->priv->platform_data == NULL); cmdline->priv->platform_data = g_value_dup_variant (value); @@ -338,6 +352,12 @@ g_application_command_line_finalize (GObject *object) { GApplicationCommandLine *cmdline = G_APPLICATION_COMMAND_LINE (object); + if (cmdline->priv->options_dict) + g_variant_dict_unref (cmdline->priv->options_dict); + + if (cmdline->priv->options) + g_variant_unref (cmdline->priv->options); + if (cmdline->priv->platform_data) g_variant_unref (cmdline->priv->platform_data); if (cmdline->priv->arguments) @@ -394,6 +414,13 @@ g_application_command_line_class_init (GApplicationCommandLineClass *class) G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (object_class, PROP_OPTIONS, + g_param_spec_variant ("options", + P_("Options"), + P_("The options sent along with the commandline"), + G_VARIANT_TYPE_VARDICT, NULL, G_PARAM_WRITABLE | + G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (object_class, PROP_PLATFORM_DATA, g_param_spec_variant ("platform-data", P_("Platform data"), @@ -451,6 +478,35 @@ g_application_command_line_get_arguments (GApplicationCommandLine *cmdline, } /** + * g_application_command_line_get_options_dict: + * @cmdline: a #GApplicationCommandLine + * + * Gets the options there were passed to g_application_command_line(). + * + * If you did not override local_command_line() then these are the same + * options that were parsed according to the #GOptionEntrys added to the + * application with g_application_add_main_option_entries() and possibly + * modified from your GApplication::handle-local-options handler. + * + * If no options were sent then an empty dictionary is returned so that + * you don't need to check for %NULL. + * + * Returns: (transfer none): a #GVariantDict with the options + * + * Since: 2.40 + **/ +GVariantDict * +g_application_command_line_get_options_dict (GApplicationCommandLine *cmdline) +{ + g_return_val_if_fail (G_IS_APPLICATION_COMMAND_LINE (cmdline), NULL); + + if (!cmdline->priv->options_dict) + cmdline->priv->options_dict = g_variant_dict_new (cmdline->priv->options); + + return cmdline->priv->options_dict; +} + +/** * g_application_command_line_get_stdin: * @cmdline: a #GApplicationCommandLine * diff --git a/gio/gapplicationcommandline.h b/gio/gapplicationcommandline.h index 874ce0a..ff42d0e 100644 --- a/gio/gapplicationcommandline.h +++ b/gio/gapplicationcommandline.h @@ -76,6 +76,9 @@ GLIB_AVAILABLE_IN_ALL gchar ** g_application_command_line_get_arguments (GApplicationCommandLine *cmdline, int *argc); +GLIB_AVAILABLE_IN_2_40 +GVariantDict * g_application_command_line_get_options_dict (GApplicationCommandLine *cmdline); + GLIB_AVAILABLE_IN_2_36 GInputStream * g_application_command_line_get_stdin (GApplicationCommandLine *cmdline); diff --git a/gio/gapplicationimpl-dbus.c b/gio/gapplicationimpl-dbus.c index a76156e..dea8ac2 100644 --- a/gio/gapplicationimpl-dbus.c +++ b/gio/gapplicationimpl-dbus.c @@ -700,9 +700,9 @@ g_application_impl_cmdline_done (GObject *source, } int -g_application_impl_command_line (GApplicationImpl *impl, - gchar **arguments, - GVariant *platform_data) +g_application_impl_command_line (GApplicationImpl *impl, + const gchar * const *arguments, + GVariant *platform_data) { const static GDBusInterfaceVTable vtable = { g_application_impl_cmdline_method_call diff --git a/gio/gapplicationimpl.h b/gio/gapplicationimpl.h index 85d7a3e..1e6a718 100644 --- a/gio/gapplicationimpl.h +++ b/gio/gapplicationimpl.h @@ -31,7 +31,7 @@ void g_application_impl_open (GApplic GVariant *platform_data); int g_application_impl_command_line (GApplicationImpl *impl, - gchar **arguments, + const gchar *const *arguments, GVariant *platform_data); void g_application_impl_flush (GApplicationImpl *impl); -- 2.7.4