| /************************************************************************* |
| * |
| * File Name (api_all_headers.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2013 Linux Foundation |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| import "objidl.idl"; |
| import "oaidl.idl"; |
| import "oleacc.idl"; |
| |
| /************************************************************************* |
| * |
| * File Name (IA2CommonTypes.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| /** These constants control the scrolling of an object or substring into a window. |
| |
| This enum is used in IAccessible2::scrollTo and IAccessibleText::scrollSubstringTo. |
| */ |
| enum IA2ScrollType { |
| |
| /** Scroll the top left corner of the object or substring such that the top left |
| corner (and as much as possible of the rest of the object or substring) is within |
| the top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_TOP_LEFT, |
| |
| /** Scroll the bottom right corner of the object or substring such that the bottom right |
| corner (and as much as possible of the rest of the object or substring) is within |
| the top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_BOTTOM_RIGHT, |
| |
| /** Scroll the top edge of the object or substring such that the top edge |
| (and as much as possible of the rest of the object or substring) is within the |
| top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_TOP_EDGE, |
| |
| /** Scroll the bottom edge of the object or substring such that the bottom edge |
| (and as much as possible of the rest of the object or substring) is within the |
| top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_BOTTOM_EDGE, |
| |
| /** Scroll the left edge of the object or substring such that the left edge |
| (and as much as possible of the rest of the object or substring) is within the |
| top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_LEFT_EDGE, |
| |
| /** Scroll the right edge of the object or substring such that the right edge |
| (and as much as possible of the rest of the object or substring) is within the |
| top level window. In cases where the entire object or substring fits within |
| the top level window, the placement of the object or substring is dependent on |
| the application. For example, the object or substring may be scrolled to the |
| closest edge, the furthest edge, or midway between those two edges. In cases |
| where there is a hierarchy of nested scrollable controls, more than one control |
| may have to be scrolled. |
| */ |
| IA2_SCROLL_TYPE_RIGHT_EDGE, |
| |
| /** Scroll the object or substring such that as much as possible of the |
| object or substring is within the top level window. The placement of |
| the object is dependent on the application. For example, the object or |
| substring may be scrolled to to closest edge, the furthest edge, or midway |
| between those two edges. |
| */ |
| IA2_SCROLL_TYPE_ANYWHERE |
| }; |
| |
| /** These constants define which coordinate system a point is located in. |
| |
| This enum is used in IAccessible2::scrollToPoint, IAccessibleImage::imagePosition, |
| IAccessibleText::characterExtents, and IAccessibleText::offsetAtPoint, and |
| IAccessibleText::scrollSubstringToPoint. |
| */ |
| enum IA2CoordinateType { |
| |
| /// The coordinates are relative to the screen. |
| IA2_COORDTYPE_SCREEN_RELATIVE, |
| |
| /** The coordinates are relative to the upper left corner of the bounding box |
| of the immediate parent. |
| */ |
| IA2_COORDTYPE_PARENT_RELATIVE |
| |
| }; |
| |
| /** Special offsets for use in IAccessibleText and IAccessibleEditableText methods |
| |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for more information. |
| */ |
| enum IA2TextSpecialOffsets { |
| IA2_TEXT_OFFSET_LENGTH = -1, /**< This offset is equivalent to the length of the string. It eliminates |
| the need to call IAccessibleText::nCharacters. */ |
| IA2_TEXT_OFFSET_CARET = -2 /**< This offset signifies that the text related to the physical location |
| of the caret should be used. */ |
| }; |
| |
| /** These constants specify the kind of change made to a table. |
| |
| This enum is used in the IA2TableModelChange struct which in turn is used by |
| IAccessibleTable::modelChange and IAccessibleTable2::modelChange. |
| */ |
| enum IA2TableModelChangeType { |
| IA2_TABLE_MODEL_CHANGE_INSERT, // = 0; |
| IA2_TABLE_MODEL_CHANGE_DELETE, |
| IA2_TABLE_MODEL_CHANGE_UPDATE |
| }; |
| |
| /** A structure defining the type of and extents of changes made to a table |
| |
| IAccessibleTable::modelChange and IAccessibleTable2::modelChange return this struct. |
| In the case of an insertion or change the row and column offsets define the boundaries |
| of the inserted or changed subtable after the operation. In the case of a deletion |
| the row and column offsets define the boundaries of the subtable being removed before |
| the removal. |
| */ |
| typedef struct IA2TableModelChange { |
| enum IA2TableModelChangeType type; // insert, delete, update |
| long firstRow; ///< 0 based, inclusive |
| long lastRow; ///< 0 based, inclusive |
| long firstColumn; ///< 0 based, inclusive |
| long lastColumn; ///< 0 based, inclusive |
| } IA2TableModelChange; |
| /************************************************************************* |
| * |
| * File Name (AccessibleRelation.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| /** @defgroup grpRelations Relations |
| Use the following constants to compare against the BSTRs returned by |
| IAccessibleRelation::relationType. |
| */ |
| ///@{ |
| |
| /** The target object is the containing application object. */ |
| const WCHAR *const IA2_RELATION_CONTAINING_APPLICATION = L"containingApplication"; |
| |
| /** The target object is the containing document object. The target object implements |
| the IAccessibleDocument interface. |
| */ |
| const WCHAR *const IA2_RELATION_CONTAINING_DOCUMENT = L"containingDocument"; |
| |
| /** The target object is the containing tab pane object. */ |
| const WCHAR *const IA2_RELATION_CONTAINING_TAB_PANE = L"containingTabPane"; |
| |
| /** The target object is the containing window object. */ |
| const WCHAR *const IA2_RELATION_CONTAINING_WINDOW = L"containingWindow"; |
| |
| /** Some attribute of this object is affected by a target object. */ |
| const WCHAR *const IA2_RELATION_CONTROLLED_BY = L"controlledBy"; |
| |
| /** This object is interactive and controls some attribute of a target object. */ |
| const WCHAR *const IA2_RELATION_CONTROLLER_FOR = L"controllerFor"; |
| |
| /** This object is described by the target object. */ |
| const WCHAR *const IA2_RELATION_DESCRIBED_BY = L"describedBy"; |
| |
| /** This object is describes the target object. */ |
| const WCHAR *const IA2_RELATION_DESCRIPTION_FOR = L"descriptionFor"; |
| |
| /** This object is embedded by a target object. */ |
| const WCHAR *const IA2_RELATION_EMBEDDED_BY = L"embeddedBy"; |
| |
| /** This object embeds a target object. This relation can be used on the |
| OBJID_CLIENT accessible for a top level window to show where the content |
| areas are. |
| */ |
| const WCHAR *const IA2_RELATION_EMBEDS = L"embeds"; |
| |
| /** Content flows to this object from a target object. |
| This relation and IA2_RELATION_FLOWS_TO are useful to tie text and non-text |
| objects together in order to allow assistive technology to follow the |
| intended reading order. |
| */ |
| const WCHAR *const IA2_RELATION_FLOWS_FROM = L"flowsFrom"; |
| |
| /** Content flows from this object to a target object. */ |
| const WCHAR *const IA2_RELATION_FLOWS_TO = L"flowsTo"; |
| |
| /** This object is label for a target object. */ |
| const WCHAR *const IA2_RELATION_LABEL_FOR = L"labelFor"; |
| |
| /** This object is labelled by a target object. Note that the double L spelling |
| which follows is preferred. Please use it instead. This single L version may |
| be removed in a later version. |
| */ |
| const WCHAR *const IA2_RELATION_LABELED_BY = L"labelledBy"; |
| |
| /** This object is labelled by a target object. */ |
| const WCHAR *const IA2_RELATION_LABELLED_BY = L"labelledBy"; |
| |
| /** This object is a member of a group of one or more objects. When |
| there is more than one object in the group each member may have one and the |
| same target, e.g. a grouping object. It is also possible that each member has |
| multiple additional targets, e.g. one for every other member in the group. |
| */ |
| const WCHAR *const IA2_RELATION_MEMBER_OF = L"memberOf"; |
| |
| /** The target object is the next object in the tab order. */ |
| const WCHAR *const IA2_RELATION_NEXT_TABBABLE = L"nextTabbable"; |
| |
| /** This object is a logical child of a target object. This relation is the reciprocal |
| of the IA2_RELATION_NODE_PARENT_OF relation. In some cases an application's accessible |
| tree is such that objects can be in a logical parent-child relationship which is |
| different from the hierarchy of the accessible tree. */ |
| const WCHAR *const IA2_RELATION_NODE_CHILD_OF = L"nodeChildOf"; |
| |
| /** This object is a logical parent of a target object. This relation is the reciprocal |
| of the IA2_RELATION_NODE_CHILD_OF relation. In some cases an application's accessible |
| tree is such that objects can be in a logical parent-child relationship which is |
| different from the hierarchy of the accessible tree. */ |
| const WCHAR *const IA2_RELATION_NODE_PARENT_OF = L"nodeParentOf"; |
| |
| /** This object is a parent window of the target object. */ |
| const WCHAR *const IA2_RELATION_PARENT_WINDOW_OF = L"parentWindowOf"; |
| |
| /** This object is a transient component related to the target object. |
| When this object is activated the target object doesn't lose focus. |
| */ |
| const WCHAR *const IA2_RELATION_POPUP_FOR = L"popupFor"; |
| |
| /** The target object is the previous object in the tab order. */ |
| const WCHAR *const IA2_RELATION_PREVIOUS_TABBABLE = L"previousTabbable"; |
| |
| /** This object is a sub window of a target object. */ |
| const WCHAR *const IA2_RELATION_SUBWINDOW_OF = L"subwindowOf"; |
| |
| ///@} |
| |
| /** This interface gives access to an object's set of relations. |
| */ |
| [object, uuid(7CDF86EE-C3DA-496a-BDA4-281B336E1FDC)] |
| interface IAccessibleRelation : IUnknown |
| { |
| /** @brief Returns the type of the relation. |
| @param [out] relationType |
| The strings returned are defined @ref grpRelations "in this section of the documentation". |
| @retval S_OK |
| */ |
| [propget] HRESULT relationType |
| ( |
| [out, retval] BSTR *relationType |
| ); |
| |
| /** @brief Returns a localized version of the relation type. |
| @param [out] localizedRelationType |
| @retval S_OK |
| */ |
| [propget] HRESULT localizedRelationType |
| ( |
| [out, retval] BSTR *localizedRelationType |
| ); |
| |
| /** @brief Returns the number of targets for this relation. |
| @param [out] nTargets |
| @retval S_OK |
| */ |
| [propget] HRESULT nTargets |
| ( |
| [out, retval] long *nTargets |
| ); |
| |
| /** @brief Returns one accessible relation target. |
| @param [in] targetIndex |
| 0 based index |
| @param [out] target |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Use QueryInterface to get IAccessible2. |
| */ |
| [propget] HRESULT target |
| ( |
| [in] long targetIndex, |
| [out, retval] IUnknown **target |
| ); |
| |
| /** @brief Returns multiple accessible relation targets |
| @param [in] maxTargets |
| maximum size of the array allocated by the client |
| @param [out] targets |
| The array of target objects. Note that this array is to be allocated by the |
| client and freed when no longer needed. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. You will need to use |
| QueryInterface on the IUnknown to get the IAccessible2. |
| @param [out] nTargets |
| actual number of targets in the returned array (not more than maxTargets) |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, e.g. a negative value |
| */ |
| [propget] HRESULT targets |
| ( |
| [in] long maxTargets, |
| [out, size_is(maxTargets), length_is(*nTargets)] |
| IUnknown **targets, |
| [out, retval] long *nTargets |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleAction.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| /** This enum defines values which are predefined actions for use when implementing |
| support for media. |
| |
| This enum is used when specifying an action for IAccessibleAction::doAction. |
| */ |
| |
| enum IA2Actions { |
| IA2_ACTION_OPEN = -1, /**< Used to inform the server that the client will |
| signal via IA2_ACTION_COMPLETE when it has consumed |
| the content provided by the object. This action |
| allows the object's server to wait for all clients |
| to signal their readiness for additional content. |
| Any form of content generation that requires |
| synchronization with an AT would require use of this |
| action. One example is the generation of text describing |
| visual content not obvious from a video's sound track. |
| In this scenario the Text to Speech or Braille output |
| may take more time than the related length of silence |
| in the video's sound track. */ |
| IA2_ACTION_COMPLETE = -2, /**< Used by the client to inform the server that it has |
| consumed the most recent content provided by this object. */ |
| IA2_ACTION_CLOSE = -3 /**< Used to inform the server that the client no longer |
| requires synchronization. */ |
| }; |
| |
| /** @brief This interface gives access to actions that can be executed |
| for accessible objects. |
| |
| Every accessible object that can be manipulated via the native GUI beyond the |
| methods available either in the MSAA IAccessible interface or in the set of |
| IAccessible2 interfaces (other than this IAccessibleAction interface) should |
| support the IAccessibleAction interface in order to provide Assistive Technology |
| access to all the actions that can be performed by the object. Each action can |
| be performed or queried for a name, description or associated key bindings. |
| Actions are needed more for ATs that assist the mobility impaired, such as |
| on-screen keyboards and voice command software. By providing actions directly, |
| the AT can present them to the user without the user having to perform the extra |
| steps to navigate a context menu. |
| |
| The first action should be equivalent to the MSAA default action. If there is |
| only one action, %IAccessibleAction should also be implemented. |
| */ |
| [object, uuid(B70D9F59-3B5A-4dba-AB9E-22012F607DF5)] |
| interface IAccessibleAction : IUnknown |
| { |
| |
| /** @brief Returns the number of accessible actions available in this object. |
| |
| If there are more than one, the first one is considered the |
| "default" action of the object. |
| @param [out] nActions |
| The returned value of the number of actions is zero if there are |
| no actions. |
| @retval S_OK |
| @note This method is missing a [propget] prefix in the IDL. The result is the |
| method is named nActions in generated C++ code instead of get_nActions. |
| */ |
| HRESULT nActions |
| ( |
| [out,retval] long* nActions |
| ); |
| |
| /** @brief Performs the specified Action on the object. |
| @param [in] actionIndex |
| 0 based index specifying the action to perform. If it lies outside |
| the valid range no action is performed. |
| @retval S_OK |
| @retval S_FALSE if action could not be performed |
| @retval E_INVALIDARG if bad [in] passed |
| @note If implementing support for media, refer to the predefined constants in the ::IA2Actions enum. |
| */ |
| HRESULT doAction |
| ( |
| [in] long actionIndex |
| ); |
| |
| /** @brief Returns a description of the specified action of the object. |
| @param [in] actionIndex |
| 0 based index specifying which action's description to return. |
| If it lies outside the valid range an empty string is returned. |
| @param [out] description |
| The returned value is a localized string of the specified action. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT description |
| ( |
| [in] long actionIndex, |
| [out, retval] BSTR *description |
| ); |
| |
| /** @brief Returns an array of BSTRs describing one or more key bindings, if |
| there are any, associated with the specified action. |
| |
| The returned strings are the localized human readable key sequences to be |
| used to activate each action, e.g. "Ctrl+Shift+D". Since these key |
| sequences are to be used when the object has focus, they are like |
| mnemonics (access keys), and not like shortcut (accelerator) keys. |
| |
| There is no need to implement this method for single action controls since |
| that would be redundant with the standard MSAA programming practice of |
| getting the mnemonic from get_accKeyboardShortcut. |
| |
| An AT such as an On Screen Keyboard might not expose these bindings but |
| provide alternative means of activation. |
| |
| Note: the client allocates and passes in an array of pointers. The server |
| allocates the BSTRs and passes back one or more pointers to these BSTRs into |
| the array of pointers allocated by the client. The client is responsible |
| for deallocating the BSTRs. |
| |
| @param [in] actionIndex |
| 0 based index specifying which action's key bindings should be returned. |
| @param [in] nMaxBindings |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] keyBindings |
| An array of BSTRs, allocated by the server, one for each key binding. |
| The client must free it with CoTaskMemFree. |
| @param [out] nBindings |
| The number of key bindings returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are no key bindings, [out] values are NULL and 0 respectively |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT keyBinding |
| ( |
| [in] long actionIndex, |
| [in] long nMaxBindings, |
| [out, size_is(,nMaxBindings), length_is(,*nBindings)] BSTR **keyBindings, |
| [out, retval] long *nBindings |
| ); |
| |
| /** @brief Returns the non-localized name of specified action. |
| @param [in] actionIndex |
| 0 based index specifying which action's non-localized name should be returned. |
| @param [out] name |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT name |
| ( |
| [in] long actionIndex, |
| [out, retval] BSTR *name |
| ); |
| |
| /** @brief Returns the localized name of specified action. |
| @param [in] actionIndex |
| 0 based index specifying which action's localized name should be returned. |
| @param [out] localizedName |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT localizedName |
| ( |
| [in] long actionIndex, |
| [out, retval] BSTR *localizedName |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleRole.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| /** Collection of roles |
| |
| This enumerator defines an extended set of accessible roles of objects implementing |
| the %IAccessible2 interface. These roles are in addition to the MSAA roles obtained |
| through the MSAA get_accRole method. Examples are 'footnote', 'heading', and |
| 'label'. You obtain an object's %IAccessible2 roles by calling IAccessible2::role. |
| */ |
| enum IA2Role { |
| |
| /** Unknown role. The object contains some Accessible information, but its |
| role is not known. |
| */ |
| IA2_ROLE_UNKNOWN = 0, |
| |
| /** An object that can be drawn into and to manage events from the objects |
| drawn into it. Also refer to ::IA2_ROLE_FRAME, |
| ::IA2_ROLE_GLASS_PANE, and ::IA2_ROLE_LAYERED_PANE. |
| */ |
| IA2_ROLE_CANVAS = 0x401, |
| |
| /// A caption describing another object. |
| IA2_ROLE_CAPTION, |
| |
| /// Used for check buttons that are menu items. |
| IA2_ROLE_CHECK_MENU_ITEM, |
| |
| /// A specialized dialog that lets the user choose a color. |
| IA2_ROLE_COLOR_CHOOSER, |
| |
| /// A date editor. |
| IA2_ROLE_DATE_EDITOR, |
| |
| /** An iconified internal frame in an ::IA2_ROLE_DESKTOP_PANE. |
| Also refer to ::IA2_ROLE_INTERNAL_FRAME. |
| */ |
| IA2_ROLE_DESKTOP_ICON, |
| |
| /** A desktop pane. A pane that supports internal frames and iconified |
| versions of those internal frames. Also refer to ::IA2_ROLE_INTERNAL_FRAME. |
| */ |
| IA2_ROLE_DESKTOP_PANE, |
| |
| /** A directory pane. A pane that allows the user to navigate through |
| and select the contents of a directory. May be used by a file chooser. |
| Also refer to ::IA2_ROLE_FILE_CHOOSER. |
| */ |
| IA2_ROLE_DIRECTORY_PANE, |
| |
| /** An editable text object in a toolbar. <b>Deprecated.</b> |
| The edit bar role was meant for a text area in a tool bar. However, to detect |
| a text area in a tool bar the AT can query the parent. |
| */ |
| IA2_ROLE_EDITBAR, |
| |
| /// Embedded (OLE) object. |
| IA2_ROLE_EMBEDDED_OBJECT, |
| |
| /// Text that is used as an endnote (footnote at the end of a chapter or section). |
| IA2_ROLE_ENDNOTE, |
| |
| /** A file chooser. A specialized dialog that displays the files in the |
| directory and lets the user select a file, browse a different directory, |
| or specify a filename. May use the directory pane to show the contents of |
| a directory. |
| Also refer to ::IA2_ROLE_DIRECTORY_PANE. |
| */ |
| IA2_ROLE_FILE_CHOOSER, |
| |
| /** A font chooser. A font chooser is a component that lets the user pick |
| various attributes for fonts. |
| */ |
| IA2_ROLE_FONT_CHOOSER, |
| |
| /** Footer of a document page. |
| Also refer to ::IA2_ROLE_HEADER. |
| */ |
| IA2_ROLE_FOOTER, |
| |
| /// Text that is used as a footnote. Also refer to ::IA2_ROLE_ENDNOTE. |
| IA2_ROLE_FOOTNOTE, |
| |
| /** A container of form controls. An example of the use of this role is to |
| represent an HTML FORM tag. |
| */ |
| IA2_ROLE_FORM, |
| |
| /** 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. Also refer to |
| ::IA2_ROLE_CANVAS and the MSAA roles of dialog and window. |
| */ |
| IA2_ROLE_FRAME, |
| |
| /** A glass pane. A pane that is guaranteed to be painted on top of all panes |
| beneath it. Also refer to ::IA2_ROLE_CANVAS, ::IA2_ROLE_INTERNAL_FRAME, and |
| ::IA2_ROLE_ROOT_PANE. |
| */ |
| IA2_ROLE_GLASS_PANE, |
| |
| /** Header of a document page. |
| Also refer to ::IA2_ROLE_FOOTER. |
| */ |
| IA2_ROLE_HEADER, |
| |
| /// Heading. Use the IAccessible2::attributes level attribute to determine the heading level. |
| IA2_ROLE_HEADING, |
| |
| /// A small fixed size picture, typically used to decorate components. |
| IA2_ROLE_ICON, |
| |
| /** An image map object. Usually a graphic with multiple hotspots, where |
| each hotspot can be activated resulting in the loading of another document |
| or section of a document. |
| */ |
| IA2_ROLE_IMAGE_MAP, |
| |
| /** An object which is used to allow input of characters not found on a keyboard, |
| such as the input of Chinese characters on a Western keyboard. |
| */ |
| IA2_ROLE_INPUT_METHOD_WINDOW, |
| |
| /** An internal frame. A frame-like object that is clipped by a desktop pane. |
| The desktop pane, internal frame, and desktop icon objects are often used to |
| create multiple document interfaces within an application. |
| Also refer to ::IA2_ROLE_DESKTOP_ICON, ::IA2_ROLE_DESKTOP_PANE, and ::IA2_ROLE_FRAME. |
| */ |
| IA2_ROLE_INTERNAL_FRAME, |
| |
| /// An object used to present an icon or short string in an interface. |
| IA2_ROLE_LABEL, |
| |
| /** A layered pane. A specialized pane that allows its children to be drawn |
| in layers, providing a form of stacking order. This is usually the pane that |
| holds the menu bar as well as the pane that contains most of the visual |
| components in a window. |
| Also refer to ::IA2_ROLE_CANVAS, ::IA2_ROLE_GLASS_PANE, and ::IA2_ROLE_ROOT_PANE. |
| */ |
| IA2_ROLE_LAYERED_PANE, |
| |
| /** A section whose content is parenthetic or ancillary to the main content |
| of the resource. |
| */ |
| IA2_ROLE_NOTE, |
| |
| /** A specialized pane whose primary use is inside a dialog. |
| Also refer to MSAA's dialog role. |
| */ |
| IA2_ROLE_OPTION_PANE, |
| |
| /** An object representing a page of document content. It is used in documents |
| which are accessed by the user on a page by page basis. |
| */ |
| IA2_ROLE_PAGE, |
| |
| /// A paragraph of text. |
| IA2_ROLE_PARAGRAPH, |
| |
| /** A radio button that is a menu item. |
| Also refer to MSAA's button and menu item roles. |
| */ |
| IA2_ROLE_RADIO_MENU_ITEM, |
| |
| /** An object which is redundant with another object in the accessible hierarchy. |
| ATs typically ignore objects with this role. |
| */ |
| IA2_ROLE_REDUNDANT_OBJECT, |
| |
| /** A root pane. A specialized pane that has a glass pane and a layered pane |
| as its children. |
| Also refer to ::IA2_ROLE_GLASS_PANE and ::IA2_ROLE_LAYERED_PANE |
| */ |
| IA2_ROLE_ROOT_PANE, |
| |
| /** A ruler such as those used in word processors. |
| */ |
| IA2_ROLE_RULER, |
| |
| /** A scroll pane. An object that allows a user to incrementally view a large |
| amount of information. Its children can include scroll bars and a viewport. |
| Also refer to ::IA2_ROLE_VIEW_PORT and MSAA's scroll bar role. |
| */ |
| IA2_ROLE_SCROLL_PANE, |
| |
| /** A container of document content. An example of the use of this role is to |
| represent an HTML DIV tag. A section may be used as a region. A region is a |
| group of elements that together form a perceivable unit. A region does not |
| necessarily follow the logical structure of the content, but follows the |
| perceivable structure of the page. A region may have an attribute in the set |
| of IAccessible2::attributes which indicates that it is "live". A live region |
| is content that is likely to change in response to a timed change, a user |
| event, or some other programmed logic or event. |
| */ |
| IA2_ROLE_SECTION, |
| |
| /// Object with graphical representation used to represent content on draw pages. |
| IA2_ROLE_SHAPE, |
| |
| /** A split pane. A specialized panel that presents two other panels at the |
| same time. Between the two panels is a divider the user can manipulate to make |
| one panel larger and the other panel smaller. |
| */ |
| IA2_ROLE_SPLIT_PANE, |
| |
| /** An object that forms part of a menu system but which can be "undocked" |
| from or "torn off" the menu system to exist as a separate window. |
| */ |
| IA2_ROLE_TEAR_OFF_MENU, |
| |
| /// An object used as a terminal emulator. |
| IA2_ROLE_TERMINAL, |
| |
| /// Collection of objects that constitute a logical text entity. |
| IA2_ROLE_TEXT_FRAME, |
| |
| /** A toggle button. A specialized push button that can be checked or unchecked, |
| but does not provide a separate indicator for the current state. |
| Also refer to MSAA's roles of push button, check box, and radio button. |
| <BR><B>Note:</B> IA2_ROLE_TOGGLE_BUTTON should not be used. Instead, use MSAA's |
| ROLE_SYSTEM_PUSHBUTTON and STATE_SYSTEM_PRESSED. |
| */ |
| IA2_ROLE_TOGGLE_BUTTON, |
| |
| /** A viewport. An object usually used in a scroll pane. It represents the |
| portion of the entire data that the user can see. As the user manipulates |
| the scroll bars, the contents of the viewport can change. |
| Also refer to ::IA2_ROLE_SCROLL_PANE. |
| */ |
| IA2_ROLE_VIEW_PORT, |
| |
| /** An object containing content which is complementary to the main content of |
| a document, but remains meaningful when separated from the main content. There |
| are various types of content that would appropriately have this role. For example, |
| in the case where content is delivered via a web portal to a web browser, this may |
| include but not be limited to show times, current weather, related articles, or |
| stocks to watch. The complementary role indicates that contained content is relevant |
| to the main content. If the complementary content is completely separable main |
| content, it may be appropriate to use a more general role. |
| */ |
| IA2_ROLE_COMPLEMENTARY_CONTENT |
| |
| }; |
| /************************************************************************* |
| * |
| * File Name (AccessibleStates.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| typedef long AccessibleStates; |
| |
| /** %IAccessible2 specific state bit constants |
| |
| This enum defines the state bits returned by IAccessible2::states. The |
| %IAccessible2 state bits are in addition to those returned by MSAA. |
| */ |
| enum IA2States { |
| |
| /** Indicates a window is currently the active window, or is an active subelement |
| within a container or table. |
| |
| This state can be used to indicate the current active item in a container, even |
| if the container itself is not currently active. In other words this would indicate |
| the item that will get focus if you tab to the container. |
| |
| This information is important for knowing what to report for trees and potentially |
| other containers in a virtual buffer. |
| |
| Also, see ::IA2_STATE_MANAGES_DESCENDANTS for more information. |
| */ |
| IA2_STATE_ACTIVE = 0x1, |
| |
| /** Indicates that the object is armed. |
| |
| Used to indicate that the control is "pressed" and will be invoked when the |
| actuator, e.g. a mouse button, is "released". An AT which either monitors the |
| mouse or synthesizes mouse events might need to know that, and possibly a talking |
| interface would even let the user know about it. It could also potentially be |
| useful to on screen keyboards or test tools since the information does indicate |
| something about the state of the interface, for example, code operating asynchronously |
| might need to wait for the armed state to change before doing something else. |
| |
| */ |
| IA2_STATE_ARMED = 0x2, |
| |
| /** Indicates the user interface object corresponding to this object no longer exists. */ |
| IA2_STATE_DEFUNCT = 0x4, |
| |
| /** An object with this state has a caret and implements the IAccessibleText interface. |
| |
| Such fields may be read-only, so STATE_SYSTEM_READONLY is valid in combination |
| with IA2_STATE_EDITABLE. |
| |
| */ |
| IA2_STATE_EDITABLE = 0x8, |
| |
| /** Indicates the orientation of this object is horizontal. */ |
| IA2_STATE_HORIZONTAL = 0x10, |
| |
| /** Indicates this object is minimized and is represented only by an icon. */ |
| IA2_STATE_ICONIFIED = 0x20, |
| |
| /** Indicates an input validation failure. */ |
| IA2_STATE_INVALID_ENTRY = 0x40, |
| |
| /** Indicates that this object manages its children. |
| |
| Note: Due to the fact that MSAA's WinEvents don't allow the active child index |
| to be passed on the IA2_EVENT_ACTIVE_DESCENDANT_CHANGED event, the manages |
| descendants scheme can't be used. Instead the active child object has to fire |
| MSAA's EVENT_OBJECT_FOCUS. In a future release a new event mechanism may be |
| added to provide for event specific data to be passed with the event. At that |
| time the IA2_EVENT_ACTIVE_DECENDENT_CHANGED event and |
| IA2_STATE_MANAGES_DESCENDANTS state would be useful. |
| */ |
| IA2_STATE_MANAGES_DESCENDANTS = 0x80, |
| |
| /** Indicates that an object is modal. |
| |
| Modal objects have the behavior that something must be done with the object |
| before the user can interact with an object in a different window. |
| */ |
| IA2_STATE_MODAL = 0x100, |
| |
| /** Indicates this text object can contain multiple lines of text. */ |
| IA2_STATE_MULTI_LINE = 0x200, |
| |
| /** Indicates this object paints every pixel within its rectangular region. */ |
| IA2_STATE_OPAQUE = 0x400, |
| |
| /** Indicates that user interaction is required. |
| |
| An example of when this state is used is when a field in a form must be filled |
| before a form can be processed. |
| */ |
| IA2_STATE_REQUIRED = 0x800, |
| |
| /** Indicates an object which supports text selection. |
| |
| Note: This is different than MSAA STATE_SYSTEM_SELECTABLE. |
| */ |
| IA2_STATE_SELECTABLE_TEXT = 0x1000, |
| |
| /** Indicates that this text object can contain only a single line of text. */ |
| IA2_STATE_SINGLE_LINE = 0x2000, |
| |
| /** Indicates that the accessible object is stale. |
| |
| This state is used when the accessible object no longer accurately |
| represents the state of the object which it is representing such as when an |
| object is transient or when an object has been or is in the process of being |
| destroyed or when the object's index in its parent has changed. |
| */ |
| IA2_STATE_STALE = 0x4000, |
| |
| /** Indicates that the object implements autocompletion. |
| |
| This state indicates that a text control will respond to the input of |
| one ore more characters and cause a sub-item to become selected. The |
| selection may also result in events fired on the parent object. |
| */ |
| IA2_STATE_SUPPORTS_AUTOCOMPLETION = 0x8000, |
| |
| /** Indicates this object is transient. |
| |
| An object has this state when its parent object has the state ::IA2_STATE_MANAGES_DESCENDANTS. |
| For example, a list item object may be managed by its parent list object and may only |
| exist as long as the object is actually rendered. Similarly a table cell's accessible |
| object may exist only while the cell has focus. However, from the perspective of an |
| assistive technology a transient object behaves like a non-transient object. As a |
| result it is likely that this state is not of use to an assistive technology, but it |
| is provided in case an assistive technology determines that knowledge of the transient |
| nature of the object is useful and also for harmony with the Linux accessibility API. |
| |
| Also, see ::IA2_STATE_MANAGES_DESCENDANTS for more information. |
| */ |
| IA2_STATE_TRANSIENT = 0x10000, |
| |
| /** Indicates the orientation of this object is vertical. */ |
| IA2_STATE_VERTICAL = 0x20000, |
| |
| /** Indicates this object is checkable. |
| |
| The standard checkable objects are check boxes, radio buttons, check box menu |
| items, radio menu items, and toggle buttons. Since assistive technology will |
| determine that these objects are checkable via the object's role the checkable |
| state is not required. However, this state is necessary in those cases where |
| an object has a role which is not one of the previously mentioned roles. An |
| example is a table cell which indicates whether or not an email has an attachment, |
| whether or not an mail is considered spam, and whether or not an email has been read. |
| */ |
| IA2_STATE_CHECKABLE = 0x40000, |
| |
| /** Indicates this object is pinned. |
| |
| This state indicates that an object is fixed at a certain location. One example |
| is a browser tab that when pinned cannot be moved until unpinned. Another example |
| is a movable or floating object that when pinned remains in its pinned location |
| until being unpinned. |
| */ |
| IA2_STATE_PINNED = 0x80000 |
| |
| }; |
| /************************************************************************* |
| * |
| * File Name (Accessible2.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| /** @mainpage |
| |
| @section _interfaces Interfaces |
| IAccessible2\n |
| IAccessible2_2\n |
| IAccessibleAction\n |
| IAccessibleApplication\n |
| IAccessibleComponent\n |
| IAccessibleDocument\n |
| IAccessibleEditableText\n |
| IAccessibleHypertext\n |
| IAccessibleHypertext2\n |
| IAccessibleHyperlink\n |
| IAccessibleImage\n |
| IAccessibleRelation\n |
| IAccessibleTable [Deprecated]\n |
| IAccessibleTable2\n |
| IAccessibleTableCell\n |
| IAccessibleText\n |
| IAccessibleText2\n |
| IAccessibleValue |
| |
| @section _structs Structs |
| IA2Locale\n |
| IA2TableModelChange\n |
| IA2TextSegment |
| |
| @section _enums Enums |
| ::IA2Actions values are predefined actions for use when implementing support for HTML5 media.\n |
| ::IA2CoordinateType values define the requested coordinate type (screen or parent window).\n |
| ::IA2EventID values identify events.\n |
| ::IA2Role values defines roles which are in addition to the existing MSAA roles.\n |
| ::IA2ScrollType values define where to place an object or substring on the screen.\n |
| ::IA2States values define states which are in addition to the existing MSAA states.\n |
| ::IA2TableModelChangeType values describe the kinds of changes made to a table (insert, delete, update).\n |
| ::IA2TextBoundaryType values define the requested text unit (character, word, sentence, line, paragraph).\n |
| ::IA2TextSpecialOffsets values define special offsets for use in the text interfaces. |
| |
| @section _constants Constants |
| @ref grpRelations |
| |
| @section _misc Miscellaneous |
| @ref _licensePage "BSD License"\n |
| @ref _generalInfo "General Information"\n |
| |
| @page _licensePage BSD License |
| %IAccessible2 IDL Specification |
| |
| Copyright (c) 2007, 2013 Linux Foundation\n |
| Copyright (c) 2006 IBM Corporation\n |
| Copyright (c) 2000, 2006 Sun Microsystems, Inc.\n |
| All rights reserved. |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| 1. Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| |
| 2. Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the following |
| disclaimer in the documentation and/or other materials |
| provided with the distribution. |
| |
| 3. Neither the name of the Linux Foundation nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior written |
| permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| This BSD License conforms to the Open Source Initiative "Simplified |
| BSD License" as published at: |
| http://www.opensource.org/licenses/bsd-license.php |
| |
| %IAccessible2 is a trademark of the Linux Foundation. The %IAccessible2 |
| mark may be used in accordance with the |
| <a href="http://www.linuxfoundation.org/collaborate/workgroups/accessibility/trademark-policy"> |
| Linux Foundation Trademark Policy</a> to indicate compliance with the %IAccessible2 specification. |
| |
| @page _generalInfo General Information |
| The following information is applicable to two or more interfaces. |
| |
| @ref _errors\n |
| @ref _memory\n |
| @ref _arrayConsideration\n |
| @ref _indexes\n |
| @ref _enumBase\n |
| @ref _specialOffsets\n |
| @ref _dicoveringInterfaces\n |
| @ref _changingInterfaces\n |
| @ref _applicationInfo\n |
| @ref _childIDs\n |
| @ref _variants\n |
| @ref _iaaction-iahyperlink\n |
| @ref _trademark |
| |
| @section _errors Error Handling |
| HRESULT values are defined by the Microsoft® Win32® API. For more information, refer to |
| <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/aa378137%28v=vs.85%29.aspx"> |
| Interpreting HRESULT Values</a> in MSDN®. |
| |
| Note that the S_FALSE return value is considered a non-error value and the |
| SUCCEEDED macro will return TRUE. S_FALSE is used when there is no failure |
| but there was nothing valid to return, e.g. in IAccessible2::attributes when |
| there are no attributes. When S_FALSE is returned [out] pointer types should |
| be NULL and [out] longs should generally be 0, but sometimes -1 is used such |
| as IAccessible2::indexInParent, IAccessibleText::caretOffset, and |
| IAccessibleHypertext::hyperlinkIndex. |
| |
| Note that for BSTR [out] variables common COM practice is that the server does |
| the SysAllocString and the client does the SysFreeString. Also note that when |
| NULL is returned there is no need for the client to call SysFreeString. Please |
| refer to the documentation for each method for more details regarding error handling. |
| |
| @section _memory Memory Management |
| The following memory management issues should be considered: |
| @li Although [out] BSTR variables are declared by the client, their space is |
| allocated by the server. They need to be freed with SysFreeString by the |
| client at end of life; the same is true when BSTRs are used in structs or |
| arrays which are passed to the server. |
| @li If there is no valid [out] BSTR to return, the server should return S_FALSE and |
| assign NULL to the output, e.g. *theOutBSTR = NULL;. |
| @li COM interfaces need to be referenced with AddRef when used and dereferenced |
| with Release at end of life. |
| @li Single [out] longs, HWNDs, booleans, and structs are declared by the caller |
| and passed by reference. The marshaller does all the memory management. |
| |
| The following articles may be helpful for understanding memory management issues: |
| @li An article by Don Box in a |
| <a href="http://www.microsoft.com/msj/1196/activex1196.aspx">Q & A section</a> |
| of the November 1996 edition of the Microsoft Systems Journal. |
| @li A posting to a CodeGuru forum, |
| <a href="http://www.codeguru.com/forum/showthread.php?t=364511">Windows SDK |
| String: What are the rules for BSTR allocation and deallocation?</a> |
| |
| @subsection _arrayConsideration Special Consideration when using Arrays |
| There are several methods which return arrays. In the case of IAccessible2::relations |
| and IAccessibleRelation::targets the client must allocate and free the arrays. |
| |
| For the remaining methods which return arrays, the server must allocate the array |
| and the client must free the array when no longer needed. These methods are |
| IAccessible2::extendedStates, IAccessible2::localizedExtendedStates, |
| IAccessible2_2::relationTargetsOfType, IAccessibleAction::keyBinding, |
| IAccessibleHypertext2::hyperlinks, IAccessibleTable::selectedChildren, |
| IAccessibleTable::selectedColumns, IAccessibleTable::selectedRows, |
| IAccessibleTable2::selectedCells, IAccessibleTable2::selectedColumns, |
| IAccessibleTable2::selectedRows, IAccessibleTableCell::columnHeaderCells, |
| and IAccessibleTableCell::rowHeaderCells. |
| For those methods, the server must allocate both the top level array and any storage |
| associated with it, e.g. for BSTRs. The server must allocate the arrays with |
| CoTaskMemAlloc and any BSTRs with SysAllocString. The client must use CoTaskMemFree |
| to free the array and any BSTRs must be freed with SysFreeString. |
| |
| Also, the IDL for IAccessible2::extendedStates, IAccessible2::localizedExtendedStates, |
| IAccessibleAction::keyBinding, IAccessibleTable::selectedChildren, |
| IAccessibleTable::selectedColumns, and IAccessibleTable::selectedRows includes an |
| extraneous [in] parameter for the caller to specify the max size of the array. |
| This parameter will be ignored by the COM server. |
| |
| @section _indexes Zero and One Based Indexes |
| Unless otherwise specified all offsets and indexes are 0 based. |
| |
| @section _enumBase Enum Base |
| Note that enums start at 0. |
| |
| @section _specialOffsets Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods |
| IAccessibleText and IAccessibleEditableText can use one or more of the following |
| special offset values. They are defined in the ::IA2TextSpecialOffsets enum. |
| @li Using ::IA2_TEXT_OFFSET_LENGTH (-1) as an offset in any of the IAccessibleText or |
| IAccessibleEditableText methods is the same as specifying the length of the string. |
| @li Using ::IA2_TEXT_OFFSET_CARET (-2) as an offset for IAccessibleText::textBeforeOffset, |
| IAccessibleText::textAtOffset, and IAccessibleText::textAfterOffset indicates that the |
| text related to the physical location of the caret should be used. This is needed for |
| applications that consider the character offset of the end of one line (as reached by |
| pressing the End key) the same as the offset of the first character on the next line. |
| Since the same offset is associated with two different lines a special means is needed |
| to fetch text from the line where the caret is physically located. |
| |
| @section _dicoveringInterfaces Discovery of Interfaces |
| In general AT (Assistive Technology) should try IAccessible2 interfaces, followed by using |
| the MSAA (Microsoft® Active Accessibility®) interfaces. (In cases where the an application |
| is known to have custom interfaces which provide information not supplied by IAccessible2 |
| or MSAA, then those custom interfaces can be used.) The AT can then, by default, support |
| unknown IAccessible2/MSAA applications, without the application developers having to request |
| AT vendors for support on an individual application by application basis. |
| |
| When you have a reference to an IAccessible and require a reference to an IAccessible2 use |
| QueryService as follows: |
| @code |
| // pAcc is a reference to the accessible object's IAccessible interface. |
| IServiceProvider *pService = NULL; |
| hr = pAcc->QueryInterface(IID_IServiceProvider, (void **)&pService); |
| if(SUCCEEDED(hr)) { |
| IAccessible2 *pIA2 = NULL; |
| hr = pService->QueryService(IID_IAccessible, IID_IAccessible2, (void**)&pIA2); |
| if (SUCCEEDED(hr) && pIA2) { |
| // The control supports IAccessible2. |
| // pIA2 is the reference to the accessible object's IAccessible2 interface. |
| } |
| } |
| @endcode |
| |
| @section _changingInterfaces Changing between Accessible Interfaces |
| Note that developers must always implement MSAA's IAccessible and, if needed, some |
| of the interfaces in the set of IAccessible2 interfaces. Although the IAccessible2 |
| IDL is coded such that IAccessible2 is a subclass of MSAA's IAccessible, none of |
| MSAA's IAccessible methods are redefined by IAccessible2. |
| |
| QueryService must be used to switch from a reference to an MSAA IAccessible interface |
| to another interface. This has been |
| <a href="http://www.atia.org/files/public/Introducing_IAccessibleEx.doc"> |
| documented</a> and the pertinent facts have been extracted below: |
| |
| @par |
| Why use QueryService instead of just using QueryInterface to get IAccessibleEx |
| directly? The reason is that since MSAA 2.0, clients don't talk to a server's |
| IAccessible interface directly; instead they talk to an intermediate MSAA-provided |
| wrapper that calls through to the original IAccessible. This wrapper provides services |
| such as implementing IDispatch, supplying information from MSAA 2.0's Dynamic Annotation |
| service, and scaling locations when running on Windows Vista with DPI scaling enabled. |
| QueryService is the supported way to expose additional interfaces from an existing |
| IAccessible and was originally used by MSHTML to expose IHTMLElement objects corresponding |
| to IAccessibles. QueryService is often more convenient for servers to implement than |
| QueryInterface because it does not have the same requirements for preserving object |
| identity or symmetry/transitivity as QueryInterface, so QueryService allows servers to |
| easily implement the interface on the same object or a separate object. The latter is |
| often hard to do with QueryInterface unless the original object supports aggregation. |
| |
| Two related references in MSDN® are: |
| @li <a href="http://msdn.microsoft.com/en-us/library/ms696078(VS.85).aspx"> |
| "Using QueryService to expose a native object model interface for an IAccessible object"</a> |
| @li <a href="http://msdn.microsoft.com/en-us/library/ms528415.aspx#acc_obj"> |
| "Accessing the Internet Explorer Object Associated with an Accessible Object"</a> |
| |
| Based on this information from Microsoft, QueryService must be used to switch back and forth |
| between a reference to an MSAA IAccessible interface and any of the IAccessible2 interfaces. |
| |
| Regarding switching between any of the IAccessible2 interfaces, applications implementing |
| IAccessible2 should implement the IAccessible2 interfaces on a single object since ATs |
| will be using QueryInterface to switch between the IAccessilbe2 interfaces. Implementing |
| the IAccessible2 interfaces on separate objects would require the use of QueryService. |
| There is one exception, IAccessibleApplication can be implemented on a separate object so |
| its common code doesn't have to be included in each accessible object. ATs should use |
| QueryService to access IAccessibleApplication. |
| |
| @section _applicationInfo Access to Information about the Application |
| Servers implementing IAccessible2 should provide access to the IAccessibleApplication |
| interface via QueryService from any object so that ATs can easily determine specific |
| information about the application such as its name or version. |
| |
| @section _childIDs Child IDs |
| The IAccessible2 interfaces do not support child IDs, i.e. simple child elements. |
| Full accessible objects must be created for each object that supports IAccessible2. |
| Therefore MSAA's get_accChild should never return a child ID (other than CHILDID_SELF) |
| for an object that implements any of the IAccessible2 interfaces. |
| |
| Microsoft's UI Automation specification has the same limitation and this was resolved |
| in the UI Automation Express specification by adding IAccessibleEx::GetObjectForChild |
| and IAccessibleEx::GetIAccessiblePair. These methods allow mapping back and forth |
| between an IAccessibleEx and an {IAccessible, Child ID} pair. A future version of |
| IAccessible2 may include similar methods to map back and forth between an IAccessible2 |
| and an {IAccessible, Child ID} pair. |
| |
| @section _variants VARIANTs |
| Some methods return a VARIANT. Implementers need to make sure that the return type is |
| specified, i.e. VT_I4, VT_IDISPATCH, etc. The methods that return VARIANTs are |
| IAccessibleHyperlink::anchor, IAccessibleHyperlink::anchorTarget, IAccessibleValue::currentValue, |
| IAccessibleValue::maximumValue, IAccessibleValue::minimumValue. |
| |
| @section _iaaction-iahyperlink IAccessibleHyperlink as subclass of IAccessibleAction |
| In this version of the IDL, IAccessibleHyperlink is a subclass of IAccessibleAction. |
| However, there is no practical need for that inheritance and in some cases, such as |
| an image map of smart tags, it doesn't make sense because such an image map doesn't |
| have actionable objects; it's the secondary smart tags that are actionable. As a |
| result, implementations should not rely on the inheritance as it may be removed in |
| a later version of the IDL. |
| |
| @section _trademark Trademark Attribution |
| The names of actual companies and products mentioned herein may be the trademarks of |
| their respective owners. In particular, Active Accessibility, Microsoft, MSDN, and Win32 |
| are trademarks of the Microsoft group of companies in the U.S.A. and/or other countries. |
| |
| **/ |
| |
| |
| |
| |
| |
| |
| |
| |
| /** A structure defining the locale of an accessible object. |
| |
| IAccessible2::locale returns this struct. |
| */ |
| typedef struct IA2Locale { |
| BSTR language; ///< ISO 639-1 Alpha-2 two character language code |
| BSTR country; ///< ISO 3166-1 Alpha-2 two character country code |
| BSTR variant; ///< Application specific variant of the locale |
| } IA2Locale; |
| |
| /** @brief This interface exposes the primary set of information about an |
| IAccessible2 enabled accessible object. |
| |
| This interface must always be provided for objects that support some |
| portion of the collection of the %IAccessible2 interfaces. |
| |
| Please refer to @ref _changingInterfaces "Changing between Accessible Interfaces" |
| for special considerations related to use of the MSAA IAccessible interface and |
| the set of %IAccessible2 interfaces. |
| */ |
| [object, uuid(E89F726E-C4F4-4c19-BB19-B647D7FA8478)] |
| interface IAccessible2 : IAccessible |
| { |
| |
| /** @brief Returns the number of accessible relations for this object. |
| @param [out] nRelations |
| @retval S_OK |
| */ |
| [propget] HRESULT nRelations |
| ( |
| [out, retval] long *nRelations |
| ); |
| |
| /** @brief Returns one accessible relation for this object. |
| @param [in] relationIndex |
| 0 based |
| @param [out] relation |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT relation |
| ( |
| [in] long relationIndex, |
| [out, retval] IAccessibleRelation **relation |
| ); |
| |
| /** @brief Returns multiple accessible relations for this object. |
| @param [in] maxRelations |
| maximum size of the array allocated by the client |
| @param [out] relations |
| The array of accessible relation objects. Note that this array is to be |
| allocated by the client and freed when no longer needed. Refer to @ref |
| _arrayConsideration "Special Consideration when using Arrays" for more details. |
| @param [out] nRelations |
| actual number of relations in the returned array (not more than maxRelations) |
| @retval S_OK |
| @retval S_FALSE if there are no relations, nRelations is set to 0 |
| @note As a performant alternative, client code should consider using IAccessible2_2::relationTargetsOfType. |
| */ |
| [propget] HRESULT relations |
| ( |
| [in] long maxRelations, |
| [out, size_is(maxRelations), length_is(*nRelations)] |
| IAccessibleRelation **relations, |
| [out, retval] long *nRelations |
| ); |
| |
| /** @brief Returns the role of an %IAccessible2 object. |
| @param [out] role |
| The role of an %IAccessible2 object. |
| @retval S_OK |
| @note |
| @li For convenience MSAA roles are also passed through this method so the |
| AT doesn't have to also fetch roles through MSAA's get_accRole. |
| @li %IAccessible2 roles should not be passed through MSAA's get_accRole. |
| @li For compatibility with non IAccessible2 enabled ATs, IAccessible2 |
| applications should also add support to get_accRole to return the closest |
| MSAA role or ROLE_SYSTEM_CLIENT (the MSAA defined default role) if there |
| is not a good match. |
| @li This method is missing a [propget] prefix in the IDL. The result is the |
| method is named role in generated C++ code instead of get_role. |
| */ |
| HRESULT role |
| ( |
| [out, retval] long *role |
| ); |
| |
| /** @brief Makes an object visible on the screen. |
| @param [in] scrollType |
| Defines where the object should be placed on the screen. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT scrollTo |
| ( |
| [in] enum IA2ScrollType scrollType |
| ); |
| |
| /** @brief Moves the top left of an object to a specified location. |
| |
| @param [in] coordinateType |
| Specifies whether the coordinates are relative to the screen or the parent object. |
| @param [in] x |
| Defines the x coordinate. |
| @param [in] y |
| Defines the y coordinate. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT scrollToPoint |
| ( |
| [in] enum IA2CoordinateType coordinateType, |
| [in] long x, |
| [in] long y |
| ); |
| |
| /** @brief Returns grouping information. |
| |
| Used for tree items, list items, tab panel labels, radio buttons, etc. |
| Also used for collections of non-text objects. |
| |
| @param [out] groupLevel |
| 1 based, 0 indicates that this value is not applicable |
| @param [out] similarItemsInGroup |
| 1 based, 0 indicates that this value is not applicable |
| @param [out] positionInGroup |
| 1 based, 0 indicates that this value is not applicable. This is an index |
| into the objects in the current group, not an index into all the objects |
| at the same group level. |
| @retval S_OK if at least one value is valid |
| @retval S_FALSE if no values are valid, [out] values are 0s |
| @note This method is meant to describe the nature of an object's containment |
| structure. It's exposed by trees, tree grids, nested lists, nested menus, |
| but not headings, which uses the level object attribute. It is also exposed |
| by radio buttons (with groupLevel == 0). |
| @note This is normally not implemented on a combo box to describe the nature |
| of its contents. Normally an AT will get that information from its child list |
| object. However, in some cases when non-edit combo boxes are not able to be structured |
| such that the list is a child of the combo box, this method is implemented on |
| the combo box itself. ATs can use this interface if a child list is not found. |
| */ |
| [propget] HRESULT groupPosition |
| ( |
| [out] long *groupLevel, |
| [out] long *similarItemsInGroup, |
| [out, retval] long *positionInGroup |
| ); |
| |
| /** @brief Returns the bit strip containing any IAccessible2 states. |
| |
| The IAccessible2 states are in addition to the MSAA states and are defined in |
| the IA2States enum. |
| |
| @param [out] states |
| @retval S_OK |
| */ |
| [propget] HRESULT states |
| ( |
| [out, retval] AccessibleStates *states |
| ); |
| |
| /** @brief Returns the extended role. |
| |
| An extended role is a role which is dynamically generated by the application. |
| It is not predefined by the %IAccessible2 specification. |
| |
| @param [out] extendedRole |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT extendedRole |
| ( |
| [out, retval] BSTR *extendedRole |
| ); |
| |
| /** @brief Returns the localized extended role. |
| @param [out] localizedExtendedRole |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT localizedExtendedRole |
| ( |
| [out, retval] BSTR *localizedExtendedRole |
| ); |
| |
| /** @brief Returns the number of extended states. |
| @param [out] nExtendedStates |
| @retval S_OK |
| */ |
| [propget] HRESULT nExtendedStates |
| ( |
| [out, retval] long *nExtendedStates |
| ); |
| |
| /** @brief Returns the extended states (array of strings). |
| |
| An extended state is a state which is dynamically generated by the application. |
| It is not predefined by the %IAccessible2 specification. |
| |
| @param [in] maxExtendedStates |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] extendedStates |
| This array is allocated by the server. The client must free it with CoTaskMemFree. |
| @param [out] nExtendedStates |
| The number of extended states returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are no states, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT extendedStates |
| ( |
| [in] long maxExtendedStates, |
| [out, size_is(,maxExtendedStates), length_is(,*nExtendedStates)] BSTR **extendedStates, |
| [out, retval] long *nExtendedStates |
| ); |
| |
| /** @brief Returns the localized extended states (array of strings). |
| |
| @param [in] maxLocalizedExtendedStates |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] localizedExtendedStates |
| This array is allocated by the server. The client must free it with CoTaskMemFree. |
| @param [out] nLocalizedExtendedStates |
| The number of localized extended states returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are no states, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT localizedExtendedStates |
| ( |
| [in] long maxLocalizedExtendedStates, |
| [out, size_is(,maxLocalizedExtendedStates), length_is(,*nLocalizedExtendedStates)] BSTR **localizedExtendedStates, |
| [out, retval] long *nLocalizedExtendedStates |
| ); |
| |
| /** @brief Returns the unique ID. |
| |
| The uniqueID is an identifier for this object, is unique within the |
| current window, and remains the same for the lifetime of the accessible |
| object. |
| |
| The uniqueID is not related to: |
| - the MSAA objectID which is used by the server to disambiguate between |
| IAccessibles per HWND or |
| - the MSAA childID which is used to disambiguate between children being |
| managed by an IAccessible. |
| |
| This value is provided so the AT can have access to a unique runtime persistent |
| identifier even when not handling an event for the object. |
| |
| An example of when this value is useful is if the AT wants to build a cache. |
| The AT could cache the uniqueIDs in addition to other data being cached. |
| When an event is fired the AT could map the uniqueID to its internal model. |
| Thus, if there's a REORDER/SHOW/HIDE event the AT knows which part of the |
| internal structure has been invalidated and can refetch just that part. |
| |
| This value can also be used by an AT to determine when the current control |
| has changed. If the role is the same for two controls that are adjacent in |
| the tab order, this can be used to detect the new control. |
| |
| Another use of this value by an AT is to identify when a grouping object has |
| changed, e.g. when moving from a radio button in one group to a radio button in a |
| different group. |
| |
| One means of implementing this would be to create a factory with a 32 bit number |
| generator and a reuse pool. The number generator would emit numbers starting |
| at 1. Each time an object's life cycle ended, its number would be saved into a |
| reuse pool. The number generator would be used whenever the reuse pool was empty. |
| |
| Another way to create a unique ID is to generate it from a pointer value, e.g. an |
| object's address. That would be unique because no two active objects can use the |
| same allocated memory space. |
| |
| @param [out] uniqueID |
| @retval S_OK |
| */ |
| [propget] HRESULT uniqueID |
| ( |
| [out, retval] long *uniqueID |
| ); |
| |
| /** @brief Returns the window handle for the parent window which contains this object. |
| |
| This is the same window handle which will be passed for any events that occur on the |
| object, but is cached in the accessible object for use when it would be helpful to |
| access the window handle in cases where an event isn't fired on this object. |
| |
| A use case is when a screen reader is grabbing an entire web page on a page load. |
| Without the availability of windowHandle, the AT would have to get the window handle |
| by using WindowFromAccessibleObject on each IAccessible, which is slow because it's |
| implemented by oleacc.dll as a loop which crawls up the ancestor chain and looks for |
| a ROLE_WINDOW object, mapping that back to a window handle. |
| |
| @param [out] windowHandle |
| @retval S_OK |
| */ |
| [propget] HRESULT windowHandle |
| ( |
| [out, retval] HWND *windowHandle |
| ); |
| |
| /** @brief Returns the index of this object in its parent object. |
| @param [out] indexInParent |
| 0 based; -1 indicates there is no parent; the upper bound is the value |
| returned by the parent's IAccessible::get_accChildCount. |
| @retval S_OK |
| @retval S_FALSE if no parent, [out] value is -1 |
| */ |
| [propget] HRESULT indexInParent |
| ( |
| [out, retval] long *indexInParent |
| ); |
| |
| /** @brief Returns the IA2Locale of the accessible object. |
| @param [out] locale |
| @retval S_OK |
| */ |
| [propget] HRESULT locale |
| ( |
| [out, retval] IA2Locale *locale |
| ); |
| |
| /** @brief Returns the attributes specific to this object, such as a cell's formula. |
| @param [out] attributes |
| @retval S_OK |
| @retval S_FALSE returned if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT attributes |
| ( |
| [out, retval] BSTR *attributes |
| ); |
| |
| } |
| |
| /************************************************************************* |
| * |
| * File Name (Accessible2_2.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface exposes the primary set of information about an |
| IAccessible2 enabled accessible object. |
| |
| This interface must always be provided for objects that support some |
| portion of the collection of the %IAccessible2 interfaces. |
| |
| Please refer to @ref _changingInterfaces "Changing between Accessible Interfaces" |
| for special considerations related to use of the MSAA IAccessible interface and |
| the set of %IAccessible2 interfaces. |
| */ |
| [object, uuid(6C9430E9-299D-4E6F-BD01-A82A1E88D3FF)] |
| interface IAccessible2_2 : IAccessible2 |
| { |
| /** @brief Returns the attribute value of a specified attribute specific to this object. |
| @param [in] name |
| @param [out] attribute |
| @retval S_OK |
| @retval S_FALSE returned if there is nothing to return, [out] value is NULL. |
| @retval E_INVALIDARG if bad [in] passed. |
| @note The output value is a VARIANT. Typically it will be a VT_BSTR, but there |
| are some cases where it will be a VT_I4 or VT_BOOL. Refer to the <a href= |
| "http://www.linuxfoundation.org/collaborate/workgroups/accessibility/iaccessible2/objectattributesIAccessible2"> |
| Object Attributes specification</a> for more information. |
| */ |
| [propget] HRESULT attribute |
| ( |
| [in] BSTR name, |
| [out, retval] VARIANT *attribute |
| ); |
| |
| /** @brief Returns the deepest hypertext accessible in the subtree of this object, and the caret offset within it. |
| @param [out] accessible |
| @param [out] caretOffset |
| @retval S_OK |
| @retval S_FALSE returned if there is no caret in any of the objects in the subtree, [out] accessible is NULL and [out] caretOffset is -1. |
| */ |
| [propget] HRESULT accessibleWithCaret |
| ( |
| [out] IUnknown **accessible, |
| [out, retval] long *caretOffset |
| ); |
| |
| /** @brief Returns relation targets for a specified target type. |
| @param [in] type |
| The requested @ref grpRelations "relation type". |
| @param [in] maxTargets |
| The number of targets requested. 0 indicates that all targets should be returned. |
| @param [out] targets |
| This array is allocated by the server. The client must free it with CoTaskMemFree. |
| @param [out] nTargets |
| The number of targets returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are no targets, [out] values are NULL and 0 respectively. |
| @retval E_INVALIDARG if bad [in] passed. |
| */ |
| [propget] HRESULT relationTargetsOfType |
| ( |
| [in] BSTR type, |
| [in] long maxTargets, |
| [out, size_is(,*nTargets)] IUnknown ***targets, |
| [out, retval] long *nTargets |
| ); |
| |
| } |
| |
| /************************************************************************* |
| * |
| * File Name (AccessibleComponent.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| /** A value specifying a color in ARGB format, where each 8 bit color component |
| specifies alpha, red, green, and blue respectively. The alpha value is optional. |
| */ |
| typedef long IA2Color; |
| |
| /** @brief This interface is implemented by any object that can be rendered |
| on the screen. |
| |
| This interface provides the standard mechanism for an assistive technology |
| to retrieve information concerning the graphical representation of an object. |
| Coordinates used by the functions of this interface are specified in |
| different coordinate systems. Their scale is the same and is equal to |
| that of the screen coordinate system. In other words all coordinates |
| are measured in pixels. They differ in their respective origin: |
| <ul> |
| <li>The screen coordinate system has its origin in the upper left |
| corner of the current screen.</li> |
| <li>The origin of the parent coordinate system is the upper left corner |
| of the parent's bounding box. With no parent the screen coordinate |
| system is used instead.</li> |
| </ul> |
| */ |
| [object, uuid(1546D4B0-4C98-4bda-89AE-9A64748BDDE4)] |
| interface IAccessibleComponent : IUnknown |
| { |
| |
| /** @brief Returns the location of the upper left corner of the object's |
| bounding box relative to the immediate parent object. |
| |
| The coordinates of the bounding box are given relative to the parent's |
| coordinate system. The coordinates of the returned position are relative |
| to this object's parent or relative to the screen on which this object |
| is rendered if it has no parent. If the object is not on any screen |
| the returned position is (0,0). |
| |
| @param [out] x |
| @param [out] y |
| @retval S_OK |
| */ |
| [propget] HRESULT locationInParent |
| ( |
| [out] long *x, |
| [out, retval] long *y |
| ); |
| |
| /** @brief Returns the foreground color of this object. |
| @param [out] foreground |
| The returned color is the foreground color of this object or, if |
| that is not supported, the default foreground color. |
| @retval S_OK |
| */ |
| [propget] HRESULT foreground |
| ( |
| [out, retval] IA2Color *foreground |
| ); |
| |
| /** @brief Returns the background color of this object. |
| @param [out] background |
| The returned color is the background color of this object or, if |
| that is not supported, the default background color. |
| @retval S_OK |
| */ |
| [propget] HRESULT background |
| ( |
| [out, retval] IA2Color *background |
| ); |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleValue.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| /** @brief This interface gives access to a single numerical value. |
| |
| The %IAccessibleValue interface represents a single numerical value and should |
| be implemented by any class that supports numerical value like progress bars |
| and spin boxes. This interface lets you access the value and its upper and |
| lower bounds. |
| */ |
| [object, uuid(35855B5B-C566-4fd0-A7B1-E65465600394)] |
| interface IAccessibleValue : IUnknown |
| { |
| |
| /** @brief Returns the value of this object as a number. |
| |
| The exact return type is implementation dependent. Typical types are long and |
| double. |
| @param [out] currentValue |
| Returns the current value represented by this object. See the section about |
| @ref _variants "VARIANTs" for additional information. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is a VARIANT with vt = VT_EMPTY |
| */ |
| [propget] HRESULT currentValue |
| ( |
| [out, retval] VARIANT *currentValue |
| ); |
| |
| /** @brief Sets the value of this object to the given number. |
| |
| The argument is clipped to the valid interval whose upper and lower |
| bounds are returned by the methods IAccessibleValue::maximumValue and |
| IAccessibleValue::minimumValue, i.e. if it is lower than the minimum |
| value the new value will be the minimum and if it is greater than the |
| maximum then the new value will be the maximum. |
| |
| @param [in] value |
| The new value represented by this object. The set of admissible types for |
| this argument is implementation dependent. |
| @retval S_OK |
| */ |
| HRESULT setCurrentValue |
| ( |
| [in] VARIANT value |
| ); |
| |
| /** @brief Returns the maximal value that can be represented by this object. |
| |
| The type of the returned value is implementation dependent. It does not have |
| to be the same type as that returned by method IAccessibleValue::currentValue. |
| |
| @param [out] maximumValue |
| Returns the maximal value in an implementation dependent type. If this object |
| has no upper bound then an empty object is returned. See the section about |
| @ref _variants "VARIANTs" for additional information. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is a VARIANT with vt = VT_EMPTY |
| */ |
| [propget] HRESULT maximumValue |
| ( |
| [out, retval] VARIANT *maximumValue |
| ); |
| |
| /** @brief Returns the minimal value that can be represented by this object. |
| |
| The type of the returned value is implementation dependent. It does not have |
| to be the same type as that returned by method IAccessibleValue::currentValue. |
| |
| @param [out] minimumValue |
| Returns the minimal value in an implementation dependent type. If this object |
| has no lower bound then an empty object is returned. See the section about |
| @ref _variants "VARIANTs" for additional information. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is a VARIANT with vt = VT_EMPTY |
| */ |
| [propget] HRESULT minimumValue |
| ( |
| [out, retval] VARIANT *minimumValue |
| ); |
| |
| }; |
| /************************************************************************* |
| * |
| * File Name (AccessibleText.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** A structure containing a substring and the start and end offsets in the enclosing string. |
| |
| IAccessibleText::newText and IAccessibleText::oldText return this struct. |
| */ |
| typedef struct IA2TextSegment { |
| BSTR text; ///< A copy of a segment of text taken from an enclosing paragraph. |
| long start; ///< Index of the first character of the segment in the enclosing text. |
| long end; ///< Index of the character following the last character of the segment in the enclosing text. |
| } IA2TextSegment; |
| |
| /** This enum defines values which specify a text boundary type. |
| |
| IA2_TEXT_BOUNDARY_SENTENCE is optional. When a method doesn't implement this |
| method it must return S_FALSE. Typically this feature would not be implemented |
| by an application. However, if the application developer was not satisfied with |
| how screen readers have handled the reading of sentences this boundary type |
| could be implemented and screen readers could use the application's version of a |
| sentence rather than the screen reader's. |
| |
| The rest of the boundary types must be supported. |
| |
| This enum is used in IAccessibleText::textBeforeOffset, IAccessibleText::textAtOffset, |
| and IAccessibleText::textAfterOffset. |
| */ |
| |
| enum IA2TextBoundaryType { |
| IA2_TEXT_BOUNDARY_CHAR, /**< Typically, a single character is returned. In some cases more than |
| one character is returned, for example, when a document contains field |
| data such as a field containing a date, time, or footnote reference. |
| In this case the caret can move over several characters in one movement |
| of the caret. Note that after the caret moves, the caret offset changes |
| by the number of characters in the field, e.g. by 8 characters in the |
| following date: 03/26/07. */ |
| IA2_TEXT_BOUNDARY_WORD, /**< The range provided matches the range observed when the application |
| processes the Ctrl + left arrow and Ctrl + right arrow key sequences. |
| Typically this is from the start of one word to the start of the next, but |
| various applications are inconsistent in the handling of the end of a line. */ |
| IA2_TEXT_BOUNDARY_SENTENCE, ///< Range is from start of one sentence to the start of another sentence. |
| IA2_TEXT_BOUNDARY_PARAGRAPH, ///< Range is from start of one paragraph to the start of another paragraph. |
| IA2_TEXT_BOUNDARY_LINE, /**< Range is from start of one line to the start of another line. This |
| often means that an end-of-line character will appear at the end of the |
| range. However in the case of some applications an end-of-line character |
| indicates the end of a paragraph and the lines composing the paragraph, |
| other than the last line, do not contain an end of line character. */ |
| IA2_TEXT_BOUNDARY_ALL ///< Using this value will cause all text to be returned. |
| }; |
| |
| /** @brief This interface gives read-only access to text. |
| |
| The %IAccessibleText interface should be implemented by all components |
| that present textual information on the display like buttons, |
| text entry fields, or text portions of the document window. The interface |
| provides access to the text's content, attributes, and spatial location. |
| However, text can not be modified with this interface. That is the task |
| of the IAccessibleEditableText interface. |
| |
| The text length, i.e. the number of characters in the text, is |
| returned by IAccessibleText::nCharacters. All methods that operate |
| on particular characters (e.g. IAccessibleText::textAtOffset) use character |
| indices from 0 to length-1. All methods that operate on character positions |
| (e.g. IAccessibleText::text) use indices from 0 to length. |
| |
| Please note that accessible text does not necessarily support selection. |
| In this case it should behave as if there where no selection. An empty |
| selection is used for example to express the current cursor position. |
| |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| |
| E_FAIL is returned in the following cases |
| @li endOffset < startOffset |
| @li endoffset > length |
| */ |
| [object, uuid(24FD2FFB-3AAD-4a08-8335-A3AD89C0FB4B)] |
| interface IAccessibleText : IUnknown |
| { |
| |
| /** @brief Adds a text selection |
| @param [in] startOffset |
| Starting offset ( 0 based). |
| @param [in] endOffset |
| Offset of first character after new selection (0 based). |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| */ |
| HRESULT addSelection |
| ( |
| [in] long startOffset, |
| [in] long endOffset |
| ); |
| |
| /** @brief Returns text attributes. |
| @param [in] offset |
| Text offset (0 based). Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @param [out] startOffset |
| The starting offset of the character range over which all text attributes match |
| those of offset. (0 based) |
| @param [out] endOffset |
| The offset of the first character past the character range over which all text |
| attributes match those of offset. (0 based) |
| @param [out] textAttributes |
| A string of attributes describing the text. The attributes are described in the |
| <a href="http://www.linuxfoundation.org/en/Accessibility/IAccessible2/TextAttributes"> |
| text attributes specification</a> on the %IAccessible2 web site. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] values are 0s and NULL respectively |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT attributes |
| ( |
| [in] long offset, |
| [out] long *startOffset, |
| [out] long *endOffset, |
| [out, retval] BSTR *textAttributes |
| ); |
| |
| /** @brief Returns the position of the caret. |
| |
| Returns the 0-based offset of the caret within the text. If the text is |
| implemented as a tree of text objects with embed characters in higher levels |
| representing substrings of child text objects and the caret is in one of the |
| child text objects, then the offset in the higher level text object would be |
| at the embed character representing child text object that contains the caret. |
| |
| For example, if the string "one two three" is implemented as a two text objects, |
| with a top level text object containing an embed character "one ? three" and a |
| child text object containing "two" and if the caret is in the descendant object |
| just before the 'o' in "two", then: |
| <ul> |
| <li>the caretOffset for the "one ? three" object would be 4, matching the embed character</li> |
| <li>the caretOffset for "two" would be 2, matching the "o"</li> |
| </ul> |
| The caret position/offset is that of the character logically following it, e.g. |
| to the right of it in a left to right language, or to the left of it in a right |
| to left language. |
| @param [out] offset |
| The returned offset is relative to the text represented by this object. |
| @retval S_OK |
| @retval S_FALSE if the caret is not currently active on this object, i.e. the |
| caret is located on some other object. The returned offset value will be -1. |
| @note S_FALSE (and an offset of -1) will not be returned if the caret is somewhere |
| in the text object or one of its descendants. |
| */ |
| [propget] HRESULT caretOffset |
| ( |
| [out, retval] long *offset |
| ); |
| |
| |
| /** @brief Returns the bounding box of the specified position. |
| |
| The virtual character after the last character of the represented |
| text, i.e. the one at position length is a special case. It represents the |
| current input position and will therefore typically be queried by AT more |
| often than other positions. Because it does not represent an existing character |
| its bounding box is defined in relation to preceding characters. It should be |
| roughly equivalent to the bounding box of some character when inserted at the |
| end of the text. Its height typically being the maximal height of all the |
| characters in the text or the height of the preceding character, its width being |
| at least one pixel so that the bounding box is not degenerate. |
| |
| Note that the index 'length' is not always valid. Whether it is or not is |
| implementation dependent. It typically is when text is editable or otherwise |
| when on the screen the caret can be placed behind the text. You can be sure |
| that the index is valid after you have received a ::IA2_EVENT_TEXT_CARET_MOVED |
| event for this index. |
| @param [in] offset |
| Index of the character for which to return its bounding box. The valid range |
| is 0..length. Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @param [in] coordType |
| Specifies if the coordinates are relative to the screen or to the parent window. |
| @param [out] x |
| X coordinate of the top left corner of the bounding box of the referenced character. |
| @param [out] y |
| Y coordinate of the top left corner of the bounding box of the referenced character. |
| @param [out] width |
| Width of the bounding box of the referenced character. |
| @param [out] height |
| Height of the bounding box of the referenced character. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT characterExtents |
| ( |
| [in] long offset, |
| [in] enum IA2CoordinateType coordType, |
| [out] long *x, |
| [out] long *y, |
| [out] long *width, |
| [out, retval] long *height |
| ); |
| |
| |
| /** @brief Returns the number of active non-contiguous selections |
| @param [out] nSelections |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelections |
| ( |
| [out, retval] long *nSelections |
| ); |
| |
| /** @brief Returns the text position for the specified screen position. |
| |
| Given a point return the zero-based index of the character under that |
| point. The same functionality could be achieved by using the bounding |
| boxes for each character as returned by IAccessibleText::characterExtents. |
| The method IAccessibleText::offsetAtPoint, however, can be implemented |
| more efficiently. |
| |
| @param [in] x |
| The position's x value for which to look up the index of the character that |
| is rendered on to the display at that point. |
| @param [in] y |
| The position's y value for which to look up the index of the character that |
| is rendered on to the display at that point. |
| @param [in] coordType |
| Screen coordinates or window coordinates. |
| @param [out] offset |
| Index of the character under the given point or -1 if the point |
| is invalid or there is no character under the point. |
| @retval S_OK |
| @retval S_FALSE if nothing to return, [out] value is -1 |
| |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT offsetAtPoint |
| ( |
| [in] long x, |
| [in] long y, |
| [in] enum IA2CoordinateType coordType, |
| [out, retval] long *offset |
| ); |
| |
| /** @brief Returns the character offsets of Nth active text selection |
| |
| Returns the 0-based starting and ending offsets of the Nth selection. If the |
| text is implemented as a tree of text objects with embed characters in higher |
| levels representing substrings of child text objects, consider the following. |
| If the starting selection offset is in one of the child text objects, then the |
| starting offset in the higher level text object would be at the embed character |
| representing the child text object that contains the starting selection offset. |
| If the ending selection offset is in one of the child text objects, then the |
| ending offset in the higher level text object would be just after the embed |
| character representing the child text object that contains the ending selection |
| offset. |
| |
| For example, if the string "one two three" is implemented as a two text objects, |
| with a top level text object containing an embed character "one ? three" and a |
| child text object containing "two" and if the selection is the string "two" then: |
| <ul> |
| <li>the startOffset for the "one ? three" object would be 4, matching the embed character and the endOffset would be 5.</li> |
| <li>the startOffset for the "two" object would be 0, and the endOffset would be 3</li> |
| </ul> |
| Selection offsets are that of the character logically following it, e.g. |
| to the right of it in a left to right language or to the left of it in a right to left language. |
| @param [in] selectionIndex |
| Index of selection (0 based). |
| @param [out] startOffset |
| 0 based offset of first selected character |
| @param [out] endOffset |
| 0 based offset of one past the last selected character. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT selection |
| ( |
| [in] long selectionIndex, |
| [out] long *startOffset, |
| [out, retval] long *endOffset |
| ); |
| |
| /** @brief Returns the substring between the two given indices. |
| |
| The substring starts with the character at startOffset (inclusive) and up to |
| the character at endOffset (exclusive), if startOffset is less or equal |
| endOffset. If endOffset is lower than startOffset, the result is the same |
| as a call with the two arguments being exchanged. |
| |
| The whole text can be requested by passing the indices zero and |
| IAccessibleText::nCharacters. If both indices have the same value, an empty |
| string is returned. |
| @param [in] startOffset |
| Index of the first character to include in the returned string. The valid range |
| is 0..length. |
| @param [in] endOffset |
| Index of the last character to exclude in the returned string. The valid range |
| is 0..length. |
| @param [out] text |
| Returns the substring starting with the character at startOffset (inclusive) |
| and up to the character at endOffset (exclusive), if startOffset is less than |
| or equal to endOffset. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note |
| @li The returned string may be longer than endOffset-startOffset bytes if text |
| contains multi-byte characters. |
| @li Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| */ |
| [propget] HRESULT text |
| ( |
| [in] long startOffset, |
| [in] long endOffset, |
| [out, retval] BSTR *text |
| ); |
| |
| /** @brief Returns a text portion before the given position. |
| |
| Returns the substring of the specified text type that is located before the |
| given character and does not include it. The result of this method should be |
| same as a result for IAccessibleText::textAtOffset with a suitably decreased |
| index value. |
| |
| For example, if text type is ::IA2_TEXT_BOUNDARY_WORD, then the complete |
| word that is closest to and located before offset is returned. |
| |
| If the index is valid, but no text is found, S_FALSE is returned along with out |
| values of 0, 0, and a NULL pointer. This would happen for boundary types other |
| than character when the text consists entirely of whitespace. |
| |
| @param [in] offset |
| Index of the character for which to return the text part before it. The index |
| character will not be part of the returned string. The valid range is 0..length. |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @param [in] boundaryType |
| The type of the text portion to return. See ::IA2TextBoundaryType for the |
| complete list. |
| @param [out] startOffset |
| 0 based offset of first character. |
| @param [out] endOffset |
| 0 based offset of one past the last character. |
| @param [out] text |
| Returns the requested text portion. This portion may be empty or invalid when |
| no appropriate text portion is found or text type is invalid. |
| @retval S_OK |
| @retval S_FALSE if the requested boundary type is not implemented, such as |
| ::IA2_TEXT_BOUNDARY_SENTENCE, or if there is nothing to return; |
| [out] values are 0s and NULL respectively |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT textBeforeOffset |
| ( |
| [in] long offset, |
| [in] enum IA2TextBoundaryType boundaryType, |
| [out] long *startOffset, |
| [out] long *endOffset, |
| [out, retval] BSTR *text |
| ); |
| |
| /** @brief Returns a text portion after the given position. |
| |
| Returns the substring of the specified text type that is located after the |
| given character and does not include it. The result of this method should be |
| same as a result for IAccessibleText::textAtOffset with a suitably increased |
| index value. |
| |
| For example, if text type is ::IA2_TEXT_BOUNDARY_WORD, then the complete |
| word that is closest to and located after offset is returned. |
| |
| If the index is valid, but no text is found, S_FALSE is returned along with out |
| values of 0, 0, and a NULL pointer. This would happen for boundary types other |
| than character when the text consists entirely of whitespace. |
| |
| @param [in] offset |
| Index of the character for which to return the text part after it. The index |
| character will not be part of the returned string. The valid range is 0..length. |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @param [in] boundaryType |
| The type of the text portion to return. See ::IA2TextBoundaryType for the complete |
| list. |
| @param [out] startOffset |
| 0 based offset of first character. |
| @param [out] endOffset |
| 0 based offset of one past the last character. |
| @param [out] text |
| Returns the requested text portion. This portion may be empty or invalid when |
| no appropriate text portion is found or text type is invalid. |
| @retval S_OK |
| @retval S_FALSE if the requested boundary type is not implemented, such as |
| ::IA2_TEXT_BOUNDARY_SENTENCE, or if there is nothing to return; |
| [out] values are 0s and NULL respectively |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT textAfterOffset |
| ( |
| [in] long offset, |
| [in] enum IA2TextBoundaryType boundaryType, |
| [out] long *startOffset, |
| [out] long *endOffset, |
| [out, retval] BSTR *text |
| ); |
| |
| /** @brief Returns a text portion that spans the given position. |
| |
| Returns the substring defined by the specified boundary type at the specified |
| offset. Refer to IA2TextBoundaryType for more details. |
| |
| For the word boundary type the returned string will contain the word at the |
| offset if the offset is inside a word and will contain the word before the |
| offset if the offset is not inside a word. All offsets from the first to the |
| last characters of a word are considered inside the word. Boundary types of |
| sentence and paragraph should exhibit similar behavior. |
| |
| If the index is valid, but no text is found, S_FALSE is returned along with out |
| values of 0, 0, and a NULL pointer. This would happen for boundary types other |
| than character when the text consists entirely of whitespace. |
| |
| @param [in] offset |
| Index of the character for which to return the text part it belongs to. The valid |
| range is 0..length. |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @param [in] boundaryType |
| The type of the text portion to return. See ::IA2TextBoundaryType for the complete |
| list. |
| @param [out] startOffset |
| 0 based offset of first character. |
| @param [out] endOffset |
| 0 based offset of one past the last character. |
| @param [out] text |
| Returns the requested text portion. This portion may be empty or invalid when |
| no appropriate text portion is found or text type is invalid. |
| @retval S_OK |
| @retval S_FALSE if the requested boundary type is not implemented, such as |
| ::IA2_TEXT_BOUNDARY_SENTENCE, or if there is nothing to return; |
| [out] values are 0s and NULL respectively |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT textAtOffset |
| ( |
| [in] long offset, |
| [in] enum IA2TextBoundaryType boundaryType, |
| [out] long *startOffset, |
| [out] long *endOffset, |
| [out, retval] BSTR *text |
| ); |
| |
| /** @brief Unselects a range of text. |
| @param [in] selectionIndex |
| Index of selection to remove (0 based). |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT removeSelection |
| ( |
| [in] long selectionIndex |
| ); |
| |
| /** @brief Sets the position of the caret. |
| |
| The caret position/offset is that of the character logically following it, |
| e.g. to the right of it in a left to right language. |
| |
| Setting the caret position may or may not alter the current selection. A |
| change of the selection is notified to the accessibility event listeners with |
| an ::IA2_EVENT_TEXT_SELECTION_CHANGED event. |
| |
| When the new caret position differs from the old one (which, of course, is the |
| standard case) this is notified to the accessibility event listeners with an |
| ::IA2_EVENT_TEXT_CARET_MOVED event. |
| @param [in] offset |
| The new index of the caret. This caret is actually placed to the left side of |
| the character with that index. An index of 0 places the caret so that the next |
| insertion goes before the first character. An index of IAccessibleText::nCharacters |
| leads to insertion after the last character. Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| @retval S_OK |
| @retval E_FAIL if the caret cannot be set |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT setCaretOffset |
| ( |
| [in] long offset |
| ); |
| |
| /** @brief Changes the bounds of an existing selection. |
| @param [in] selectionIndex |
| Index of selection to change (0 based) |
| @param [in] startOffset |
| New starting offset (0 based) |
| @param [in] endOffset |
| New ending offset (0 based) - the offset of the character just past the last character of the selection. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| */ |
| HRESULT setSelection |
| ( |
| [in] long selectionIndex, |
| [in] long startOffset, |
| [in] long endOffset |
| ); |
| |
| /** @brief Returns total number of characters. |
| |
| Note that this may be different than the total number of bytes required to store the |
| text, if the text contains multi-byte characters. |
| @param [out] nCharacters |
| @retval S_OK |
| */ |
| [propget] HRESULT nCharacters |
| ( |
| [out, retval] long *nCharacters |
| ); |
| |
| /** @brief Makes a specific part of string visible on screen. |
| @param [in] startIndex |
| 0 based character offset. |
| @param [in] endIndex |
| 0 based character offset - the offset of the character just past the last character of the string. |
| @param [in] scrollType |
| Defines where the object should be placed on the screen. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| */ |
| HRESULT scrollSubstringTo |
| ( |
| [in] long startIndex, |
| [in] long endIndex, |
| [in] enum IA2ScrollType scrollType |
| ); |
| |
| /** @brief Moves the top left of a substring to a specified location. |
| |
| @param [in] startIndex |
| 0 based character offset. |
| @param [in] endIndex |
| 0 based character offset - the offset of the character just past the last character of the string. |
| @param [in] coordinateType |
| Specifies whether the coordinates are relative to the screen or the parent object. |
| @param [in] x |
| Defines the x coordinate. |
| @param [in] y |
| Defines the y coordinate. |
| @retval S_OK |
| @retval S_FALSE if the object is already at the specified location. |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleText methods. |
| */ |
| HRESULT scrollSubstringToPoint |
| ( |
| [in] long startIndex, |
| [in] long endIndex, |
| [in] enum IA2CoordinateType coordinateType, |
| [in] long x, |
| [in] long y |
| ); |
| |
| /** @brief Returns any inserted text. |
| |
| Provided for use by the ::IA2_EVENT_TEXT_INSERTED and ::IA2_EVENT_TEXT_UPDATED |
| event handlers. |
| |
| This data is only guaranteed to be valid while the thread notifying the event |
| continues. Once the handler has returned, the validity of the data depends on |
| how the server manages the life cycle of its objects. Also, note that the server |
| may have different life cycle management strategies for controls depending on |
| whether or not a control manages its children. Lists, trees, and tables can have |
| a large number of children and thus it's possible that the child objects for those |
| controls would only be created as needed. Servers should document their life cycle |
| strategy as this will be of interest to assistive technology or script engines |
| accessing data out of process or from other threads. Servers only need to save the |
| last inserted block of text and a scope of the entire application is adequate. |
| |
| @param [out] newText |
| The text that was just inserted. |
| @retval S_OK |
| @retval S_FALSE If there is nothing to return, the values of IA2TextSegment |
| struct are set as follows: text = NULL, start = 0, end = 0. |
| |
| */ |
| [propget] HRESULT newText |
| ( |
| [out, retval] IA2TextSegment *newText |
| ); |
| |
| /** @brief Returns any removed text. |
| |
| Provided for use by the IA2_EVENT_TEXT_REMOVED/UPDATED event handlers. |
| |
| This data is only guaranteed to be valid while the thread notifying the event |
| continues. Once the handler has returned, the validity of the data depends on |
| how the server manages the life cycle of its objects. Also, note that the server |
| may have different life cycle management strategies for controls depending on |
| whether or not a control manages its children. Lists, trees, and tables can have |
| a large number of children and thus it's possible that the child objects for those |
| controls would only be created as needed. Servers should document their life cycle |
| strategy as this will be of interest to assistive technology or script engines |
| accessing data out of process or from other threads. Servers only need to save the |
| last removed block of text and a scope of the entire application is adequate. |
| |
| @param [out] oldText |
| The text that was just removed. |
| @retval S_OK |
| @retval S_FALSE If there is nothing to return, the values of IA2TextSegment |
| struct are set as follows: text = NULL, start = 0, end = 0. |
| */ |
| [propget] HRESULT oldText |
| ( |
| [out, retval] IA2TextSegment *oldText |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleText2.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| |
| /** @brief This interface gives read-only access to text. |
| |
| The %IAccessibleText2 interface extends the functionality of the |
| %IAccessibleText interface. |
| */ |
| [object, uuid(9690A9CC-5C80-4DF5-852E-2D5AE4189A54)] |
| interface IAccessibleText2 : IAccessibleText |
| { |
| |
| /** @brief Returns the range and of the specified set of attributes. |
| |
| Return the range (start and end offsets) and text attributes that correspond |
| to the given attributes filter at the given offset. |
| |
| @param [in] offset |
| The offset at which to search for the attributes specified in the filter. |
| @param [in] filter |
| The requested attribute names. The filter format is "attribute1, attribute2". |
| @param [out] startOffset |
| The starting (0-based) offset of the text containing the specified attributes. |
| @param [out] endOffset |
| The (0-based) offset one past the last character of the text containing the |
| specified attributes. |
| @param [out] attributeValues |
| The values of the requested attributes. |
| @retval S_OK |
| @retval S_FALSE if nothing to return, [out] values are -1, -1, NULL respectively. |
| @retval E_INVALIDARG if bad [in] passed. |
| */ |
| [propget] HRESULT attributeRange |
| ( |
| [in] long offset, |
| [in] BSTR filter, |
| [out] long *startOffset, |
| [out] long *endOffset, |
| [out, retval] BSTR *attributeValues |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleEditableText.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2012 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface provides clipboard capability to text objects. |
| |
| This interface is typically used in conjunction with the IAccessibleText |
| interface and complements that interface with the additional capability of |
| clipboard operations. Note that even a read only text object can support |
| the copy capability so this interface is not limited to editable objects. |
| |
| The substrings used with this interface are specified as follows: |
| If startOffset is less than endOffset, the substring starts with the |
| character at startOffset and ends with the character just before endOffset. |
| If endOffset is lower than startOffset, the result is the same as a call |
| with the two arguments exchanged. The whole text can be defined by passing |
| the indices zero and IAccessibleText::nCharacters. If both indices have the |
| same value, an empty string is defined. |
| |
| Refer to the @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about a special offset constant that can be used in %IAccessibleEditableText methods. |
| */ |
| [object, uuid(A59AA09A-7011-4b65-939D-32B1FB5547E3)] |
| interface IAccessibleEditableText : IUnknown |
| { |
| |
| /** @brief Copies the text range into the clipboard. |
| |
| The selection is set to the specified offsets and then selection is copied into |
| the system clipboard. |
| |
| @param [in] startOffset |
| Start index of the text to moved into the clipboard. |
| The valid range is 0..length. |
| @param [in] endOffset |
| End index of the text to moved into the clipboard. |
| The valid range is 0..length. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| @deprecated This function is available via the application's GUI. |
| */ |
| HRESULT copyText |
| ( |
| [in] long startOffset, |
| [in] long endOffset |
| ); |
| |
| /** @brief Deletes a range of text. |
| |
| The text between and including the two given indices is deleted |
| from the text represented by this object. |
| |
| @param [in] startOffset |
| Start index of the text to be deleted. |
| The valid range is 0..length. |
| @param [in] endOffset |
| End index of the text to be deleted. |
| The valid range is 0..length. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| */ |
| HRESULT deleteText |
| ( |
| [in] long startOffset, |
| [in] long endOffset |
| ); |
| |
| /** @brief Inserts text at the specified position. |
| |
| The specified string is inserted at the given index into the text |
| represented by this object. |
| |
| @param [in] offset |
| Index at which to insert the text. |
| The valid range is 0..length. |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| @param [in] text |
| Text that is inserted. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT insertText |
| ( |
| [in] long offset, |
| [in] BSTR *text |
| ); |
| |
| /** @brief Deletes a range of text and copies it to the clipboard. |
| |
| The selection is set to the specified offsets, the selection is then copied into |
| the system clipboard, and then the selection is deleted. |
| |
| @param [in] startOffset |
| Start index of the text to be deleted. |
| The valid range is 0..length. |
| @param [in] endOffset |
| End index of the text to be deleted. |
| The valid range is 0..length. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| @deprecated This function is available via the application's GUI. |
| */ |
| HRESULT cutText |
| ( |
| [in] long startOffset, |
| [in] long endOffset |
| ); |
| |
| /** @brief Pastes content from the clipboard. |
| |
| Any existing selection is removed, the clipboard content is then pasted into |
| this object's text at the given offset. This method is similar to the insertText |
| method. If the index is not valid the system clipboard content is not inserted. The |
| behavior is the same as when Ctrl+V is used, i.e. the pasted contents are not |
| necessarily plain text. |
| |
| @param [in] offset |
| Index at which to insert the content from the system clipboard into |
| the text represented by this object. |
| The valid range is 0..length. |
| Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @deprecated This function is available via the application's GUI. |
| */ |
| HRESULT pasteText |
| ( |
| [in] long offset |
| ); |
| |
| /** @brief Replaces text. |
| |
| The text between the two given indices is replaced by the specified |
| replacement string. This method is equivalent to calling first |
| IAccessibleEditableText::deleteText with the two indices and then |
| calling IAccessibleEditableText::insertText with the replacement text |
| at the start index. |
| |
| @param [in] startOffset |
| Start index of the text to be replaced. |
| The valid range is 0..length. |
| @param [in] endOffset |
| End index of the text to be replaced. |
| The valid range is 0..length. |
| @param [in] text |
| The Text that replaces the text between the given indices. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| */ |
| HRESULT replaceText |
| ( |
| [in] long startOffset, |
| [in] long endOffset, |
| [in] BSTR *text |
| ); |
| |
| /** @brief Replaces the attributes of a text range by the given set of attributes. |
| |
| Sets the attributes for the text between the two given indices. The old |
| attributes are replaced by the new list of attributes. |
| |
| @param [in] startOffset |
| Start index of the text whose attributes are modified. |
| The valid range is 0..length. |
| @param [in] endOffset |
| End index of the text whose attributes are modified. |
| The valid range is 0..length. |
| @param [in] attributes |
| Set of attributes that replaces the old list of attributes of |
| the specified text portion. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| @note Refer to @ref _specialOffsets |
| "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" |
| for information about special offsets that can be used in %IAccessibleEditableText |
| methods. |
| */ |
| HRESULT setAttributes |
| ( |
| [in] long startOffset, |
| [in] long endOffset, |
| [in] BSTR *attributes |
| ); |
| } |
| |
| /************************************************************************* |
| * |
| * File Name (AccessibleHyperlink.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface represents hyperlinks. |
| |
| This interface represents a hyperlink associated with a single substring |
| of text or single non-text object. Non-text objects can have either a |
| single link or a collection of links such as when the non-text object is |
| an image map. |
| |
| Linked objects and anchors are implementation dependent. This interface is derived |
| from IAccessibleAction. IAccessibleAction::nActions is one greater than the |
| maximum value for the indices used with the methods of this interface. |
| |
| Furthermore, the object that implements this interface has to be connected |
| implicitly or explicitly with an object that implements IAccessibleText. |
| IAccessibleHyperlink::startIndex and IAccessibleHyperlink::endIndex are |
| indices with respect to the text exposed by IAccessibleText. |
| |
| This interface provides access to a single object which can have multiple actions. |
| An example is an image map which is an image with multiple links each of which is |
| associated with a separate non-overlapping area of the image. This interface could |
| also be applied to other kinds of objects with multiple actions such as "smart tags" |
| which are objects, typically strings, which have multiple actions such as |
| "Activate URI", "Bookmark URI", etc. |
| |
| An interesting use case is an image map where each area is associated with multiple |
| actions, e.g. an image map of smart tags. In this case you would have to implement |
| two levels of accessible hyperlinks. The first level hyperlinks would only implement |
| anchor and anchorTarget. The anchors would all reference the image object. The |
| anchorTargets would reference the second level accessible hyperlink objects. None |
| of the IAccessibleAction methods would be implemented on the first level hyperlink |
| objects. The second level hyperlink objects would implement the IAccessibleAction |
| methods. Their anchors would also reference the image object and their anchorTargets |
| would reference URLs or the objects that would be activated. |
| |
| This use case demonstrates that in some cases there is no need for IAccessibleHyperlink |
| to derive from IAccessibleAction. As a result it may be removed in a later version of |
| the IDL and it is suggested that implementations should not rely on the inheritance. |
| |
| */ |
| [object, uuid(01C20F2B-3DD2-400f-949F-AD00BDAB1D41)] |
| interface IAccessibleHyperlink : IAccessibleAction |
| { |
| |
| /** @brief Returns an object that represents the link anchor, as appropriate |
| for the link at the specified index. |
| @param [in] index |
| A 0 based index identifies the anchor when, as in the case of an image map, |
| there is more than one link represented by this object. The valid maximal |
| index is indicated by IAccessibleAction::nActions. |
| @param [out] anchor |
| This is an implementation dependent value. For example, for a text link this |
| method could return the substring of the containing string where the substring |
| is overridden with link behavior, and for an image link this method could return |
| an IUnknown VARIANT for IAccessibleImage. See the section about |
| @ref _variants "VARIANTs" for additional information. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT anchor |
| ( |
| [in] long index, |
| [out, retval] VARIANT *anchor |
| ); |
| |
| /** @brief Returns an object representing the target of the link, as appropriate |
| for the link at the specified index. |
| @param [in] index |
| A 0 based index identifies the anchor when, as in the case of an image map, |
| there is more than one link represented by this object. The valid maximal |
| index is indicated by IAccessibleAction::nActions. |
| @param [out] anchorTarget |
| This is an implementation dependent value. For example this method could |
| return a BSTR VARIANT of the URI. Alternatively this method could return an |
| IUnknown VARIANT of a COM interface representing a target object to be |
| activated when the link is activated. See the section about |
| @ref _variants "VARIANTs" for additional information. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT anchorTarget |
| ( |
| [in] long index, |
| [out, retval] VARIANT *anchorTarget |
| ); |
| |
| /** @brief Returns the 0 based character offset at which the textual representation of the hyperlink starts. |
| |
| The returned value is related to the IAccessibleText interface of the object that |
| owns this hyperlink. |
| @param [out] index |
| @retval S_OK |
| */ |
| [propget] HRESULT startIndex |
| ( |
| [out, retval] long *index |
| ); |
| |
| /** @brief Returns the 0 based character offset at which the textual representation of the hyperlink ends. |
| |
| The returned value is related to the IAccessibleText interface of the object that |
| owns this hyperlink. The character at the index is not part of the hypertext. |
| @param [out] index |
| @retval S_OK |
| */ |
| [propget] HRESULT endIndex |
| ( |
| [out, retval] long *index |
| ); |
| |
| /** @brief Returns whether the target object referenced by this link is still valid. |
| |
| This is a volatile state that may change without sending an appropriate event. |
| Returns TRUE if the referenced target is still valid and FALSE otherwise. |
| |
| This has also been used to indicate whether or not the URI of the anchorTarget |
| is malformed. |
| |
| @param [out] valid |
| If false, one or more of the object's links are invalid. |
| If true, all of the object's links are valid. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is FALSE |
| @note This method is not being used, is deprecated, and should not be implemented or |
| used. It is likely that this method will be removed in a later version of the IDL. |
| */ |
| [propget] HRESULT valid |
| ( |
| [out, retval] boolean *valid |
| ); |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleHypertext.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| |
| /** @brief This interface exposes information about hypertext in a document. |
| |
| The %IAccessibleHypertext interface is the main interface to expose |
| hyperlinks in a document, typically a text document, that are used |
| to reference other documents. A typical implementation is to implement |
| this interface on the smallest text object such as a paragraph of text. |
| */ |
| [object, uuid(6B4F8BBF-F1F2-418a-B35E-A195BC4103B9)] |
| interface IAccessibleHypertext : IAccessibleText |
| { |
| |
| /** @brief Returns the number of links and link groups contained within this hypertext |
| paragraph. |
| @param [out] hyperlinkCount |
| The number of links and link groups within this hypertext paragraph. |
| Returns 0 if there is no link. |
| @retval S_OK |
| */ |
| [propget] HRESULT nHyperlinks |
| ( |
| [out, retval] long *hyperlinkCount |
| ); |
| |
| /** @brief Returns the specified link. |
| |
| The returned IAccessibleHyperlink object encapsulates the hyperlink and |
| provides several kinds of information describing it. |
| @param [in] index |
| This 0 based index specifies the hyperlink to return. |
| @param [out] hyperlink |
| If the given index is valid, i.e. lies in the interval from 0 to the number |
| of links minus one, a reference to the specified hyperlink object is returned. |
| If the index is invalid then a NULL pointer is returned. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT hyperlink |
| ( |
| [in] long index, |
| [out, retval] IAccessibleHyperlink **hyperlink |
| ); |
| |
| /** @brief Returns the index of the hyperlink that is associated with this character index. |
| |
| This is the case when a link spans the given character index. |
| @param [in] charIndex |
| A 0 based index of the character for which to return the link index. If |
| IAccessibleText is used to represent the text containing the link, then the |
| character index is only valid if it is greater than or equal to zero and |
| lower than the number of characters in the text. |
| @param [out] hyperlinkIndex |
| Returns the 0 based index of the hyperlink that is associated with this |
| character index, or -1 if charIndex is not on a link. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is -1 |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT hyperlinkIndex |
| ( |
| [in] long charIndex, |
| [out, retval] long *hyperlinkIndex |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleHypertext2.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| |
| /** @brief This interface exposes information about hypertext in a document. |
| |
| The %IAccessibleHypertext2 interface extends the functinality of the |
| %IAccessibleHypertext inteface. |
| */ |
| [object, uuid(CF64D89F-8287-4B44-8501-A827453A6077)] |
| interface IAccessibleHypertext2 : IAccessibleHypertext |
| { |
| |
| /** @brief Returns the links for this object. |
| |
| The returned IAccessibleHyperlink objects encapsulate the hyperlink and |
| provides several kinds of information describing it. |
| |
| @param [out] hyperlinks |
| This array is allocated by the server. The client must free it with CoTaskMemFree. |
| @param [out] nHyperlinks |
| The number of links returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are no links, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT hyperlinks |
| ( |
| [out, size_is(,*nHyperlinks)] IAccessibleHyperlink ***hyperlinks, |
| [out, retval] long *nHyperlinks |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleTable.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| |
| /** @brief This interface gives access to a two-dimensional table. |
| |
| Typically all accessible objects that represent cells or cell-clusters of a table |
| will be at the same time children of the table. In this case IAccessible2::indexInParent |
| will return the child index which then can be used when calling IAccessibleTable::rowIndex |
| and IAccessibleTable::columnIndex. |
| |
| However, in some cases that kind of implementation will not be possible. When |
| the table cells are not direct children of a table, the object representing |
| the cell can define a "table-cell-index" object attribute identifying the 0 |
| based table cell index. This object attribute is obtained by parsing the |
| attribute string returned by IAccessible2::attributes. The "table-cell-index" |
| attribute can be used just like a child index of the typical case. ATs should |
| first test for the presence of the "table-cell-index" attribute and if it is not |
| present then IAccessible2::indexInParent can be used as in the typical case |
| where cells are direct children of the table. |
| |
| The range of valid coordinates for this interface are implementation dependent. |
| However, that range includes at least the intervals from the from the first row |
| or column with the index 0 up to the last (but not including) used row or column |
| as returned by IAccessibleTable::nRows and IAccessibleTable::nColumns. |
| |
| Note that newer implementations are now using IAccessibleTable2 and IAccessibleTableCell |
| rather than this interface. |
| */ |
| [object, uuid(35AD8070-C20C-4fb4-B094-F4F7275DD469)] |
| interface IAccessibleTable : IUnknown |
| { |
| |
| /** @brief Returns the accessible object at the specified row and column in |
| the table. This object could be an IAccessible or an IAccessible2. |
| @param [in] row |
| The 0 based row index for which to retrieve the cell. |
| @param [in] column |
| The 0 based column index for which to retrieve the cell. |
| @param [out] accessible |
| If both row and column index are valid then the corresponding accessible |
| object is returned that represents the requested cell regardless of whether |
| the cell is currently visible (on the screen). |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is NULL |
| */ |
| [propget] HRESULT accessibleAt |
| ( |
| [in] long row, |
| [in] long column, |
| [out, retval] IUnknown **accessible |
| ); |
| |
| /** @brief Returns the caption for the table. The returned object could be |
| an IAccessible or an IAccessible2. |
| @param [out] accessible |
| If the table has a caption then a reference to it is returned, else a NULL |
| pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT caption |
| ( |
| [out, retval] IUnknown **accessible |
| ); |
| |
| /** @brief Translates the given row and column indexes into the corresponding cell index. |
| @param [in] rowIndex |
| 0 based row index for the cell. |
| @param [in] columnIndex |
| 0 based column index for the cell. |
| @param [out] cellIndex |
| Returns the 0 based index of the cell at the specified row and column indexes. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is 0 |
| @note The returned value is not necessarily a child index of the immediate parent. |
| In cases where the table cells are not direct children of the table the index |
| is actually the cell index, i.e. conceptually it's an index into a one dimensional |
| array of cells laid out in row order. |
| */ |
| [propget] HRESULT childIndex |
| ( |
| [in] long rowIndex, |
| [in] long columnIndex, |
| [out, retval] long *cellIndex |
| ); |
| |
| /** @brief Returns the description text of the specified column in the table. |
| @param [in] column |
| The 0 based index of the column for which to retrieve the description. |
| @param [out] description |
| Returns the description text of the specified column in the table if such a |
| description exists. Otherwise a NULL pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed, [out] value is NULL |
| */ |
| [propget] HRESULT columnDescription |
| ( |
| [in] long column, |
| [out, retval] BSTR *description |
| ); |
| |
| /** @brief Returns the number of columns occupied by the accessible object |
| at the specified row and column in the table. |
| |
| The result is greater than 1 if the specified cell spans multiple columns. |
| @param [in] row |
| 0 based row index of the accessible for which to return the column extent. |
| @param [in] column |
| 0 based column index of the accessible for which to return the column extent. |
| @param [out] nColumnsSpanned |
| Returns the 1 based column extent of the specified cell. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is 0 |
| */ |
| [propget] HRESULT columnExtentAt |
| ( |
| [in] long row, |
| [in] long column, |
| [out, retval] long *nColumnsSpanned |
| ); |
| |
| /** @brief Returns the column headers as an %IAccessibleTable object. |
| |
| Content and size of the returned table are implementation dependent. |
| @param [out] accessibleTable |
| The column header |
| @param [out] startingRowIndex |
| The 0 based row index where the header starts, usually 0. |
| @retval S_OK |
| @retval S_FALSE if there is no header, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT columnHeader |
| ( |
| [out] IAccessibleTable **accessibleTable, |
| [out, retval] long *startingRowIndex |
| ); |
| |
| /** @brief Translates the given cell index into the corresponding column index. |
| @param [in] cellIndex |
| 0 based index of the cell in the parent or closest ancestor table. Typically this |
| is the value returned from IAccessible2::indexInParent, but in the case where the |
| table cells are not direct children of the table this is the cell index specified |
| by the "table-cell-index" object attribute obtained from parsing the attributes |
| string returned by calling IAccessible2::attributes on the cell object. |
| @param [out] columnIndex |
| Returns the 0 based column index of the cell of the specified child or the index of |
| the first column if the child spans multiple columns. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is 0 |
| */ |
| [propget] HRESULT columnIndex |
| ( |
| [in] long cellIndex, |
| [out, retval] long *columnIndex |
| ); |
| |
| /** @brief Returns the total number of columns in table |
| @param [out] columnCount |
| Number of columns in table (including columns outside the current viewport) |
| @retval S_OK |
| */ |
| [propget] HRESULT nColumns |
| ( |
| [out, retval] long *columnCount |
| ); |
| |
| /** @brief Returns the total number of rows in table |
| @param [out] rowCount |
| Number of rows in table (including rows outside the current viewport) |
| @retval S_OK |
| */ |
| [propget] HRESULT nRows |
| ( |
| [out, retval] long *rowCount |
| ); |
| |
| /** @brief Returns the total number of selected cells |
| @param [out] cellCount |
| Number of cells currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedChildren |
| ( |
| [out, retval] long *cellCount |
| ); |
| |
| /** @brief Returns the total number of selected columns |
| @param [out] columnCount |
| Number of columns currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedColumns |
| ( |
| [out, retval] long *columnCount |
| ); |
| |
| /** @brief Returns the total number of selected rows |
| @param [out] rowCount |
| Number of rows currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedRows |
| ( |
| [out, retval] long *rowCount |
| ); |
| |
| /** @brief Returns the description text of the specified row in the table. |
| @param [in] row |
| The 0 based index of the row for which to retrieve the description. |
| @param [out] description |
| Returns the description text of the specified row in the table if such a |
| description exists. Otherwise a NULL pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed, [out] value is NULL |
| */ |
| [propget] HRESULT rowDescription |
| ( |
| [in] long row, |
| [out, retval] BSTR *description |
| ); |
| |
| /** @brief Returns the number of rows occupied by the accessible object |
| at the specified row and column in the table. |
| |
| The result is greater than 1 if the specified cell spans multiple rows. |
| @param [in] row |
| 0 based row index of the accessible for which to return the row extent. |
| @param [in] column |
| 0 based column index of the accessible for which to return the row extent. |
| @param [out] nRowsSpanned |
| Returns the row extent of the specified cell. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is 0 |
| */ |
| [propget] HRESULT rowExtentAt |
| ( |
| [in] long row, |
| [in] long column, |
| [out, retval] long *nRowsSpanned |
| ); |
| |
| /** @brief Returns the row headers as an %IAccessibleTable object. |
| |
| Content and size of the returned table are implementation dependent. |
| @param [out] accessibleTable |
| The row header. |
| @param [out] startingColumnIndex |
| The 0 based column index where the header starts, usually 0. |
| @retval S_OK |
| @retval S_FALSE if there is no header, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT rowHeader |
| ( |
| [out] IAccessibleTable **accessibleTable, |
| [out, retval] long *startingColumnIndex |
| ); |
| |
| /** @brief Translates the given cell index into a row index. |
| @param [in] cellIndex |
| 0 based index of the cell in the parent or closest ancestor table. Typically this |
| is the value returned from IAccessible2::indexInParent, but in the case where the |
| table cells are not direct children of the table this is the cell index specified |
| by the "table-cell-index" object attribute obtained from parsing the attributes |
| string returned by calling IAccessible2::attributes on the cell object. |
| @param [out] rowIndex |
| 0 based row index |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is 0 |
| */ |
| [propget] HRESULT rowIndex |
| ( |
| [in] long cellIndex, |
| [out, retval] long *rowIndex |
| ); |
| |
| /** @brief Returns a list of cell indexes currently selected (0 based). |
| @param [in] maxChildren |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] children |
| An array of cell indexes of selected cells (each index is 0 based), |
| allocated by the server. The client must free it with CoTaskMemFree. |
| @param [out] nChildren |
| The number of cell indexes returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedChildren |
| ( |
| [in] long maxChildren, |
| [out, size_is(,maxChildren), length_is(,*nChildren)] long **children, |
| [out, retval] long *nChildren |
| ); |
| |
| /** @brief Returns a list of column indexes currently selected (0 based). |
| @param [in] maxColumns |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] columns |
| An array of column indexes of selected columns (each index is 0 based), allocated |
| by the server. The client must free it with CoTaskMemFree. |
| @param [out] nColumns |
| The number of column indexes returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedColumns |
| ( |
| [in] long maxColumns, |
| [out, size_is(,maxColumns), length_is(,*nColumns)] long **columns, |
| [out, retval] long *nColumns |
| ); |
| |
| /** @brief Returns a list of row indexes currently selected (0 based). |
| @param [in] maxRows |
| This parameter is ignored. Refer to @ref _arrayConsideration |
| "Special Consideration when using Arrays" for more details. |
| @param [out] rows |
| An array of row indexes of selected rows (each index is 0 based), allocated |
| by the server. The client must free it with CoTaskMemFree. |
| @param [out] nRows |
| The number of row indexes returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedRows |
| ( |
| [in] long maxRows, |
| [out, size_is(,maxRows), length_is(,*nRows)] long **rows, |
| [out, retval] long *nRows |
| ); |
| |
| /** @brief Returns the summary description of the table. The returned object could be |
| an IAccessible or an IAccessible2. |
| @param [out] accessible |
| Returns a reference to an implementation dependent accessible object |
| representing the table's summary or a NULL pointer if the table |
| does not support a summary. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT summary |
| ( |
| [out, retval] IUnknown **accessible |
| ); |
| |
| /** @brief Returns a boolean value indicating whether the specified column is |
| completely selected. |
| @param [in] column |
| 0 based index of the column for which to determine whether it is selected. |
| @param [out] isSelected |
| Returns TRUE if the specified column is selected completely and FALSE otherwise. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is FALSE |
| */ |
| [propget] HRESULT isColumnSelected |
| ( |
| [in] long column, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Returns a boolean value indicating whether the specified row is completely |
| selected. |
| @param [in] row |
| 0 based index of the row for which to determine whether it is selected. |
| @param [out] isSelected |
| Returns TRUE if the specified row is selected completely and FALSE otherwise. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is FALSE |
| */ |
| [propget] HRESULT isRowSelected |
| ( |
| [in] long row, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Returns a boolean value indicating whether the specified cell is selected. |
| @param [in] row |
| 0 based index of the row for the cell to determine whether it is selected. |
| @param [in] column |
| 0 based index of the column for the cell to determine whether it is selected. |
| @param [out] isSelected |
| Returns TRUE if the specified cell is selected and FALSE otherwise. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] value is FALSE |
| */ |
| [propget] HRESULT isSelected |
| ( |
| [in] long row, |
| [in] long column, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Selects a row and unselects all previously selected rows. |
| @param [in] row |
| 0 based index of the row to be selected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT selectRow |
| ( |
| [in] long row |
| ); |
| |
| /** @brief Selects a column and unselects all previously selected columns. |
| @param [in] column |
| 0 based index of the column to be selected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT selectColumn |
| ( |
| [in] long column |
| ); |
| |
| /** @brief Unselects one row, leaving other selected rows selected (if any). |
| @param [in] row |
| 0 based index of the row to be unselected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT unselectRow |
| ( |
| [in] long row |
| ); |
| |
| /** @brief Unselects one column, leaving other selected columns selected (if any). |
| @param [in] column |
| 0 based index of the column to be unselected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT unselectColumn |
| ( |
| [in] long column |
| ); |
| |
| /** @brief Given a cell index, gets the row and column indexes and extents of a cell |
| and whether or not it is selected. |
| |
| This is a convenience function. It is not mandatory to implement it. |
| @param [in] index |
| 0 based index of this cell in the table. |
| @param [out] row |
| 0 based row index. |
| @param [out] column |
| 0 based column index. |
| @param [out] rowExtents |
| Number of cells spanned by this cell in this row. |
| @param [out] columnExtents |
| Number of cells spanned by this cell in this column. |
| @param [out] isSelected |
| Indicates if the specified cell is selected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed, [out] values are 0s and FALSE respectively |
| */ |
| [propget] HRESULT rowColumnExtentsAtIndex |
| ( |
| [in] long index, |
| [out] long *row, |
| [out] long *column, |
| [out] long *rowExtents, |
| [out] long *columnExtents, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Returns the type and extents describing how a table changed. |
| |
| Provided for use by the IA2_EVENT_TABLE_MODEL_CHANGED event handler. |
| |
| This data is only guaranteed to be valid while the thread notifying the event |
| continues. Once the handler has returned, the validity of the data depends on |
| how the server manages the life cycle of its objects. Also, note that the server |
| may have different life cycle management strategies for controls depending on |
| whether or not a control manages its children. Lists, trees, and tables can have |
| a large number of children and thus it's possible that the child objects for those |
| controls would only be created as needed. Servers should document their life cycle |
| strategy as this will be of interest to assistive technology or script engines |
| accessing data out of process or from other threads. Servers only need to save the |
| most recent row and column values associated with the change and a scope of the |
| entire application is adequate. |
| |
| @param [out] modelChange |
| A struct of (type(insert, delete, update), firstRow, lastRow, firstColumn, lastColumn). |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT modelChange |
| ( |
| [out, retval] IA2TableModelChange *modelChange |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleTable2.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2012 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| |
| /** @brief This interface gives access to a two-dimensional table. |
| |
| Please also refer to the IAccessibleTableCell interface. |
| |
| If you want to support older applications you should also support the |
| IAccessibleTable inteface. |
| */ |
| [object, uuid(6167f295-06f0-4cdd-a1fa-02e25153d869)] |
| interface IAccessibleTable2 : IUnknown |
| { |
| |
| /** @brief Returns the accessible object at the specified row and column in |
| the table. This object could be an IAccessible or an IAccessible2. |
| @param [in] row |
| The 0 based row index for which to retrieve the cell. |
| @param [in] column |
| The 0 based column index for which to retrieve the cell. |
| @param [out] cell |
| If both row and column index are valid then the corresponding accessible |
| object is returned that represents the requested cell regardless of whether |
| the cell is currently visible (on the screen). |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT cellAt |
| ( |
| [in] long row, |
| [in] long column, |
| [out, retval] IUnknown **cell |
| ); |
| |
| /** @brief Returns the caption for the table. The returned object could be |
| an IAccessible or an IAccessible2. |
| @param [out] accessible |
| If the table has a caption then a reference to it is returned, else a NULL |
| pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @deprecated use a describedBy relation |
| */ |
| [propget] HRESULT caption |
| ( |
| [out, retval] IUnknown **accessible |
| ); |
| |
| /** @brief Returns the description text of the specified column in the table. |
| @param [in] column |
| The 0 based index of the column for which to retrieve the description. |
| @param [out] description |
| Returns the description text of the specified column in the table if such a |
| description exists. Otherwise a NULL pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT columnDescription |
| ( |
| [in] long column, |
| [out, retval] BSTR *description |
| ); |
| |
| |
| /** @brief Returns the total number of columns in table |
| @param [out] columnCount |
| Number of columns in table (including columns outside the current viewport) |
| @retval S_OK |
| */ |
| [propget] HRESULT nColumns |
| ( |
| [out, retval] long *columnCount |
| ); |
| |
| /** @brief Returns the total number of rows in table |
| @param [out] rowCount |
| Number of rows in table (including rows outside the current viewport) |
| @retval S_OK |
| */ |
| [propget] HRESULT nRows |
| ( |
| [out, retval] long *rowCount |
| ); |
| |
| /** @brief Returns the total number of selected cells |
| @param [out] cellCount |
| Number of cells currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedCells |
| ( |
| [out, retval] long *cellCount |
| ); |
| |
| /** @brief Returns the total number of selected columns |
| @param [out] columnCount |
| Number of columns currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedColumns |
| ( |
| [out, retval] long *columnCount |
| ); |
| |
| /** @brief Returns the total number of selected rows |
| @param [out] rowCount |
| Number of rows currently selected |
| @retval S_OK |
| */ |
| [propget] HRESULT nSelectedRows |
| ( |
| [out, retval] long *rowCount |
| ); |
| |
| /** @brief Returns the description text of the specified row in the table. |
| @param [in] row |
| The 0 based index of the row for which to retrieve the description. |
| @param [out] description |
| Returns the description text of the specified row in the table if such a |
| description exists. Otherwise a NULL pointer is returned. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT rowDescription |
| ( |
| [in] long row, |
| [out, retval] BSTR *description |
| ); |
| |
| /** @brief Returns a list of accessibles currently selected. |
| @param [out] cells |
| Pointer to an array of references to selected accessibles. The array is |
| allocated by the server with CoTaskMemAlloc and freed by the client with |
| CoTaskMemFree. |
| @param [out] nSelectedCells |
| The number of accessibles returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedCells |
| ( |
| [out, size_is(,*nSelectedCells)] IUnknown ***cells, |
| [out, retval] long *nSelectedCells |
| ); |
| |
| /** @brief Returns a list of column indexes currently selected (0 based). |
| @param [out] selectedColumns |
| A pointer to an array of column indexes of selected columns (each index is |
| 0 based). The array is allocated by the server with CoTaskMemAlloc and |
| freed by the client with CoTaskMemFree. |
| @param [out] nColumns |
| The number of column indexes returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedColumns |
| ( |
| [out, size_is(,*nColumns)] long **selectedColumns, |
| [out, retval] long *nColumns |
| ); |
| |
| /** @brief Returns a list of row indexes currently selected (0 based). |
| @param [out] selectedRows |
| An array of row indexes of selected rows (each index is 0 based). The array |
| is allocated by the server with CoTaskMemAlloc and freed by the client with |
| CoTaskMemFree. |
| @param [out] nRows |
| The number of row indexes returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there are none, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT selectedRows |
| ( |
| [out, size_is(,*nRows)] long **selectedRows, |
| [out, retval] long *nRows |
| ); |
| |
| /** @brief Returns the summary description of the table. The returned object could be |
| an IAccessible or an IAccessible2. |
| @param [out] accessible |
| Returns a reference to an implementation dependent accessible object |
| representing the table's summary or a NULL pointer if the table |
| does not support a summary. |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| @deprecated Use the labeledBy relation |
| */ |
| [propget] HRESULT summary |
| ( |
| [out, retval] IUnknown **accessible |
| ); |
| |
| /** @brief Returns a boolean value indicating whether the specified column is |
| completely selected. |
| @param [in] column |
| 0 based index of the column for which to determine whether it is selected. |
| @param [out] isSelected |
| Returns TRUE if the specified column is selected completely and FALSE otherwise. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT isColumnSelected |
| ( |
| [in] long column, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Returns a boolean value indicating whether the specified row is completely |
| selected. |
| @param [in] row |
| 0 based index of the row for which to determine whether it is selected. |
| @param [out] isSelected |
| Returns TRUE if the specified row is selected completely and FALSE otherwise. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| [propget] HRESULT isRowSelected |
| ( |
| [in] long row, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Selects a row and unselects all previously selected rows. |
| |
| The behavior should mimic that of the application, but for those applications |
| which do not have a means in the GUI to select a full row of cells the behavior |
| should be as follows: First any selected rows in the table are unselected. Then |
| the entire row of cells for the specified row is selected. If any of the |
| cells in the selected row span additional rows, the cells in those rows |
| are also selected. |
| @param [in] row |
| 0 based index of the row to be selected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT selectRow |
| ( |
| [in] long row |
| ); |
| |
| /** @brief Selects a column and unselects all previously selected columns. |
| |
| The behavior should mimic that of the application, but for those applications |
| which do not have a means in the GUI to select a full column of cells the behavior |
| should be as follows: First any selected columns in the table are unselected. Then |
| the entire column of cells for the specified column is selected. If any of the |
| cells in the selected column span additional columns, the cells in those columns |
| are also selected. |
| @param [in] column |
| 0 based index of the column to be selected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT selectColumn |
| ( |
| [in] long column |
| ); |
| |
| /** @brief Unselects one row, leaving other selected rows selected (if any). |
| |
| The behavior should mimic that of the application, but for those applications |
| which do not have a means in the GUI to unselect a full row of cells the |
| behavior should be as follows: The entire row of cells for the specified |
| row is unselected. If any of the cells in the selected row span additional |
| rows, the cells in those rows are also unselected. |
| @param [in] row |
| 0 based index of the row to be unselected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT unselectRow |
| ( |
| [in] long row |
| ); |
| |
| /** @brief Unselects one column, leaving other selected columns selected (if any). |
| |
| The behavior should mimic that of the application, but for those applications |
| which do not have a means in the GUI to unselect a full column of cells the |
| behavior should be as follows: The entire column of cells for the specified |
| column is unselected. If any of the cells in the selected column span additional |
| columns, the cells in those columns are also unselected. |
| @param [in] column |
| 0 based index of the column to be unselected. |
| @retval S_OK |
| @retval E_INVALIDARG if bad [in] passed |
| */ |
| HRESULT unselectColumn |
| ( |
| [in] long column |
| ); |
| |
| /** @brief Returns the type and extents describing how a table changed. |
| |
| Provided for use by the IA2_EVENT_TABLE_MODEL_CHANGED event handler. |
| |
| This data is only guaranteed to be valid while the thread notifying the event |
| continues. Once the handler has returned, the validity of the data depends on |
| how the server manages the life cycle of its objects. Also, note that the server |
| may have different life cycle management strategies for controls depending on |
| whether or not a control manages its children. Lists, trees, and tables can have |
| a large number of children and thus it's possible that the child objects for those |
| controls would only be created as needed. Servers should document their life cycle |
| strategy as this will be of interest to assistive technology or script engines |
| accessing data out of process or from other threads. Servers only need to save the |
| most recent row and column values associated with the change and a scope of the |
| entire application is adequate. |
| |
| @param [out] modelChange |
| A struct of (type(insert, delete, update), firstRow, lastRow, firstColumn, lastColumn). |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT modelChange |
| ( |
| [out, retval] IA2TableModelChange *modelChange |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleTableCell.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2013 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface gives access to the cells of a two-dimensional table. |
| |
| Please also refer to the IAccessibleTable2 interface. |
| |
| */ |
| [object, uuid(594116B1-C99F-4847-AD06-0A7A86ECE645)] |
| interface IAccessibleTableCell : IUnknown |
| { |
| |
| /** @brief Returns the number of columns occupied by this cell accessible. |
| |
| The result is greater than 1 if the specified cell spans multiple columns. |
| @param [out] nColumnsSpanned |
| Returns the 1 based column extent of the specified cell. |
| @retval S_OK |
| */ |
| [propget] HRESULT columnExtent |
| ( |
| [out, retval] long *nColumnsSpanned |
| ); |
| |
| /** @brief Returns the column headers as an array of cell accessibles. |
| |
| @param [out] cellAccessibles |
| Pointer to an array of references to cell accessibles. The array is allocated |
| by the server. The client must free it with CoTaskMemFree. |
| @param [out] nColumnHeaderCells |
| The number of accessibles returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there is no header, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT columnHeaderCells |
| ( |
| [out, size_is(,*nColumnHeaderCells)] IUnknown ***cellAccessibles, |
| [out, retval] long *nColumnHeaderCells |
| ); |
| |
| /** @brief Translates this cell accessible into the corresponding column index. |
| |
| @param [out] columnIndex |
| Returns the 0 based column index of the cell of the specified cell or the index of |
| the first column if the cell spans multiple columns. |
| @retval S_OK |
| */ |
| [propget] HRESULT columnIndex |
| ( |
| [out, retval] long *columnIndex |
| ); |
| |
| /** @brief Returns the number of rows occupied by this cell accessible. |
| |
| @param [out] nRowsSpanned |
| Returns the row extent of the specified cell. |
| @retval S_OK |
| */ |
| [propget] HRESULT rowExtent |
| ( |
| [out, retval] long *nRowsSpanned |
| ); |
| |
| /** @brief Returns the row headers as an array of cell accessibles. |
| |
| @param [out] cellAccessibles |
| Pointer to an array of references to cell accessibles. The array is allocated |
| by the server. The client must free it with CoTaskMemFree. |
| @param [out] nRowHeaderCells |
| The number of accessibles returned; the size of the returned array. |
| @retval S_OK |
| @retval S_FALSE if there is no header, [out] values are NULL and 0 respectively |
| */ |
| [propget] HRESULT rowHeaderCells |
| ( |
| [out, size_is(,*nRowHeaderCells)] IUnknown ***cellAccessibles, |
| [out, retval] long *nRowHeaderCells |
| ); |
| |
| /** @brief Translates this cell accessible into the corresponding row index. |
| |
| @param [out] rowIndex |
| Returns the 0 based row index of the specified cell or the index of |
| the first row if the cell spans multiple rows. |
| @retval S_OK |
| */ |
| [propget] HRESULT rowIndex |
| ( |
| [out, retval] long *rowIndex |
| ); |
| |
| /** @brief Returns a boolean value indicating whether this cell is selected. |
| |
| @param [out] isSelected |
| Returns TRUE if the specified cell is selected and FALSE otherwise. |
| @retval S_OK |
| */ |
| [propget] HRESULT isSelected |
| ( |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Gets the row and column indexes and extents of this cell accessible |
| and whether or not it is selected. |
| |
| This is a convenience function. It is not mandatory to implement it. |
| @param [out] row |
| 0 based row index. |
| @param [out] column |
| 0 based column index. |
| @param [out] rowExtents |
| Number of cells spanned by this cell in this row. |
| @param [out] columnExtents |
| Number of cells spanned by this cell in this column. |
| @param [out] isSelected |
| Indicates if the specified cell is selected. |
| @retval S_OK |
| */ |
| [propget] HRESULT rowColumnExtents |
| ( |
| [out] long *row, |
| [out] long *column, |
| [out] long *rowExtents, |
| [out] long *columnExtents, |
| [out, retval] boolean *isSelected |
| ); |
| |
| /** @brief Returns a reference to the accessbile of the containing table. |
| |
| @param [out] table |
| Returns a reference to the IUnknown of the containing table. |
| @retval S_OK |
| */ |
| [propget] HRESULT table |
| ( |
| [out, retval] IUnknown **table |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleImage.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface represents images and icons. |
| |
| This interface is used for a representation of images like icons on buttons. |
| %IAccessibleImage only needs to be implemented in certain situations. Some |
| examples are: |
| <ol> |
| <li>The accessible name and description are not enough to fully |
| describe the image, e.g. when the accessible description is used to define the |
| behavior of an actionable image and the image itself conveys semantically |
| significant information. |
| <li>The user can edit the content that includes an |
| image and therefore the user needs to be able to review the image's position. |
| </ol> |
| */ |
| [object, uuid(FE5ABB3D-615E-4f7b-909F-5F0EDA9E8DDE)] |
| interface IAccessibleImage : IUnknown |
| { |
| /** @brief Returns the localized description of the image. |
| @param [out] description |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT description |
| ( |
| [out, retval] BSTR *description |
| ); |
| |
| /** @brief Returns the coordinates of the image. |
| @param [in] coordinateType |
| Specifies whether the returned coordinates should be relative to the screen or the parent object. |
| @param [out] x |
| @param [out] y |
| @retval S_OK |
| */ |
| [propget] HRESULT imagePosition |
| ( |
| [in] enum IA2CoordinateType coordinateType, |
| [out] long *x, |
| [out, retval] long *y |
| ); |
| |
| /** @brief Returns the size of the image in units specified by parent's coordinate system. |
| @param [out] height |
| @param [out] width |
| @retval S_OK |
| */ |
| |
| [propget] HRESULT imageSize |
| ( |
| [out] long *height, |
| [out, retval] long *width |
| ); |
| } |
| /************************************************************************* |
| * |
| * File Name (AccessibleEventID.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| /** %IAccessible2 specific event constants |
| |
| This enum defines the event IDs fired by %IAccessible2 objects. The event IDs |
| are in addition to those used by MSAA. |
| */ |
| enum IA2EventID { |
| |
| /** The change of the number or attributes of actions of an accessible |
| object is signaled by events of this type. |
| */ |
| IA2_EVENT_ACTION_CHANGED = 0x101, |
| |
| /** <b>Deprecated.</b> The active descendant of a component has changed. |
| |
| Note: This event constant is misspelled and thus is deprecated and will be |
| removed in a later version. Please use the correctly spelled version which |
| follows. |
| */ |
| IA2_EVENT_ACTIVE_DECENDENT_CHANGED, |
| |
| /** The active descendant of a component has changed. The active descendant |
| is used in objects with transient children. |
| |
| Note: Due to the fact that MSAA's WinEvents don't allow the active child index |
| to be passed on the IA2_EVENT_ACTIVE_DESCENDANT_CHANGED event the manages |
| descendants scheme can't be used. Instead the active child object has to fire |
| MSAA's EVENT_OBJECT_FOCUS. In a future release a new event mechanism may be |
| added to provide for event specific data to be passed with the event. At that |
| time the IA2_EVENT_ACTIVE_DECENDENT_CHANGED event and |
| IA2_STATE_MANAGES_DESCENDANTS state would be useful. |
| */ |
| IA2_EVENT_ACTIVE_DESCENDANT_CHANGED = IA2_EVENT_ACTIVE_DECENDENT_CHANGED, |
| |
| /** The document wide attributes of the document object have changed. |
| */ |
| IA2_EVENT_DOCUMENT_ATTRIBUTE_CHANGED, |
| |
| /** The contents of the document have changed. |
| */ |
| IA2_EVENT_DOCUMENT_CONTENT_CHANGED, |
| |
| /** The loading of the document has completed. |
| */ |
| IA2_EVENT_DOCUMENT_LOAD_COMPLETE, |
| |
| /** The loading of the document was interrupted. |
| */ |
| IA2_EVENT_DOCUMENT_LOAD_STOPPED, |
| |
| /** The document contents are being reloaded. |
| */ |
| IA2_EVENT_DOCUMENT_RELOAD, |
| |
| /** The ending index of this link within the containing string has changed. |
| */ |
| IA2_EVENT_HYPERLINK_END_INDEX_CHANGED, |
| |
| /** The number of anchors associated with this hyperlink object has changed. |
| */ |
| IA2_EVENT_HYPERLINK_NUMBER_OF_ANCHORS_CHANGED, |
| |
| /** The hyperlink selected state changed from selected to unselected or |
| from unselected to selected. |
| */ |
| IA2_EVENT_HYPERLINK_SELECTED_LINK_CHANGED, |
| |
| /** One of the links associated with the hypertext object has been activated. |
| */ |
| IA2_EVENT_HYPERTEXT_LINK_ACTIVATED, |
| |
| /** One of the links associated with the hypertext object has been selected. |
| */ |
| IA2_EVENT_HYPERTEXT_LINK_SELECTED, |
| |
| /** The starting index of this link within the containing string has changed. |
| */ |
| IA2_EVENT_HYPERLINK_START_INDEX_CHANGED, |
| |
| /** Focus has changed from one hypertext object to another, or focus moved |
| from a non-hypertext object to a hypertext object, or focus moved from a |
| hypertext object to a non-hypertext object. |
| */ |
| IA2_EVENT_HYPERTEXT_CHANGED, |
| |
| /** The number of hyperlinks associated with a hypertext object changed |
| */ |
| IA2_EVENT_HYPERTEXT_NLINKS_CHANGED, |
| |
| /** An object's attributes changed. |
| Also see ::IA2_EVENT_TEXT_ATTRIBUTE_CHANGED. |
| */ |
| IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED, |
| |
| /** A slide changed in a presentation document or a page boundary was |
| crossed in a word processing document. |
| */ |
| IA2_EVENT_PAGE_CHANGED, |
| |
| /** The caret moved from one section to the next. |
| */ |
| IA2_EVENT_SECTION_CHANGED, |
| |
| /** A table caption changed. |
| */ |
| IA2_EVENT_TABLE_CAPTION_CHANGED, |
| |
| /** A table's column description changed. |
| */ |
| IA2_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED, |
| |
| /** A table's column header changed. |
| */ |
| IA2_EVENT_TABLE_COLUMN_HEADER_CHANGED, |
| |
| /** A table's data changed. |
| */ |
| IA2_EVENT_TABLE_MODEL_CHANGED, |
| |
| /** A table's row description changed. |
| */ |
| IA2_EVENT_TABLE_ROW_DESCRIPTION_CHANGED, |
| |
| /** A table's row header changed. |
| */ |
| IA2_EVENT_TABLE_ROW_HEADER_CHANGED, |
| |
| /** A table's summary changed. |
| */ |
| IA2_EVENT_TABLE_SUMMARY_CHANGED, |
| |
| /** A text object's attributes changed. |
| Also see ::IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED. |
| */ |
| IA2_EVENT_TEXT_ATTRIBUTE_CHANGED, |
| |
| /** The caret has moved to a new position. |
| */ |
| IA2_EVENT_TEXT_CARET_MOVED, |
| |
| /** <b>Deprecated.</b> This event is equivalent to ::IA2_EVENT_TEXT_UPDATED. |
| */ |
| IA2_EVENT_TEXT_CHANGED, |
| |
| /** The caret moved from one column to the next. |
| */ |
| IA2_EVENT_TEXT_COLUMN_CHANGED, |
| |
| /** Text was inserted. |
| */ |
| IA2_EVENT_TEXT_INSERTED, |
| |
| /** Text was removed. |
| */ |
| IA2_EVENT_TEXT_REMOVED, |
| |
| /** This event indicates general text changes, i.e. changes to text that are |
| exposed through the IAccessibleText interface. For compatibility with ATK/AT-SPI |
| which does not have an equivalent event, servers can alternatively fire |
| ::IA2_EVENT_TEXT_REMOVED and ::IA2_EVENT_TEXT_INSERTED. |
| */ |
| IA2_EVENT_TEXT_UPDATED, |
| |
| /** The text selection changed. Later versions of Microsoft development environments |
| have an equivalent event identified, EVENT_OBJECT_TEXTSELECTIONCHANGED. Servers |
| should use that if it is available and use IA2_EVENT_TEXT_SELECTION_CHANGED otherwise. |
| Clients should be prepared to respond to either event. |
| |
| */ |
| IA2_EVENT_TEXT_SELECTION_CHANGED, |
| |
| /** A visible data event indicates the change of the visual appearance |
| of an accessible object. This includes for example most of the |
| attributes available via the IAccessibleComponent interface. |
| */ |
| IA2_EVENT_VISIBLE_DATA_CHANGED |
| |
| }; |
| /************************************************************************* |
| * |
| * File Name (AccessibleApplication.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2010 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| |
| /** @brief This interface gives access to the application's name and version information. |
| |
| This interface provides the AT with the information it needs to differentiate |
| this application from other applications, from other versions of this |
| application, or from other versions of this application running on different |
| versions of an accessibility bridge or accessibility toolkit. |
| |
| Servers implementing IAccessible2 should provide access to the %IAccessibleApplication |
| interface via QueryService from any object so that ATs can easily determine specific |
| information about the application such as its name or version. |
| */ |
| [object, uuid(D49DED83-5B25-43F4-9B95-93B44595979E)] |
| interface IAccessibleApplication : IUnknown |
| { |
| |
| /** @brief Returns the application name. |
| @param [out] name |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT appName |
| ( |
| [out, retval] BSTR *name |
| ); |
| |
| /** @brief Returns the application version. |
| @param [out] version |
| The version string must not contain levels when it is know beforehand that |
| this information will never require a change in a client's behavior. |
| For example, use "3.6.0" rather than "3.6.0.v201005131500". |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT appVersion |
| ( |
| [out, retval] BSTR *version |
| ); |
| |
| /** @brief Returns the toolkit/bridge name. |
| @param [out] name |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT toolkitName |
| ( |
| [out, retval] BSTR *name |
| ); |
| |
| /** @brief Returns the toolkit/bridge version. |
| @param [out] version |
| The version string must not contain levels when it is know beforehand that |
| this information will never require a change in a client's behavior. |
| For example, use "3.6.0" rather than "3.6.0.v201005131500". |
| @retval S_OK |
| @retval S_FALSE if there is nothing to return, [out] value is NULL |
| */ |
| [propget] HRESULT toolkitVersion |
| ( |
| [out, retval] BSTR *version |
| ); |
| |
| } |
| |
| /************************************************************************* |
| * |
| * File Name (AccessibleDocument.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2013 Linux Foundation |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| |
| |
| |
| |
| /** @brief This interface represents documents. |
| |
| This interface is used for a representation of documents. |
| */ |
| [object, uuid(C48C7FCF-4AB5-4056-AFA6-902D6E1D1149)] |
| interface IAccessibleDocument : IUnknown |
| { |
| /** @brief Returns the most recently used anchor target within a document. |
| |
| A document's most recently targeted in-page anchor is returned. A typical use |
| of this method is to fetch the anchor target within an HTML document. In this |
| case anchor targets are those which have been defined with the <a> tag. |
| |
| @param [out] accessible |
| @retval S_OK |
| @retval S_FALSE if there are no existing valid anchor targets, [out] value is NULL. |
| */ |
| [propget] HRESULT anchorTarget |
| ( |
| [out, retval] IUnknown **accessible |
| ); |
| |
| } |
| /************************************************************************* |
| * |
| * File Name (IA2TypeLibrary.idl) |
| * |
| * IAccessible2 IDL Specification |
| * |
| * Copyright (c) 2007, 2012 Linux Foundation |
| * Copyright (c) 2006 IBM Corporation |
| * Copyright (c) 2000, 2006 Sun Microsystems, Inc. |
| * All rights reserved. |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * 3. Neither the name of the Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products |
| * derived from this software without specific prior written |
| * permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * This BSD License conforms to the Open Source Initiative "Simplified |
| * BSD License" as published at: |
| * http://www.opensource.org/licenses/bsd-license.php |
| * |
| * IAccessible2 is a trademark of the Linux Foundation. The IAccessible2 |
| * mark may be used in accordance with the Linux Foundation Trademark |
| * Policy to indicate compliance with the IAccessible2 specification. |
| * |
| ************************************************************************/ |
| |
| // This is not a standalone file. It is to be appended to the end of the |
| // merged IDL file. |
| |
| cpp_quote("") |
| cpp_quote("// Type Library Definitions") |
| cpp_quote("") |
| |
| [ |
| uuid(CE3F726E-D1D3-44FE-B995-FF1DB3B48B2B), |
| helpstring("IAccessible2 Type Library"), |
| version(1.3), |
| hidden |
| ] |
| |
| library IAccessible2Lib |
| { |
| importlib ("stdole2.tlb"); |
| importlib ("oleacc.dll"); |
| interface IAccessible2; |
| interface IAccessible2_2; |
| interface IAccessibleAction; |
| interface IAccessibleApplication; |
| interface IAccessibleComponent; |
| interface IAccessibleDocument; |
| interface IAccessibleEditableText; |
| interface IAccessibleHyperlink; |
| interface IAccessibleHypertext; |
| interface IAccessibleHypertext2; |
| interface IAccessibleImage; |
| interface IAccessibleRelation; |
| interface IAccessibleTable; |
| interface IAccessibleTable2; |
| interface IAccessibleTableCell; |
| interface IAccessibleText; |
| interface IAccessibleText2; |
| interface IAccessibleValue; |
| enum IA2CoordinateType; |
| enum IA2EventID; |
| enum IA2Role; |
| enum IA2ScrollType; |
| enum IA2States; |
| enum IA2TableModelChangeType; |
| enum IA2TextBoundaryType; |
| enum IA2TextSpecialOffsets; |
| } |