path: root/winaccessibility/source/UAccCOMIDL/ia2_api_all.idl

/*************************************************************************
 *
 *  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
 &nbsp;&nbsp;@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&reg; Win32&reg; 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&reg;.

  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&reg; Active Accessibility&reg;) 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&reg; 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 &lt;a&gt; 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;
}