This file is indexed.

/usr/share/idl/thunderbird/nsIAccessible.idl is in thunderbird-dev 1:52.8.0-1~deb8u1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISupports.idl"
#include "nsIArray.idl"

interface nsIPersistentProperties;
interface nsIDOMCSSPrimitiveValue;
interface nsIDOMNode;
interface nsIAccessibleDocument;
interface nsIAccessibleRelation;

%{C++
namespace mozilla {
namespace a11y {
class Accessible;
}
}
%}

/**
 * A cross-platform interface that supports platform-specific 
 * accessibility APIs like MSAA and ATK. Contains the sum of what's needed
 * to support IAccessible as well as ATK's generic accessibility objects.
 * Can also be used by in-process accessibility clients to get information
 * about objects in the accessible tree. The accessible tree is a subset of 
 * nodes in the DOM tree -- such as documents, focusable elements and text.
 * Mozilla creates the implementations of nsIAccessible on demand.
 * See http://www.mozilla.org/projects/ui/accessibility for more information.
 */
[scriptable, builtinclass, uuid(de2869d9-563c-4943-996b-31a4daa4d097)]
interface nsIAccessible : nsISupports
{
  /**
   * Parent node in accessible tree.
   */
  readonly attribute nsIAccessible parent;

  /**
   * Next sibling in accessible tree
   */
  readonly attribute nsIAccessible nextSibling;

  /**
   * Previous sibling in accessible tree
   */
  readonly attribute nsIAccessible previousSibling;

  /**
   * First child in accessible tree
   */
  readonly attribute nsIAccessible firstChild;

  /**
   * Last child in accessible tree
   */
  readonly attribute nsIAccessible lastChild;
  
  /**
   * Array of all this element's children.
   */
  readonly attribute nsIArray children;

  /**
   * Number of accessible children
   */
  readonly attribute long childCount;

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

  /**
   * The DOM node this nsIAccessible is associated with.
   */
  readonly attribute nsIDOMNode DOMNode;

  /**
    * For remote accessibles the id of the related DOM node.
    */
  readonly attribute DOMString id;

  /**
   * The document accessible that this access node resides in.
   */
  readonly attribute nsIAccessibleDocument document;

  /**
   * The root document accessible that this access node resides in.
   */
  readonly attribute nsIAccessibleDocument rootDocument;

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

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

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

  /**
   * Accessible description -- long text associated with this node
   */
  readonly attribute AString description;

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

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

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

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

  /**
   * Help text associated with node
   *
   * @note As of now, this just returns empty string.
   */
  readonly attribute AString help;

  /**
   * Focused accessible child of node
   */
  readonly attribute nsIAccessible focusedChild;

  /**
   * Attributes of accessible
   */
  readonly attribute nsIPersistentProperties attributes;

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

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

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

  /**
   * Nth accessible child using zero-based index or last child if index less than zero
   */
  nsIAccessible getChildAt(in long aChildIndex);

  /**
   * Return accessible relation by the given relation type (see.
   * constants defined in nsIAccessibleRelation).
   */
  nsIAccessibleRelation getRelationByType(in unsigned long aRelationType);

  /**
   * Returns multiple accessible relations for this object.
   */
  nsIArray getRelations();

  /**
   * Return accessible's x and y coordinates relative to the screen and
   * accessible's width and height.
   */
  void getBounds(out long x, out long y, out long width, out long height);

  /**
   * Add or remove this accessible to the current selection
   */
  void setSelected(in boolean isSelected);

  /**
   * Select this accessible node only
   */
  void takeSelection();

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

  /**
   * The number of accessible actions associated with this accessible
   */
  readonly attribute uint8_t actionCount;

  /**
   * The name of the accessible action at the given zero-based index
   */
  AString getActionName(in uint8_t index);

  /**
   * The description of the accessible action at the given zero-based index
   */
  AString getActionDescription(in uint8_t aIndex);

  /**
   * Perform the accessible action at the given zero-based index
   * Action number 0 is the default action
   */
  void doAction(in uint8_t index);

  /**
   * Makes an object visible on screen.
   *
   * @param scrollType - defines where the object should be placed on
   *                     the screen (see nsIAccessibleScrollType for
   *                     available constants).
   */
  void scrollTo(in unsigned long aScrollType);

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

  %{C++
  virtual mozilla::a11y::Accessible* ToInternalAccessible() const = 0;
  %}

};