Trait gio::prelude::ApplicationExtManual
source · pub trait ApplicationExtManual {
// Required methods
fn run(&self) -> i32;
fn run_with_args<S: AsRef<str>>(&self, args: &[S]) -> i32;
fn connect_open<F: Fn(&Self, &[File], &str) + 'static>(
&self,
f: F
) -> SignalHandlerId;
}
Required Methods§
sourcefn run(&self) -> i32
fn run(&self) -> i32
Runs the application.
This function is intended to be run from main()
and its return value
is intended to be returned by main()
. Although you are expected to pass
the argc
, argv
parameters from main()
to this function, it is possible
to pass None
if argv
is not available or commandline handling is not
required. Note that on Windows, argc
and argv
are ignored, and
g_win32_get_command_line()
is called internally (for proper support
of Unicode commandline arguments).
Application
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
signal::Application::handle-local-options
signal is emitted, from which the
application can inspect the values of its GOptionEntrys
.
signal::Application::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 signal::Application::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
ApplicationFlags::HANDLES_COMMAND_LINE
was specified then the remaining
commandline arguments are sent to the primary instance, where a
signal::Application::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
signal::Application::activate
signal. If there are one or more files, and
ApplicationFlags::HANDLES_OPEN
was specified then the files are opened
via the signal::Application::open
signal.
If you are interested in doing more complicated local handling of the
commandline then you should implement your own Application
subclass
and override local_command_line()
. In this case, you most likely want
to return true
from your local_command_line()
implementation to
suppress the default handling. See
[gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
for an example.
If, after the above is done, the use count of the application is zero then the exit status is returned immediately. If the use count is non-zero then the default main context is iterated until the use count falls to zero, at which point 0 is returned.
If the ApplicationFlags::IS_SERVICE
flag is set, then the service will
run for as much as 10 seconds with a use count of zero while waiting
for the message that caused the activation to arrive. After that,
if the use count falls to zero the application will exit immediately,
except in the case that ApplicationExt::set_inactivity_timeout()
is in
use.
This function sets the prgname (g_set_prgname()
), if not already set,
to the basename of argv[0].
Much like g_main_loop_run()
, this function will acquire the main context
for the duration that the application is running.
Since 2.40, applications that are not explicitly flagged as services
or launchers (ie: neither ApplicationFlags::IS_SERVICE
or
ApplicationFlags::IS_LAUNCHER
are given as flags) will check (from the
default handler for local_command_line) if “–gapplication-service”
was given in the command line. If this flag is present then normal
commandline processing is interrupted and the
ApplicationFlags::IS_SERVICE
flag is set. This provides a “compromise”
solution whereby running an application directly from the commandline
will invoke it in the normal way (which can be useful for debugging)
while still allowing applications to be D-Bus activated in service
mode. The D-Bus service file should invoke the executable with
“–gapplication-service” as the sole commandline argument. This
approach is suitable for use by most graphical applications but
should not be used from applications like editors that need precise
control over when processes invoked via the commandline will exit and
what their exit status will be.
argv
the argv from main()
, or None
Returns
the exit status
fn run_with_args<S: AsRef<str>>(&self, args: &[S]) -> i32
sourcefn connect_open<F: Fn(&Self, &[File], &str) + 'static>(
&self,
f: F
) -> SignalHandlerId
fn connect_open<F: Fn(&Self, &[File], &str) + 'static>( &self, f: F ) -> SignalHandlerId
The ::open signal is emitted on the primary instance when there are
files to open. See ApplicationExt::open()
for more information.
files
an array of GFiles
hint
a hint provided by the calling instance