Trait gio::prelude::ApplicationCommandLineExt
source · pub trait ApplicationCommandLineExt: 'static {
// Required methods
fn create_file_for_arg(&self, arg: impl AsRef<OsStr>) -> File;
fn arguments(&self) -> Vec<OsString>;
fn cwd(&self) -> Option<PathBuf>;
fn environ(&self) -> Vec<OsString>;
fn exit_status(&self) -> i32;
fn is_remote(&self) -> bool;
fn options_dict(&self) -> VariantDict;
fn platform_data(&self) -> Option<Variant>;
fn stdin(&self) -> Option<InputStream>;
fn getenv(&self, name: impl AsRef<OsStr>) -> Option<GString>;
fn set_exit_status(&self, exit_status: i32);
fn connect_is_remote_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
}
Expand description
Required Methods§
sourcefn create_file_for_arg(&self, arg: impl AsRef<OsStr>) -> File
fn create_file_for_arg(&self, arg: impl AsRef<OsStr>) -> File
Creates a File
corresponding to a filename that was given as part
of the invocation of self
.
This differs from File::for_commandline_arg()
in that it
resolves relative pathnames using the current working directory of
the invoking process rather than the local process.
arg
an argument from self
Returns
a new File
sourcefn arguments(&self) -> Vec<OsString>
fn arguments(&self) -> Vec<OsString>
Gets the list of arguments that was passed on the command line.
The strings in the array may contain non-UTF-8 data on UNIX (such as filenames or arguments given in the system locale) but are always in UTF-8 on Windows.
If you wish to use the return value with GOptionContext
, you must
use g_option_context_parse_strv()
.
The return value is None
-terminated and should be freed using
g_strfreev()
.
Returns
the string array containing the arguments (the argv)
sourcefn cwd(&self) -> Option<PathBuf>
fn cwd(&self) -> Option<PathBuf>
Gets the working directory of the command line invocation. The string may contain non-utf8 data.
It is possible that the remote application did not send a working
directory, so this may be None
.
The return value should not be modified or freed and is valid for as
long as self
exists.
Returns
the current directory, or None
sourcefn environ(&self) -> Vec<OsString>
fn environ(&self) -> Vec<OsString>
Gets the contents of the ‘environ’ variable of the command line
invocation, as would be returned by g_get_environ()
, ie as a
None
-terminated list of strings in the form ‘NAME=VALUE’.
The strings may contain non-utf8 data.
The remote application usually does not send an environment. Use
ApplicationFlags::SEND_ENVIRONMENT
to affect that. Even with this flag
set it is possible that the environment is still not available (due
to invocation messages from other applications).
The return value should not be modified or freed and is valid for as
long as self
exists.
See getenv()
if you are only interested
in the value of a single environment variable.
Returns
the environment strings, or None
if they were not sent
sourcefn exit_status(&self) -> i32
fn exit_status(&self) -> i32
sourcefn options_dict(&self) -> VariantDict
fn options_dict(&self) -> VariantDict
Gets the options that 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 None
.
The data has been passed via an untrusted external process, so the types of all values must be checked before being used.
Returns
a glib::VariantDict
with the options
sourcefn platform_data(&self) -> Option<Variant>
fn platform_data(&self) -> Option<Variant>
Gets the platform data associated with the invocation of self
.
This is a glib::Variant
dictionary containing information about the
context in which the invocation occurred. It typically contains
information like the current working directory and the startup
notification ID.
It comes from an untrusted external process and hence the types of all values must be validated before being used.
For local invocation, it will be None
.
Returns
the platform data, or None
sourcefn stdin(&self) -> Option<InputStream>
fn stdin(&self) -> Option<InputStream>
Gets the stdin of the invoking process.
The InputStream
can be used to read data passed to the standard
input of the invoking process.
This doesn’t work on all platforms. Presently, it is only available
on UNIX when using a D-Bus daemon capable of passing file descriptors.
If stdin is not available then None
will be returned. In the
future, support may be expanded to other platforms.
You must only call this function once per commandline invocation.
Returns
a InputStream
for stdin
sourcefn getenv(&self, name: impl AsRef<OsStr>) -> Option<GString>
fn getenv(&self, name: impl AsRef<OsStr>) -> Option<GString>
Gets the value of a particular environment variable of the command
line invocation, as would be returned by g_getenv()
. The strings may
contain non-utf8 data.
The remote application usually does not send an environment. Use
ApplicationFlags::SEND_ENVIRONMENT
to affect that. Even with this flag
set it is possible that the environment is still not available (due
to invocation messages from other applications).
The return value should not be modified or freed and is valid for as
long as self
exists.
name
the environment variable to get
Returns
the value of the variable, or None
if unset or unsent
sourcefn set_exit_status(&self, exit_status: i32)
fn set_exit_status(&self, exit_status: i32)
Sets the exit status that will be used when the invoking process exits.
The return value of the command-line
signal is
passed to this function when the handler returns. This is the usual
way of setting the exit status.
In the event that you want the remote invocation to continue running
and want to decide on the exit status in the future, you can use this
call. For the case of a remote invocation, the remote process will
typically exit when the last reference is dropped on self
. The
exit status of the remote process will be equal to the last value
that was set with this function.
In the case that the commandline invocation is local, the situation
is slightly more complicated. If the commandline invocation results
in the mainloop running (ie: because the use-count of the application
increased to a non-zero value) then the application is considered to
have been ‘successful’ in a certain sense, and the exit status is
always zero. If the application use count is zero, though, the exit
status of the local ApplicationCommandLine
is used.
exit_status
the exit status