Enum atspi_common::RelationType

pub enum RelationType {
    Null = 0,
    LabelFor = 1,
    LabelledBy = 2,
    ControllerFor = 3,
    ControlledBy = 4,
    MemberOf = 5,
    TooltipFor = 6,
    NodeChildOf = 7,
    NodeParentOf = 8,
    Extended = 9,
    FlowsTo = 10,
    FlowsFrom = 11,
    SubwindowOf = 12,
    Embeds = 13,
    EmbeddedBy = 14,
    PopupFor = 15,
    ParentWindowOf = 16,
    DescriptionFor = 17,
    DescribedBy = 18,
    Details = 19,
    DetailsFor = 20,
    ErrorMessage = 21,
    ErrorFor = 22,
}

Describes a relationship between one object and another.

Variants

Null = 0

Not a meaningful relationship; clients should not normally encounter this value.

LabelFor = 1

Object is a label for one or more other objects.

LabelledBy = 2

Object is labelled by one or more other objects.

ControllerFor = 3

Object is an interactive object which modifies the state, onscreen location, or other attributes of one or more target objects.

ControlledBy = 4

Object state, position, etc. is modified/controlled by user interaction with one or more other objects. For instance a viewport or scroll pane may be ControlledBy scrollbars.

MemberOf = 5

Object has a grouping relationship (e.g. ‘same group as’) to one or more other objects.

TooltipFor = 6

Object is a tooltip associated with another object.

NodeChildOf = 7

Object is a child of the target.

NodeParentOf = 8

Object is a parent of the target.

Extended = 9

Used to indicate that a relationship exists, but its type is not specified in the enumeration.

FlowsTo = 10

Object renders content which flows logically to another object. For instance, text in a paragraph may flow to another object which is not the ‘next sibling’ in the accessibility hierarchy.

FlowsFrom = 11

Reciprocal of FlowsTo.

SubwindowOf = 12

Object is visually and semantically considered a subwindow of another object, even though it is not the object’s child. Useful when dealing with embedded applications and other cases where the widget hierarchy does not map cleanly to the onscreen presentation.

Embeds = 13

Similar to SubwindowOf, but specifically used for cross-process embedding.

EmbeddedBy = 14

Reciprocal of Embeds. Used to denote content rendered by embedded renderers that live in a separate process space from the embedding context.

PopupFor = 15

Denotes that the object is a transient window or frame associated with another onscreen object. Similar to TooltipFor, but more general. Useful for windows which are technically toplevels but which, for one or more reasons, do not explicitly cause their associated window to lose ‘window focus’. Creation of an crate::Role::Window object with the PopupFor relation usually requires some presentation action on the part of assistive technology clients, even though the previous toplevel crate::Role::Frame object may still be the active window.

ParentWindowOf = 16

This is the reciprocal relation to PopupFor.

DescriptionFor = 17

Reciprocal of DescribedBy. Indicates that this object provides descriptive information about the target object(s). See also DetailsFor and ErrorFor.

DescribedBy = 18

Reciprocal of DescriptionFor. Indicates that one or more target objects provide descriptive information about this object. This relation type is most appropriate for information that is not essential as its presentation may be user-configurable and/or limited to an on-demand mechanism such as an assistive technology command. For brief, essential information such as can be found in a widget’s on-screen label, use LabelledBy. For an on-screen error message, use ErrorMessage. For lengthy extended descriptive information contained in an on-screen object, consider using Details as assistive technologies may provide a means for the user to navigate to objects containing detailed descriptions so that their content can be more closely reviewed.

Details = 19

Reciprocal of DetailsFor. Indicates that this object has a detailed or extended description, the contents of which can be found in the target object(s). This relation type is most appropriate for information that is sufficiently lengthy as to make navigation to the container of that information desirable. For less verbose information suitable for announcement only, see DescribedBy. If the detailed information describes an error condition, ErrorFor should be used instead. Included in upstream AT-SPI2-CORE since 2.26.

DetailsFor = 20

Reciprocal of Details. Indicates that this object provides a detailed or extended description about the target object(s). See also DescriptionFor and ErrorFor. Included in upstream AT-SPI2-CORE since 2.26.

ErrorMessage = 21

Reciprocal of ErrorFor. Indicates that this object has one or more errors, the nature of which is described in the contents of the target object(s). Objects that have this relation type should also contain crate::state::State::InvalidEntry when their GetState method is called.
Included in upstream AT-SPI2-CORE since 2.26.

ErrorFor = 22

Reciprocal of ErrorMessage. Indicates that this object contains an error message describing an invalid condition in the target object(s). Included in upstream AT-SPI2-CORE since 2.26.

Trait Implementations

impl Clone for RelationType

fn clone(&self) -> RelationType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RelationType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelationType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RelationType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RelationType

fn eq(&self, other: &RelationType) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for RelationType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Type for RelationType

fn signature() -> Signature<'static>

Get the signature for the implementing type.

impl Copy for RelationType

impl Eq for RelationType

impl StructuralPartialEq for RelationType