/************************************************************************* | |
* | |
* 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; | |
} |