Struct atspi_proxies::accessible::AccessibleProxy

pub struct AccessibleProxy<'c>(/* private fields */);

Implementations

impl<'c> AccessibleProxy<'c>

pub async fn new(conn: &Connection) -> Result<AccessibleProxy<'c>>

Creates a new proxy with the default service and path.

pub fn builder(conn: &Connection) -> ProxyBuilder<'c, Self>

Returns a customizable builder for this proxy.

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

Consumes self, returning the underlying zbus::Proxy.

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

The reference to the underlying zbus::Proxy.

pub async fn get_application(&self) -> Result<Accessible>

Returns an Accessible which refers to the Application object of the application. This object will have Application interface implemented.

The application object is the root of the accessibility hierarchy for the application. It is the only object in the hierarchy that does not have a parent.

Notes

The application object is the only object in the accessibility hierarchy that is guaranteed to be persistent for the lifetime of the application. All other objects in the accessibility hierarchy may be created and destroyed dynamically.

pub async fn get_attributes(&self) -> Result<HashMap<String, String>>

Gets a list of name/value pairs of attributes or annotations for this object.

Disambiguation

For typographic, textual, or textually-semantic attributes, see TextProxy’s get_attributes method instead.

pub async fn get_child_at_index(&self, index: i32) -> Result<Accessible>

Retrieve child by index (starting from 0),

Queries the N-th accessible child of self. It is expected that this will correspond to the order that the get_children method would return.

Notes

Implementations vary in their behavior when the index is out of range. GTK4 returns an error, while atk-adaptor (e.g. Gtk3) returns the null object path “/org/a11y/atspi/null”.

Documentation advises implementors to return a DBus Error when the index is out of range, to “keep the type system gods happy”.

pub async fn get_children(&self) -> Result<Vec<Accessible>>

Retrieves a list of the object’s accessible children.

Each array element is an Accessible representing the accessible child object.

Registry

On the Accessible interface of org.a11y.atspi.Registry, the registry daemon, this method retrieves a list of all accessible applications’ root objects on the bus.

pub async fn get_index_in_parent(&self) -> Result<i32>

This object resides in its parent’s list of children. This returns its position in this list of children, starting from 0.

The function returns -1 if the object does not have a parent or if an exception occurs.

pub async fn get_interfaces(&self) -> Result<InterfaceSet>

Returns an InterfaceSet accessible interface names supported by the self object. InterfaceSet: crate::common::InterfaceSet

pub async fn get_localized_role_name(&self) -> Result<String>

Gets a String corresponding to the name of the role played by an object, translated to the current locale.

Notes

This method will return useful values for roles that fall outside the enumeration used in the get_role method.

For applications, implementing this method is optional, and it may be removed in a future version of the API.

For example, libatspi will only call it in the event of an unknown role.

pub async fn get_relation_set( &self ) -> Result<Vec<(RelationType, Vec<Accessible>)>>

Returns a set of relationships between the this self object and others.

This vector of tuples contains a RelationType and a vector of Accessible’s to which that relationship applies. These relationships allow for better identification of how objects are associated with one another.

For example, the relationship RelationType::LabelledBy can be used to identify labeling information that should accompany the accessible name property when presenting an object’s content or identity to the end user.

Similarly, RelationType::ControllerFor can be used to specify the context in which a valuator is useful and/or the other UI components that are directly affected by user interactions with the valuator. Common examples include the association of scrollbars with the viewport or panel that they control.

pub async fn get_role(&self) -> Result<Role>

Gets the Role that the current accessible object represents.

Roles make it possible for various UI toolkits to expose their controls to assistive technologies (ATs) with a standard interface, regardless of toolkit.

For example, a widget that acts like a conventional push button (appears unpressed; presses when acted upon; invokes a certain action when pressed) can expose an Role::PushButton role.

pub async fn get_role_name(&self) -> Result<String>

Gets a String corresponding to the name of the role played by an object, translated to the current locale.

Notes

This method will return useful values for roles that fall outside the enumeration used in the get_role method.

For applications, implementing this method is optional, and it may be removed in a future version of the API.

pub async fn get_state(&self) -> Result<StateSet>

Method to retrieve the StateSet of states currently held by self. StateSet: crate::common::StateSet

pub async fn accessible_id(&self) -> Result<String>

Application-specific identifier for the current object.

