Struct xpcom::interfaces::nsIAccessible

#[repr(C)]
pub struct nsIAccessible { /* fields omitted */ }

interface nsIAccessible : nsISupports

/**
 * A cross-platform interface that supports platform-specific
 * accessibility APIs like MSAA and ATK. Contains the sum of what's needed
 * to support IAccessible as well as ATK's generic accessibility objects.
 * Can also be used by in-process accessibility clients to get information
 * about objects in the accessible tree. The accessible tree is a subset of
 * nodes in the DOM tree -- such as documents, focusable elements and text.
 * Mozilla creates the implementations of nsIAccessible on demand.
 * See http://www.mozilla.org/projects/ui/accessibility for more information.
 */

Methods

impl nsIAccessible

pub fn coerce<T: nsIAccessibleCoerce>(&self) -> &T

Cast this nsIAccessible to one of its base interfaces.

impl nsIAccessible

pub unsafe fn GetParent(&self, aParent: *mut *const nsIAccessible) -> nsresult

/**
   * Parent node in accessible tree.
   */

readonly attribute nsIAccessible parent;

pub unsafe fn GetNextSibling(
    &self,
    aNextSibling: *mut *const nsIAccessible
) -> nsresult

/**
   * Next sibling in accessible tree
   */

readonly attribute nsIAccessible nextSibling;

pub unsafe fn GetPreviousSibling(
    &self,
    aPreviousSibling: *mut *const nsIAccessible
) -> nsresult

/**
   * Previous sibling in accessible tree
   */

readonly attribute nsIAccessible previousSibling;

pub unsafe fn GetFirstChild(
    &self,
    aFirstChild: *mut *const nsIAccessible
) -> nsresult

/**
   * First child in accessible tree
   */

readonly attribute nsIAccessible firstChild;

pub unsafe fn GetLastChild(
    &self,
    aLastChild: *mut *const nsIAccessible
) -> nsresult

/**
   * Last child in accessible tree
   */

readonly attribute nsIAccessible lastChild;

pub unsafe fn GetChildren(&self, aChildren: *mut *const nsIArray) -> nsresult

/**
   * Array of all this element's children.
   */

readonly attribute nsIArray children;

pub unsafe fn GetChildCount(&self, aChildCount: *mut int32_t) -> nsresult

/**
   * Number of accessible children
   */

readonly attribute long childCount;

pub unsafe fn GetIndexInParent(&self, aIndexInParent: *mut int32_t) -> nsresult

/**
   * The 0-based index of this accessible in its parent's list of children,
   * or -1 if this accessible does not have a parent.
   */

readonly attribute long indexInParent;

pub unsafe fn GetDOMNode(&self, aDOMNode: *mut *const nsIDOMNode) -> nsresult

/**
   * The DOM node this nsIAccessible is associated with.
   */

readonly attribute nsIDOMNode DOMNode;

pub unsafe fn GetId(&self, aId: &mut nsAString) -> nsresult

/**
    * For remote accessibles the id of the related DOM node.
    */

readonly attribute DOMString id;

pub unsafe fn GetDocument(
    &self,
    aDocument: *mut *const nsIAccessibleDocument
) -> nsresult

/**
   * The document accessible that this access node resides in.
   */

readonly attribute nsIAccessibleDocument document;

pub unsafe fn GetRootDocument(
    &self,
    aRootDocument: *mut *const nsIAccessibleDocument
) -> nsresult

/**
   * The root document accessible that this access node resides in.
   */

readonly attribute nsIAccessibleDocument rootDocument;

pub unsafe fn GetLanguage(&self, aLanguage: &mut nsAString) -> nsresult

/**
   * The language for the current DOM node, e.g. en, de, etc.
   */

readonly attribute DOMString language;

pub unsafe fn GetName(&self, aName: &mut nsAString) -> nsresult

/**
   * Accessible name -- the main text equivalent for this node. The name is
   * specified by ARIA or by native markup. Example of ARIA markup is
   * aria-labelledby attribute placed on element of this accessible. Example
   * of native markup is HTML label linked with HTML element of this accessible.
   *
   * Value can be string or null. A null value indicates that AT may attempt to
   * compute the name. Any string value, including the empty string, should be
   * considered author-intentional, and respected.
   */

readonly attribute AString name;

