mozilla-central/__GENERATED__/dist/xpcrs/rt/nsIAccessibleRole.rs

Copy as Markdown

Other Tools

//
// DO NOT EDIT. THIS FILE IS GENERATED FROM $SRCDIR/accessible/interfaces/nsIAccessibleRole.idl
//
/// `interface nsIAccessibleRole : nsISupports`
///
/// ```text
/// /**
/// * Defines cross platform (Gecko) roles.
/// */
/// ```
///
// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.
#[repr(C)]
pub struct nsIAccessibleRole {
vtable: &'static nsIAccessibleRoleVTable,
/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads by default, as
/// XPCOM is generally not threadsafe.
///
/// If this type is marked as [rust_sync], there will be explicit `Send` and
/// `Sync` implementations on this type, which will override the inherited
/// negative impls from `Rc`.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
// Make the rust compiler aware that there might be interior mutability
// in what actually implements the interface. This works around UB
// that a rust lint would make blatantly obvious, but doesn't exist.
// This prevents optimizations, but those optimizations weren't available
// before rustc switched to LLVM 16, and they now cause problems because
// of the UB.
// Until there's a lint available to find all our UB, it's simpler to
// avoid the UB in the first place, at the cost of preventing optimizations
// in places that don't cause UB. But again, those optimizations weren't
// available before.
__maybe_interior_mutability: ::std::cell::UnsafeCell<[u8; 0]>,
}
// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIAccessibleRole.
unsafe impl XpCom for nsIAccessibleRole {
const IID: nsIID = nsID(0xad7f32a5, 0x6d5f, 0x4154,
[0xa5, 0xb8, 0x0f, 0xa7, 0xae, 0xd4, 0x89, 0x36]);
}
// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIAccessibleRole {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}
// This trait is implemented on all types which can be coerced to from nsIAccessibleRole.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIAccessibleRoleCoerce {
/// Cheaply cast a value of this type from a `nsIAccessibleRole`.
fn coerce_from(v: &nsIAccessibleRole) -> &Self;
}
// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIAccessibleRoleCoerce for nsIAccessibleRole {
#[inline]
fn coerce_from(v: &nsIAccessibleRole) -> &Self {
v
}
}
impl nsIAccessibleRole {
/// Cast this `nsIAccessibleRole` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsIAccessibleRoleCoerce>(&self) -> &T {
T::coerce_from(self)
}
}
// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIAccessibleRole {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}
// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIAccessibleRoleCoerce for T {
#[inline]
fn coerce_from(v: &nsIAccessibleRole) -> &Self {
T::coerce_from(v)
}
}
// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIAccessibleRole
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIAccessibleRoleVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,
}
// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIAccessibleRole {
/// ```text
/// /**
/// * Used when the accessible has no strongly-defined role.
/// */
/// ```
///
pub const ROLE_NOTHING: u32 = 0;
/// ```text
/// /**
/// * Represents the menu bar (positioned beneath the title bar of a window)
/// * from which menus are selected by the user. The role is used by
/// * xul:menubar or role="menubar".
/// */
/// ```
///
pub const ROLE_MENUBAR: u32 = 1;
/// ```text
/// /**
/// * Represents a vertical or horizontal scroll bar, which is part of the client
/// * area or used in a control.
/// */
/// ```
///
pub const ROLE_SCROLLBAR: u32 = 2;
/// ```text
/// /**
/// * Represents an alert or a condition that a user should be notified about.
/// * Assistive Technologies typically respond to the role by reading the entire
/// * onscreen contents of containers advertising this role. Should be used for
/// * warning dialogs, etc. The role is used by xul:browsermessage,
/// * role="alert".
/// */
/// ```
///
pub const ROLE_ALERT: u32 = 3;
/// ```text
/// /**
/// * A sub-document (<frame> or <iframe>)
/// */
/// ```
///
pub const ROLE_INTERNAL_FRAME: u32 = 4;
/// ```text
/// /**
/// * Represents a menu, which presents a list of options from which the user can
/// * make a selection to perform an action. It is used for role="menu".
/// */
/// ```
///
pub const ROLE_MENUPOPUP: u32 = 5;
/// ```text
/// /**
/// * Represents a menu item, which is an entry in a menu that a user can choose
/// * to carry out a command, select an option. It is used for xul:menuitem,
/// * role="menuitem".
/// */
/// ```
///
pub const ROLE_MENUITEM: u32 = 6;
/// ```text
/// /**
/// * Represents a ToolTip that provides helpful hints.
/// */
/// ```
///
pub const ROLE_TOOLTIP: u32 = 7;
/// ```text
/// /**
/// * Represents a main window for an application. It is used for
/// * role="application". Also refer to ROLE_APP_ROOT
/// */
/// ```
///
pub const ROLE_APPLICATION: u32 = 8;
/// ```text
/// /**
/// * Represents a document window. A document window is always contained within
/// * an application window. For role="document", see NON_NATIVE_DOCUMENT.
/// */
/// ```
///
pub const ROLE_DOCUMENT: u32 = 9;
/// ```text
/// /**
/// * Represents a pane within a frame or document window. Users can navigate
/// * between panes and within the contents of the current pane, but cannot
/// * navigate between items in different panes. Thus, panes represent a level
/// * of grouping lower than frame windows or documents, but above individual
/// * controls. It is used for the first child of a <frame> or <iframe>.
/// */
/// ```
///
pub const ROLE_PANE: u32 = 10;
/// ```text
/// /**
/// * Represents a dialog box or message box. It is used for xul:dialog,
/// * role="dialog".
/// */
/// ```
///
pub const ROLE_DIALOG: u32 = 11;
/// ```text
/// /**
/// * Logically groups other objects. There is not always a parent-child
/// * relationship between the grouping object and the objects it contains. It
/// * is used for html:textfield, xul:groupbox, role="group".
/// */
/// ```
///
pub const ROLE_GROUPING: u32 = 12;
/// ```text
/// /**
/// * Used to visually divide a space into two regions, such as a separator menu
/// * item or a bar that divides split panes within a window. It is used for
/// * xul:separator, html:hr, role="separator".
/// */
/// ```
///
pub const ROLE_SEPARATOR: u32 = 13;
/// ```text
/// /**
/// * Represents a toolbar, which is a grouping of controls (push buttons or
/// * toggle buttons) that provides easy access to frequently used features. It
/// * is used for xul:toolbar, role="toolbar".
/// */
/// ```
///
pub const ROLE_TOOLBAR: u32 = 14;
/// ```text
/// /**
/// * Represents a status bar, which is an area at the bottom of a window that
/// * displays information about the current operation, state of the application,
/// * or selected object. The status bar has multiple fields, which display
/// * different kinds of information. It is used for xul:statusbar.
/// */
/// ```
///
pub const ROLE_STATUSBAR: u32 = 15;
/// ```text
/// /**
/// * Represents a table that contains rows and columns of cells, and optionally,
/// * row headers and column headers. It is used for html:table,
/// * role="grid". Also refer to the following roles: ROLE_COLUMNHEADER,
/// * ROLE_ROWHEADER, ROLE_ROW, ROLE_CELL.
/// */
/// ```
///
pub const ROLE_TABLE: u32 = 16;
/// ```text
/// /**
/// * Represents a column header, providing a visual label for a column in
/// * a table. It is used for XUL tree column headers, html:th,
/// * role="colheader". Also refer to ROLE_TABLE.
/// */
/// ```
///
pub const ROLE_COLUMNHEADER: u32 = 17;
/// ```text
/// /**
/// * Represents a row header, which provides a visual label for a table row.
/// * It is used for role="rowheader". Also, see ROLE_TABLE.
/// */
/// ```
///
pub const ROLE_ROWHEADER: u32 = 18;
/// ```text
/// /**
/// * Represents a row of cells within a table. Also, see ROLE_TABLE.
/// */
/// ```
///
pub const ROLE_ROW: u32 = 19;
/// ```text
/// /**
/// * Represents a cell within a table. It is used for html:td and xul:tree cell.
/// * Also, see ROLE_TABLE.
/// */
/// ```
///
pub const ROLE_CELL: u32 = 20;
/// ```text
/// /**
/// * Represents a link to something else. This object might look like text or
/// * a graphic, but it acts like a button. It is used for
/// * xul:label@class="text-link", html:a, html:area.
/// */
/// ```
///
pub const ROLE_LINK: u32 = 21;
/// ```text
/// /**
/// * Represents a list box, allowing the user to select one or more items. It
/// * is used for xul:listbox, html:select@size, role="list". See also
/// * ROLE_LIST_ITEM.
/// */
/// ```
///
pub const ROLE_LIST: u32 = 22;
/// ```text
/// /**
/// * Represents an item in a list. See also ROLE_LIST.
/// */
/// ```
///
pub const ROLE_LISTITEM: u32 = 23;
/// ```text
/// /**
/// * Represents an outline or tree structure, such as a tree view control,
/// * that displays a hierarchical list and allows the user to expand and
/// * collapse branches. Is is used for role="tree".
/// */
/// ```
///
pub const ROLE_OUTLINE: u32 = 24;
/// ```text
/// /**
/// * Represents an item in an outline or tree structure. It is used for
/// * role="treeitem".
/// */
/// ```
///
pub const ROLE_OUTLINEITEM: u32 = 25;
/// ```text
/// /**
/// * Represents a page tab, it is a child of a page tab list. It is used for
/// * xul:tab, role="treeitem". Also refer to ROLE_PAGETABLIST.
/// */
/// ```
///
pub const ROLE_PAGETAB: u32 = 26;
/// ```text
/// /**
/// * Represents a property sheet. It is used for xul:tabpanel,
/// * role="tabpanel".
/// */
/// ```
///
pub const ROLE_PROPERTYPAGE: u32 = 27;
/// ```text
/// /**
/// * Represents a picture. Is is used for xul:image, html:img.
/// */
/// ```
///
pub const ROLE_GRAPHIC: u32 = 28;
/// ```text
/// /**
/// * Represents read-only text, such as labels for other controls or
/// * instructions in a dialog box. Static text cannot be modified or selected.
/// * Is is used for xul:label, xul:description, html:label, role="label".
/// */
/// ```
///
pub const ROLE_STATICTEXT: u32 = 29;
/// ```text
/// /**
/// * Represents selectable text that allows edits or is designated read-only.
/// */
/// ```
///
pub const ROLE_TEXT_LEAF: u32 = 30;
/// ```text
/// /**
/// * Represents a push button control. It is used for xul:button, html:button,
/// * role="button".
/// */
/// ```
///
pub const ROLE_PUSHBUTTON: u32 = 31;
/// ```text
/// /**
/// * Represents a check box control. It is used for xul:checkbox,
/// * html:input@type="checkbox", role="checkbox".
/// */
/// ```
///
pub const ROLE_CHECKBUTTON: u32 = 32;
/// ```text
/// /**
/// * Represents an option button, also called a radio button. It is one of a
/// * group of mutually exclusive options. All objects sharing a single parent
/// * that have this attribute are assumed to be part of single mutually
/// * exclusive group. It is used for xul:radio, html:input@type="radio",
/// * role="radio".
/// */
/// ```
///
pub const ROLE_RADIOBUTTON: u32 = 33;
/// ```text
/// /**
/// * Represents a combo box; a popup button with an associated list box that
/// * provides a set of predefined choices. It is used for html:select with a
/// * size of 1 and xul:menulist. See also ROLE_EDITCOMBOBOX.
/// */
/// ```
///
pub const ROLE_COMBOBOX: u32 = 34;
/// ```text
/// /**
/// * Represents a progress bar, dynamically showing the user the percent
/// * complete of an operation in progress. It is used for html:progress,
/// * role="progressbar".
/// */
/// ```
///
pub const ROLE_PROGRESSBAR: u32 = 35;
/// ```text
/// /**
/// * Represents a slider, which allows the user to adjust a setting in given
/// * increments between minimum and maximum values. It is used by xul:scale,
/// * role="slider".
/// */
/// ```
///
pub const ROLE_SLIDER: u32 = 36;
/// ```text
/// /**
/// * Represents a spin box, which is a control that allows the user to increment
/// * or decrement the value displayed in a separate "buddy" control associated
/// * with the spin box. It is used for input[type=number] spin buttons.
/// */
/// ```
///
pub const ROLE_SPINBUTTON: u32 = 37;
/// ```text
/// /**
/// * Represents a graphical image used to diagram data. It is used for svg:svg.
/// */
/// ```
///
pub const ROLE_DIAGRAM: u32 = 38;
/// ```text
/// /**
/// * Represents an animation control, which contains content that changes over
/// * time, such as a control that displays a series of bitmap frames.
/// */
/// ```
///
pub const ROLE_ANIMATION: u32 = 39;
/// ```text
/// /**
/// * Represents a button that drops down a list of items.
/// */
/// ```
///
pub const ROLE_BUTTONDROPDOWN: u32 = 40;
/// ```text
/// /**
/// * Represents a button that drops down a menu.
/// */
/// ```
///
pub const ROLE_BUTTONMENU: u32 = 41;
/// ```text
/// /**
/// * Represents blank space between other objects.
/// */
/// ```
///
pub const ROLE_WHITESPACE: u32 = 42;
/// ```text
/// /**
/// * Represents a container of page tab controls. Is it used for xul:tabs,
/// * DHTML: role="tabs". Also refer to ROLE_PAGETAB.
/// */
/// ```
///
pub const ROLE_PAGETABLIST: u32 = 43;
/// ```text
/// /**
/// * Represents a control that can be drawn into and is used to trap events.
/// * It is used for html:canvas.
/// */
/// ```
///
pub const ROLE_CANVAS: u32 = 44;
/// ```text
/// /**
/// * Represents a menu item with a check box.
/// */
/// ```
///
pub const ROLE_CHECK_MENU_ITEM: u32 = 45;
/// ```text
/// /**
/// * Represents control whose purpose is to allow a user to edit a date.
/// */
/// ```
///
pub const ROLE_DATE_EDITOR: u32 = 46;
/// ```text
/// /**
/// * Frame role. A top level window with a title bar, border, menu bar, etc.
/// * It is often used as the primary window for an application.
/// */
/// ```
///
pub const ROLE_CHROME_WINDOW: u32 = 47;
/// ```text
/// /**
/// * Presents an icon or short string in an interface.
/// */
/// ```
///
pub const ROLE_LABEL: u32 = 48;
/// ```text
/// /**
/// * A text object uses for passwords, or other places where the text content
/// * is not shown visibly to the user.
/// */
/// ```
///
pub const ROLE_PASSWORD_TEXT: u32 = 49;
/// ```text
/// /**
/// * A radio button that is a menu item.
/// */
/// ```
///
pub const ROLE_RADIO_MENU_ITEM: u32 = 50;
/// ```text
/// /**
/// * Collection of objects that constitute a logical text entity.
/// */
/// ```
///
pub const ROLE_TEXT_CONTAINER: u32 = 51;
/// ```text
/// /**
/// * A toggle button. A specialized push button that can be checked or
/// * unchecked, but does not provide a separate indicator for the current state.
/// */
/// ```
///
pub const ROLE_TOGGLE_BUTTON: u32 = 52;
/// ```text
/// /**
/// * Representas a control that is capable of expanding and collapsing rows as
/// * well as showing multiple columns of data.
/// * XXX: it looks like this role is dupe of ROLE_OUTLINE.
/// */
/// ```
///
pub const ROLE_TREE_TABLE: u32 = 53;
/// ```text
/// /**
/// * A paragraph of text.
/// */
/// ```
///
pub const ROLE_PARAGRAPH: u32 = 54;
/// ```text
/// /**
/// * An control whose textual content may be entered or modified by the user.
/// */
/// ```
///
pub const ROLE_ENTRY: u32 = 55;
/// ```text
/// /**
/// * A caption describing another object.
/// */
/// ```
///
pub const ROLE_CAPTION: u32 = 56;
/// ```text
/// /**
/// * An element containing content that assistive technology users may want to
/// * browse in a reading mode, rather than a focus/interactive/application mode.
/// * This role is used for role="document". For the container which holds the
/// * content of a web page, see ROLE_DOCUMENT.
/// */
/// ```
///
pub const ROLE_NON_NATIVE_DOCUMENT: u32 = 57;
/// ```text
/// /**
/// * Heading.
/// */
/// ```
///
pub const ROLE_HEADING: u32 = 58;
/// ```text
/// /**
/// * A container of document content. An example of the use of this role is to
/// * represent an html:div.
/// */
/// ```
///
pub const ROLE_SECTION: u32 = 59;
/// ```text
/// /**
/// * A container of form controls. An example of the use of this role is to
/// * represent an html:form.
/// */
/// ```
///
pub const ROLE_FORM: u32 = 60;
/// ```text
/// /**
/// * XXX: document this.
/// */
/// ```
///
pub const ROLE_APP_ROOT: u32 = 61;
/// ```text
/// /**
/// * Represents a menu item, which is an entry in a menu that a user can choose
/// * to display another menu.
/// */
/// ```
///
pub const ROLE_PARENT_MENUITEM: u32 = 62;
/// ```text
/// /**
/// * A list of items that is shown by combobox.
/// */
/// ```
///
pub const ROLE_COMBOBOX_LIST: u32 = 63;
/// ```text
/// /**
/// * A item of list that is shown by combobox;
/// */
/// ```
///
pub const ROLE_COMBOBOX_OPTION: u32 = 64;
/// ```text
/// /**
/// * An image map -- has child links representing the areas
/// */
/// ```
///
pub const ROLE_IMAGE_MAP: u32 = 65;
/// ```text
/// /**
/// * An option in a listbox
/// */
/// ```
///
pub const ROLE_OPTION: u32 = 66;
/// ```text
/// /**
/// * A rich option in a listbox, it can have other widgets as children
/// */
/// ```
///
pub const ROLE_RICH_OPTION: u32 = 67;
/// ```text
/// /**
/// * A list of options
/// */
/// ```
///
pub const ROLE_LISTBOX: u32 = 68;
/// ```text
/// /**
/// * Represents a mathematical equation in the accessible name
/// */
/// ```
///
pub const ROLE_FLAT_EQUATION: u32 = 69;
/// ```text
/// /**
/// * Represents a cell within a grid. It is used for role="gridcell". Unlike
/// * ROLE_CELL, it allows the calculation of the accessible name from subtree.
/// * Also, see ROLE_TABLE.
/// */
/// ```
///
pub const ROLE_GRID_CELL: u32 = 70;
/// ```text
/// /**
/// * A note. Originally intended to be hidden until activated, but now also used
/// * for things like html 'aside'.
/// */
/// ```
///
pub const ROLE_NOTE: u32 = 71;
/// ```text
/// /**
/// * A figure. Used for things like HTML5 figure element.
/// */
/// ```
///
pub const ROLE_FIGURE: u32 = 72;
/// ```text
/// /**
/// * Represents a rich item with a check box.
/// */
/// ```
///
pub const ROLE_CHECK_RICH_OPTION: u32 = 73;
/// ```text
/// /**
/// * An HTML definition list <dl>
/// */
/// ```
///
pub const ROLE_DEFINITION_LIST: u32 = 74;
/// ```text
/// /**
/// * An HTML definition term <dt>
/// */
/// ```
///
pub const ROLE_TERM: u32 = 75;
/// ```text
/// /**
/// * An HTML definition <dd>
/// */
/// ```
///
pub const ROLE_DEFINITION: u32 = 76;
/// ```text
/// /**
/// * A keyboard or keypad key.
/// */
/// ```
///
pub const ROLE_KEY: u32 = 77;
/// ```text
/// /**
/// * A switch control widget.
/// */
/// ```
///
pub const ROLE_SWITCH: u32 = 78;
/// ```text
/// /**
/// * A block of MathML code (math).
/// */
/// ```
///
pub const ROLE_MATHML_MATH: u32 = 79;
/// ```text
/// /**
/// * A MathML identifier (mi in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_IDENTIFIER: u32 = 80;
/// ```text
/// /**
/// * A MathML number (mn in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_NUMBER: u32 = 81;
/// ```text
/// /**
/// * A MathML operator (mo in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_OPERATOR: u32 = 82;
/// ```text
/// /**
/// * A MathML text (mtext in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_TEXT: u32 = 83;
/// ```text
/// /**
/// * A MathML string literal (ms in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STRING_LITERAL: u32 = 84;
/// ```text
/// /**
/// * A MathML glyph (mglyph in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_GLYPH: u32 = 85;
/// ```text
/// /**
/// * A MathML row (mrow in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_ROW: u32 = 86;
/// ```text
/// /**
/// * A MathML fraction (mfrac in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_FRACTION: u32 = 87;
/// ```text
/// /**
/// * A MathML square root (msqrt in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_SQUARE_ROOT: u32 = 88;
/// ```text
/// /**
/// * A MathML root (mroot in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_ROOT: u32 = 89;
/// ```text
/// /**
/// * A MathML enclosed element (menclose in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_ENCLOSED: u32 = 90;
/// ```text
/// /**
/// * A MathML styling element (mstyle in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STYLE: u32 = 91;
/// ```text
/// /**
/// * A MathML subscript (msub in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_SUB: u32 = 92;
/// ```text
/// /**
/// * A MathML superscript (msup in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_SUP: u32 = 93;
/// ```text
/// /**
/// * A MathML subscript and superscript (msubsup in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_SUB_SUP: u32 = 94;
/// ```text
/// /**
/// * A MathML underscript (munder in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_UNDER: u32 = 95;
/// ```text
/// /**
/// * A MathML overscript (mover in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_OVER: u32 = 96;
/// ```text
/// /**
/// * A MathML underscript and overscript (munderover in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_UNDER_OVER: u32 = 97;
/// ```text
/// /**
/// * A MathML multiple subscript and superscript element (mmultiscripts in
/// * MathML).
/// */
/// ```
///
pub const ROLE_MATHML_MULTISCRIPTS: u32 = 98;
/// ```text
/// /**
/// * A MathML table (mtable in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_TABLE: u32 = 99;
/// ```text
/// /**
/// * A MathML labelled table row (mlabeledtr in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_LABELED_ROW: u32 = 100;
/// ```text
/// /**
/// * A MathML table row (mtr in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_TABLE_ROW: u32 = 101;
/// ```text
/// /**
/// * A MathML table entry or cell (mtd in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_CELL: u32 = 102;
/// ```text
/// /**
/// * A MathML interactive element (maction in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_ACTION: u32 = 103;
/// ```text
/// /**
/// * A MathML error message (merror in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_ERROR: u32 = 104;
/// ```text
/// /**
/// * A MathML stacked (rows of numbers) element (mstack in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK: u32 = 105;
/// ```text
/// /**
/// * A MathML long division element (mlongdiv in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_LONG_DIVISION: u32 = 106;
/// ```text
/// /**
/// * A MathML stack group (msgroup in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK_GROUP: u32 = 107;
/// ```text
/// /**
/// * A MathML stack row (msrow in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK_ROW: u32 = 108;
/// ```text
/// /**
/// * MathML carries, borrows, or crossouts for a row (mscarries in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK_CARRIES: u32 = 109;
/// ```text
/// /**
/// * A MathML carry, borrow, or crossout for a column (mscarry in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK_CARRY: u32 = 110;
/// ```text
/// /**
/// * A MathML line in a stack (msline in MathML).
/// */
/// ```
///
pub const ROLE_MATHML_STACK_LINE: u32 = 111;
/// ```text
/// /**
/// * A group containing radio buttons
/// */
/// ```
///
pub const ROLE_RADIO_GROUP: u32 = 112;
/// ```text
/// /**
/// * A text container exposing brief amount of information. See related
/// * TEXT_CONTAINER role.
/// */
/// ```
///
pub const ROLE_TEXT: u32 = 113;
/// ```text
/// /**
/// * A text container exposing brief amount of information. See related
/// * DETAILS role.
/// */
/// ```
///
pub const ROLE_DETAILS: u32 = 114;
/// ```text
/// /**
/// * A text container exposing brief amount of information. See related
/// * SUMMARY role.
/// */
/// ```
///
pub const ROLE_SUMMARY: u32 = 115;
/// ```text
/// /**
/// * An ARIA landmark. See related NAVIGATION role.
/// */
/// ```
///
pub const ROLE_LANDMARK: u32 = 116;
/// ```text
/// /**
/// * A specific type of ARIA landmark. The ability to distinguish navigation
/// * landmarks from other types of landmarks is needed because macOS has a
/// * specific AXSubrole and AXRoleDescription for navigation landmarks.
/// */
/// ```
///
pub const ROLE_NAVIGATION: u32 = 117;
/// ```text
/// /**
/// * An object that contains the text of a footnote.
/// */
/// ```
///
pub const ROLE_FOOTNOTE: u32 = 118;
/// ```text
/// /**
/// * A complete or self-contained composition in a document, page, application,
/// * or site and that is, in principle, independently distributable or reusable,
/// * e.g. in syndication.
/// */
/// ```
///
pub const ROLE_ARTICLE: u32 = 119;
/// ```text
/// /**
/// * A perceivable section containing content that is relevant to a specific,
/// * author-specified purpose and sufficiently important that users will likely
/// * want to be able to navigate to the section easily and to have it listed in
/// * a summary of the page.
/// */
/// ```
///
pub const ROLE_REGION: u32 = 120;
/// ```text
/// /**
/// * Represents a control with a text input and a popup with a set of predefined
/// * choices. It is used for ARIA's combobox role. See also ROLE_COMBOBOX.
/// */
/// ```
///
pub const ROLE_EDITCOMBOBOX: u32 = 121;
/// ```text
/// /**
/// * A section of content that is quoted from another source.
/// */
/// ```
///
pub const ROLE_BLOCKQUOTE: u32 = 122;
/// ```text
/// /**
/// * Content previously deleted or proposed for deletion, e.g. in revision
/// * history or a content view providing suggestions from reviewers.
/// */
/// ```
///
pub const ROLE_CONTENT_DELETION: u32 = 123;
/// ```text
/// /**
/// * Content previously inserted or proposed for insertion, e.g. in revision
/// * history or a content view providing suggestions from reviewers.
/// */
/// ```
///
pub const ROLE_CONTENT_INSERTION: u32 = 124;
/// ```text
/// /**
/// * An html:form element with a label provided by WAI-ARIA.
/// * This may also be used if role="form" with a label should be exposed
/// * differently in the future.
/// */
/// ```
///
pub const ROLE_FORM_LANDMARK: u32 = 125;
/// ```text
/// /**
/// * The html:mark element.
/// * May also be used if WAI-ARIA gets an equivalent role.
/// */
/// ```
///
pub const ROLE_MARK: u32 = 126;
/// ```text
/// /**
/// * The WAI-ARIA suggestion role.
/// */
/// ```
///
pub const ROLE_SUGGESTION: u32 = 127;
/// ```text
/// /**
/// * The WAI-ARIA comment role.
/// */
/// ```
///
pub const ROLE_COMMENT: u32 = 128;
/// ```text
/// /**
/// * A snippet of program code. ATs might want to treat this differently.
/// */
/// ```
///
pub const ROLE_CODE: u32 = 129;
/// ```text
/// /**
/// * Represents control whose purpose is to allow a user to edit a time.
/// */
/// ```
///
pub const ROLE_TIME_EDITOR: u32 = 130;
/// ```text
/// /**
/// * Represents the marker associated with a list item. In unordered lists,
/// * this is a bullet, while in ordered lists this is a number.
/// */
/// ```
///
pub const ROLE_LISTITEM_MARKER: u32 = 131;
/// ```text
/// /**
/// * Essentially, this is a progress bar with a contextually defined
/// * scale, ex. the strength of a password entered in an input.
/// */
/// ```
///
pub const ROLE_METER: u32 = 132;
/// ```text
/// /**
/// * Represents phrasing content that is presented with vertical alignment
/// * lower than the baseline and a smaller font size. For example, the "2" in
/// * the chemical formula H2O.
/// */
/// ```
///
pub const ROLE_SUBSCRIPT: u32 = 133;
/// ```text
/// /**
/// * Represents phrasing content that is presented with vertical alignment
/// * higher than the baseline and a smaller font size. For example, the
/// * exponent in a math expression.
/// */
/// ```
///
pub const ROLE_SUPERSCRIPT: u32 = 134;
/// ```text
/// /**
/// * Represents one or more emphasized characters. Use this role to stress or
/// * emphasize content.
/// */
/// ```
///
pub const ROLE_EMPHASIS: u32 = 135;
/// ```text
/// /**
/// * Represents content that is important, serious, or urgent.
/// */
/// ```
///
pub const ROLE_STRONG: u32 = 136;
/// ```text
/// /**
/// * Represents a specific point in time.
/// */
/// ```
///
pub const ROLE_TIME: u32 = 137;
/// ```text
/// /**
/// * Represents a composite widget containing a collection of one or more rows
/// * with one or more cells where some or all cells in the grid are focusable
/// * by using methods of two-dimensional navigation.
/// */
/// ```
///
pub const ROLE_GRID: u32 = 138;
/// ```text
/// /**
/// * Represents a structure containing one or more row elements in a tabular
/// * container. It is the structural equivalent to the thead, tfoot, and tbody
/// * elements in an HTML table element.
/// */
/// ```
///
pub const ROLE_ROWGROUP: u32 = 139;
}