A special id given to an object. Accessible application developers can use this to give a special id to an object to use in tests, for example, “my_widget”.

Note that there is no way to directly find an object by its id; a test program may have to recursively get the children to find a specific id. This is because accessible objects can be created dynamically, and they do not always correspond to a static view of an application’s data.

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

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

pub async fn receive_accessible_id_changed( &self ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

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

pub async fn child_count(&self) -> Result<i32>

Number of accessible children for the current object.

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

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

pub async fn receive_child_count_changed( &self ) -> PropertyStream<'c, <Result<i32> as ResultAdapter>::Ok>

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

pub async fn description(&self) -> Result<String>

Human-readable, localized description of self in more detail.

This is a longer description than the Name property.

For example, a button might have a name of “OK”, but a description of “OK button”.

While the Name property is meant to be a short string that screen readers say during normal navigation, the Description property is for when the user asks for more detail.

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

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

pub async fn receive_description_changed( &self ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

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

pub async fn locale(&self) -> Result<String>

Unix locale for the current object.

This is a string in the form of “language_territory.codeset”. For example, “en_US.UTF-8” or “de_DE.UTF-8”.

For an application, this may be the locale for the language that the application shows in its user interface.

For a document being shown in an application, or a paragraph within a document, the locale may refer to that object exclusively. For example: an application may be showing itself in English (“en”), but it may be used to display a document in Spanish (“es”). In the latter case, a screen reader will want to know that it should switch to Spanish while reading the document.

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

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

pub async fn receive_locale_changed( &self ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

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

pub async fn name(&self) -> Result<String>

Human-readable, localized, short name for the object.

Applications should have this set for objects which do not have a RelationType::LabelledBy relation.

Consider a widget to select RGB colors by setting three sliders. The names for the sliders would be “Red”, “Green”, “Blue”, respectively, or their translations to application’s locale. The names would be unnecessary if each slider had a LabeledBy relation to corresponding labels visible in the user interface.

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

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

pub async fn receive_name_changed( &self ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

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

pub async fn parent(&self) -> Result<Accessible>

Accessible parent object of the current object.

Null parent: If the object has no parent (e.g. the application’s root object is being queried), The application should return “” for the application name name and “/org/a11y/atspi/null” for the object path.

Root object: An application must have a single root object, called “/org/a11y/atspi/accessible/root”. All other objects should have that one as their highest-level ancestor.

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

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

pub async fn receive_parent_changed( &self ) -> PropertyStream<'c, <Result<Accessible> as ResultAdapter>::Ok>

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

Methods from Deref<Target = Proxy<'c>>

pub fn connection(&self) -> &Connection

Get a reference to the associated connection.

pub fn destination(&self) -> &BusName<'_>

Get a reference to the destination service name.

pub fn path(&self) -> &ObjectPath<'_>

Get a reference to the object path.

pub fn interface(&self) -> &InterfaceName<'_>

Get a reference to the interface.

pub async fn introspect(&self) -> impl Future<Output = Result<String, Error>>

Introspect the associated object, and return the XML description.

See the xml or quick_xml module for parsing the result.

pub fn cached_property<T>( &self, property_name: &str ) -> Result<Option<T>, Error>where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the cached value of the property property_name.

This returns None if the property is not in the cache. This could be because the cache was invalidated by an update, because caching was disabled for this property or proxy, or because the cache has not yet been populated. Use get_property to fetch the value from the peer.

pub fn cached_property_raw<'p>( &'p self, property_name: &'p str ) -> Option<impl Deref<Target = Value<'static>> + 'p>

Get the cached value of the property property_name.

Same as cached_property, but gives you access to the raw value stored in the cache. This is useful if you want to avoid allocations and cloning.

pub async fn get_property<T>( &self, property_name: &str ) -> impl Future<Output = Result<T, Error>>where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the property property_name.

Get the property value from the cache (if caching is enabled) or call the Get method of the org.freedesktop.DBus.Properties interface.

pub async fn set_property<'t, T>( &self, property_name: &str, value: T ) -> impl Future<Output = Result<(), Error>>where T: 't + Into<Value<'t>>,

Set the property property_name.

Effectively, call the Set method of the org.freedesktop.DBus.Properties interface.

pub async fn call_method<'m, M, B>( &self, method_name: M, body: &B ) -> impl Future<Output = Result<Arc<Message, Global>, Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method and return the reply.

Typically, you would want to use call method instead. Use this method if you need to deserialize the reply message manually (this way, you can avoid the memory allocation/copying, by deserializing the reply to an unowned type).

pub async fn call<'m, M, B, R>( &self, method_name: M, body: &B ) -> impl Future<Output = Result<R, Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body.

Use call_method instead if you need to deserialize the reply manually/separately.

pub async fn call_with_flags<'m, M, B, R>( &self, method_name: M, flags: BitFlags<MethodFlags, <MethodFlags as RawBitFlags>::Numeric>, body: &B ) -> impl Future<Output = Result<Option<R>, Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body, optionally supplying a set of method flags to control the way the method call message is sent and handled.

Use call instead if you do not need any special handling via additional flags. If the NoReplyExpected flag is passed , this will return None immediately after sending the message, similar to call_noreply

pub async fn call_noreply<'m, M, B>( &self, method_name: M, body: &B ) -> impl Future<Output = Result<(), Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method without expecting a reply

This sets the NoReplyExpected flag on the calling message and does not wait for a reply.

pub async fn receive_signal<'m, M>( &self, signal_name: M ) -> impl Future<Output = Result<SignalStream<'m>, Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Create a stream for signal named signal_name.

pub async fn receive_signal_with_args<'m, M>( &self, signal_name: M, args: &[(u8, &str)] ) -> impl Future<Output = Result<SignalStream<'m>, Error>>where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Same as Proxy::receive_signal but with a filter.

The D-Bus specification allows you to filter signals by their arguments, which helps avoid a lot of unnecessary traffic and processing since the filter is run on the server side. Use this method where possible. Note that this filtering is limited to arguments of string types.

The arguments are passed as a tuples of argument index and expected value.

pub async fn receive_all_signals( &self ) -> impl Future<Output = Result<SignalStream<'static>, Error>>

Create a stream for all signals emitted by this service.

pub async fn receive_property_changed<'name, T>( &self, name: &'name str ) -> impl Future<Output = PropertyStream<'a, T>>where 'name: 'a,

Get a stream to receive property changed events.

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

If caching is not enabled on this proxy, the resulting stream will not return any events.

pub async fn receive_owner_changed( &self ) -> impl Future<Output = Result<OwnerChangedStream<'_>, Error>>

Get a stream to receive destination owner changed events.

If the proxy destination is a unique name, the stream will be notified of the peer disconnection from the bus (with a None value).

If the proxy destination is a well-known name, the stream will be notified whenever the name owner is changed, either by a new peer being granted ownership (Some value) or when the name is released (with a None value).

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

Trait Implementations

impl<'c> AsMut<Proxy<'c>> for AccessibleProxy<'c>

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

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

impl<'c> AsRef<Proxy<'c>> for AccessibleProxy<'c>

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

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

impl<'c> Clone for AccessibleProxy<'c>

fn clone(&self) -> AccessibleProxy<'c>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'c> Debug for AccessibleProxy<'c>

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

Formats the value using the given formatter.

impl<'c> Deref for AccessibleProxy<'c>

type Target = Proxy<'c>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'c> DerefMut for AccessibleProxy<'c>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'c> From<Proxy<'c>> for AccessibleProxy<'c>

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

Converts to this type from the input type.

impl PartialEq<AccessibleProxy<'_>> for AccessibleProxy<'_>

fn eq<'a>(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> ProxyDefault for AccessibleProxy<'a>

const INTERFACE: &'static str = _

const DESTINATION: &'static str = _

const PATH: &'static str = _

impl<'c> Serialize for AccessibleProxy<'c>

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

Serialize this value into the given Serde serializer.

impl TryFrom<&AccessibleProxy<'_>> for Accessible

type Error = AtspiError

The type returned in the event of a conversion error.

fn try_from(proxy: &AccessibleProxy<'_>) -> Result<Accessible, Self::Error>

Performs the conversion.

impl TryFrom<AccessibleProxy<'_>> for Accessible

type Error = AtspiError

The type returned in the event of a conversion error.

fn try_from(proxy: AccessibleProxy<'_>) -> Result<Accessible, Self::Error>

Performs the conversion.

impl<'c> Type for AccessibleProxy<'c>

fn signature() -> Signature<'static>

Get the signature for the implementing type.

impl Eq for AccessibleProxy<'_>