pub unsafe fn GetValue(&self, aValue: &mut nsAString) -> nsresult

/**
   * Accessible value -- a number or a secondary text equivalent for this node
   * Widgets that use role attribute can force a value using the valuenow attribute
   */

readonly attribute AString value;

pub unsafe fn GetDescription(&self, aDescription: &mut nsAString) -> nsresult

/**
   * Accessible description -- long text associated with this node
   */

readonly attribute AString description;

pub unsafe fn GetAccessKey(&self, aAccessKey: &mut nsAString) -> nsresult

/**
   * Provides localized string of accesskey name, such as Alt+D.
   * The modifier may be affected by user and platform preferences.
   * Usually alt+letter, or just the letter alone for menu items.
   */

readonly attribute AString accessKey;

pub unsafe fn GetKeyboardShortcut(
    &self,
    aKeyboardShortcut: &mut nsAString
) -> nsresult

/**
   * Provides localized string of global keyboard accelerator for default
   * action, such as Ctrl+O for Open file
   */

readonly attribute AString keyboardShortcut;

pub unsafe fn GetRole(&self, aRole: *mut uint32_t) -> nsresult

/**
   * Enumerated accessible role (see the constants defined in nsIAccessibleRole).
   *
   * @note  The values might depend on platform because of variations. Widgets
   *        can use ARIA role attribute to force the final role.
   */

readonly attribute unsigned long role;

pub unsafe fn GetState(
    &self,
    aState: *mut uint32_t,
    aExtraState: *mut uint32_t
) -> nsresult

/**
   * Accessible states -- bit fields which describe boolean properties of node.
   * Many states are only valid given a certain role attribute that supports
   * them.
   *
   * @param aState - the first bit field (see nsIAccessibleStates::STATE_*
   *                 constants)
   * @param aExtraState - the second bit field
   *                      (see nsIAccessibleStates::EXT_STATE_* constants)
   */

void getState (out unsigned long aState, out unsigned long aExtraState);

pub unsafe fn GetHelp(&self, aHelp: &mut nsAString) -> nsresult

/**
   * Help text associated with node
   *
   * @note As of now, this just returns empty string.
   */

readonly attribute AString help;

pub unsafe fn GetFocusedChild(
    &self,
    aFocusedChild: *mut *const nsIAccessible
) -> nsresult

/**
   * Focused accessible child of node
   */

readonly attribute nsIAccessible focusedChild;

pub unsafe fn GetAttributes(
    &self,
    aAttributes: *mut *const nsIPersistentProperties
) -> nsresult

/**
   * Attributes of accessible
   */

readonly attribute nsIPersistentProperties attributes;

pub unsafe fn GroupPosition(
    &self,
    aGroupLevel: *mut int32_t,
    aSimilarItemsInGroup: *mut int32_t,
    aPositionInGroup: *mut int32_t
) -> nsresult

/**
   * Returns grouping information. Used for tree items, list items, tab panel
   * labels, radio buttons, etc. Also used for collectons of non-text objects.
   *
   * @param groupLevel - 1-based, similar to ARIA 'level' property
   * @param similarItemsInGroup - 1-based, similar to ARIA 'setsize' property,
   *                              inclusive of the current item
   * @param positionInGroup - 1-based, similar to ARIA 'posinset' property
   */

void groupPosition (out long aGroupLevel, out long aSimilarItemsInGroup, out long aPositionInGroup);

pub unsafe fn GetChildAtPoint(
    &self,
    x: int32_t,
    y: int32_t,
    _retval: *mut *const nsIAccessible
) -> nsresult

/**
   * Accessible child which contains the coordinate at (x, y) in screen pixels.
   * If the point is in the current accessible but not in a child, the
   * current accessible will be returned.
   * If the point is in neither the current accessible or a child, then
   * null will be returned.
   *
   * @param x  screen's x coordinate
   * @param y  screen's y coordinate
   * @return   the deepest accessible child containing the given point
   */

nsIAccessible getChildAtPoint (in long x, in long y);

pub unsafe fn GetDeepestChildAtPoint(
    &self,
    x: int32_t,
    y: int32_t,
    _retval: *mut *const nsIAccessible
) -> nsresult

