Struct atspi_proxies::action::ActionProxyBlocking

pub struct ActionProxyBlocking<'p>(/* private fields */);

A handle for a remote object implementing the org.a11y.atspi.Action interface.

The Action interface allows exploring and invoking the actions of a user-actionable UI component.

For example, a button may expose a “click” action - a popup menu may expose an “open” action.

Components which are not “passive” providers of UI information should implement this interface, unless there is a more specialized interface for interaction like org.a11y.atspi.Text or org.a11y.atspi.Value.

Implementations

impl<'p> ActionProxyBlocking<'p>

pub fn new(conn: &Connection) -> Result<ActionProxyBlocking<'p>>

Creates a new proxy with the default service and path.

pub fn builder(conn: &Connection) -> Builder<'p, Self>

Returns a customizable builder for this proxy.

pub fn into_inner(self) -> Proxy<'p>

Consumes self, returning the underlying zbus::Proxy.

pub fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

pub fn inner_mut(&mut self) -> &mut Proxy<'p>

The mutable reference to the underlying zbus::Proxy.

pub fn do_action(&self, index: i32) -> Result<bool>

Performs the specified action on the object.

Returns: Ok(true) on success, Ok(false) otherwise.

Arguments

• index - The index of the action to perform.

pub fn get_actions(&self) -> Result<Vec<Action>>

Returns an array of localized name, localized description, keybinding for the actions that an object supports.

See get_key_binding method for a description of that field’s syntax.

This is equivalent to using the methods get_localized_name, get_description and get_key_binding for each action, but with a single call and thus less DBus traffic.

By convention, if there is more than one action available, the first one is considered the “default” action of the object.

pub fn get_description(&self, index: i32) -> Result<String>

Returns the localized description for the action at the specified index, starting at zero.

For example, a screen reader will read out this description when the user asks for extra detail on an action. For example, “Clicks the button” for the “click” action of a button.

pub fn get_key_binding(&self, index: i32) -> Result<String>

Returns the keybinding for the action, specified by a zero-based index.

Gets the keybinding which can be used to invoke this action, if one exists.

The string returned should contain localized, human-readable, key sequences as they would appear when displayed on screen. It must be in the format “mnemonic;sequence;shortcut”.

• The mnemonic key activates the object if it is presently enabled on screen. This typically corresponds to the underlined letter within the widget. Example: “n” in a traditional “Ṉew…” menu item or the “a” in “Apply” for a button.

• The sequence is the full list of keys which invoke the action even if the relevant element is not currently shown on screen. For instance, for a menu item the sequence is the keybindings used to open the parent menus before invoking.

The sequence string is colon-delimited. Example: “Alt+F:N” in a traditional “Ṉew…” menu item.

• The shortcut, if it exists, will invoke the same action without showing the component or its enclosing menus or dialogs. Example: “Ctrl+N” in a traditional “Ṉew…” menu item. The shortcut string is colon-delimited. Example: “Ctrl+N” in a traditional “Ṉew…” menu item.

Example: For a traditional “Ṉew…” menu item, the expected return value would be: “N;Alt+F:N;Ctrl+N” for the English locale and “N;Alt+D:N;Strg+N” for the German locale. If, hypothetically, this menu item lacked a mnemonic, it would be represented by “;;Ctrl+N” and “;;Strg+N” respectively.

If there is no key binding for this action, “” is returned.

pub fn get_localized_name(&self, index: i32) -> Result<String>

Returns a short, localized name for the action at the specified by a zero-based index.

This is what screen readers will read out during normal navigation. For example, “Click” for a button.

pub fn get_name(&self, index: i32) -> Result<String>

Returns a machine-readable name for the action at the specified, zero-based index.

pub fn nactions(&self) -> Result<i32>

Returns the number of available actions.

By convention, if there is more than one action available, the first one is considered the “default” action of the object.

pub fn cached_nactions( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the Nactions property, or None if the property is not cached.

pub fn receive_nactions_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the Nactions property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for ActionProxyBlocking<'p>

fn as_mut(&mut self) -> &mut Proxy<'p>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'p> AsRef<Proxy<'p>> for ActionProxyBlocking<'p>

fn as_ref(&self) -> &Proxy<'p>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'p> Clone for ActionProxyBlocking<'p>

fn clone(&self) -> ActionProxyBlocking<'p>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'p> Debug for ActionProxyBlocking<'p>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'p> From<Proxy<'p>> for ActionProxyBlocking<'p>

fn from(proxy: Proxy<'p>) -> Self

Converts to this type from the input type.

impl<'a> ProxyDefault for ActionProxyBlocking<'a>

const INTERFACE: Option<&'static str> = _

const DESTINATION: Option<&'static str> = _

const PATH: Option<&'static str> = _

impl<'p> ProxyImpl<'p> for ActionProxyBlocking<'p>

fn builder(conn: &Connection) -> Builder<'p, Self>

Returns a customizable builder for this proxy.

fn into_inner(self) -> Proxy<'p>

Consumes self, returning the underlying zbus::Proxy.

fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

impl<'p> Serialize for ActionProxyBlocking<'p>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'p> Type for ActionProxyBlocking<'p>

fn signature() -> Signature<'static>

Get the signature for the implementing type.