/**
   * Deepest accessible child which contains the coordinate at (x, y) in screen
   * pixels. If the point is in the current accessible but not in a child, the
   * current accessible will be returned. If the point is in neither the current
   * accessible or a child, then null will be returned.
   *
   * @param x  screen's x coordinate
   * @param y  screen's y coordinate
   * @return   the deepest accessible child containing the given point
   */

nsIAccessible getDeepestChildAtPoint (in long x, in long y);

pub unsafe fn GetChildAt(
    &self,
    aChildIndex: int32_t,
    _retval: *mut *const nsIAccessible
) -> nsresult

/**
   * Nth accessible child using zero-based index or last child if index less than zero
   */

nsIAccessible getChildAt (in long aChildIndex);

pub unsafe fn GetRelationByType(
    &self,
    aRelationType: uint32_t,
    _retval: *mut *const nsIAccessibleRelation
) -> nsresult

/**
   * Return accessible relation by the given relation type (see.
   * constants defined in nsIAccessibleRelation).
   */

nsIAccessibleRelation getRelationByType (in unsigned long aRelationType);

pub unsafe fn GetRelations(&self, _retval: *mut *const nsIArray) -> nsresult

/**
   * Returns multiple accessible relations for this object.
   */

nsIArray getRelations ();

pub unsafe fn GetBounds(
    &self,
    x: *mut int32_t,
    y: *mut int32_t,
    width: *mut int32_t,
    height: *mut int32_t
) -> nsresult

/**
   * Return accessible's x and y coordinates relative to the screen and
   * accessible's width and height.
   */

void getBounds (out long x, out long y, out long width, out long height);

pub unsafe fn SetSelected(&self, isSelected: bool) -> nsresult

/**
   * Add or remove this accessible to the current selection
   */

void setSelected (in boolean isSelected);

pub unsafe fn TakeSelection(&self) -> nsresult

/**
   * Select this accessible node only
   */

void takeSelection ();

pub unsafe fn TakeFocus(&self) -> nsresult

/**
   * Focus this accessible node,
   * The state STATE_FOCUSABLE indicates whether this node is normally focusable.
   * It is the callers responsibility to determine whether this node is focusable.
   * accTakeFocus on a node that is not normally focusable (such as a table),
   * will still set focus on that node, although normally that will not be visually
   * indicated in most style sheets.
   */

void takeFocus ();

pub unsafe fn GetActionCount(&self, aActionCount: *mut uint8_t) -> nsresult

/**
   * The number of accessible actions associated with this accessible
   */

readonly attribute uint8_t actionCount;

pub unsafe fn GetActionName(
    &self,
    index: uint8_t,
    _retval: &mut nsAString
) -> nsresult

/**
   * The name of the accessible action at the given zero-based index
   */

AString getActionName (in uint8_t index);

pub unsafe fn GetActionDescription(
    &self,
    aIndex: uint8_t,
    _retval: &mut nsAString
) -> nsresult

/**
   * The description of the accessible action at the given zero-based index
   */

AString getActionDescription (in uint8_t aIndex);

pub unsafe fn DoAction(&self, index: uint8_t) -> nsresult

/**
   * Perform the accessible action at the given zero-based index
   * Action number 0 is the default action
   */

void doAction (in uint8_t index);

pub unsafe fn ScrollTo(&self, aScrollType: uint32_t) -> nsresult

/**
   * Makes an object visible on screen.
   *
   * @param scrollType - defines where the object should be placed on
   *                     the screen (see nsIAccessibleScrollType for
   *                     available constants).
   */

void scrollTo (in unsigned long aScrollType);

pub unsafe fn ScrollToPoint(
    &self,
    coordinateType: uint32_t,
    x: int32_t,
    y: int32_t
) -> nsresult

/**
   * Moves the top left of an object to a specified location.
   *
   * @param coordinateType [in] - specifies whether the coordinates are relative to
   *                         the screen or the parent object (for available
   *                         constants refer to nsIAccessibleCoordinateType)
   * @param x [in] - defines the x coordinate
   * @param y [in] - defines the y coordinate
  */

void scrollToPoint (in unsigned long coordinateType, in long x, in long y);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIAccessible

const IID: nsIID

IID: nsIID = nsID(3727190489, 22076, 18755, [153, 107, 49, 164, 218, 164, 208, 151])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIAccessible

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIAccessible

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.