1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include "DocAccessibleChild.h"
8
9 #include "Accessible-inl.h"
10 #include "ProxyAccessible.h"
11 #include "Relation.h"
12 #include "HyperTextAccessible-inl.h"
13 #include "TextLeafAccessible.h"
14 #include "ImageAccessible.h"
15 #include "TableAccessible.h"
16 #include "TableCellAccessible.h"
17 #include "nsIPersistentProperties2.h"
18 #include "nsISimpleEnumerator.h"
19 #include "nsAccUtils.h"
20 #ifdef MOZ_ACCESSIBILITY_ATK
21 #include "AccessibleWrap.h"
22 #endif
23
24 namespace mozilla {
25 namespace a11y {
26
27 Accessible*
IdToAccessible(const uint64_t & aID) const28 DocAccessibleChild::IdToAccessible(const uint64_t& aID) const
29 {
30 if (!aID)
31 return mDoc;
32
33 if (!mDoc)
34 return nullptr;
35
36 return mDoc->GetAccessibleByUniqueID(reinterpret_cast<void*>(aID));
37 }
38
39 Accessible*
IdToAccessibleLink(const uint64_t & aID) const40 DocAccessibleChild::IdToAccessibleLink(const uint64_t& aID) const
41 {
42 Accessible* acc = IdToAccessible(aID);
43 return acc && acc->IsLink() ? acc : nullptr;
44 }
45
46 Accessible*
IdToAccessibleSelect(const uint64_t & aID) const47 DocAccessibleChild::IdToAccessibleSelect(const uint64_t& aID) const
48 {
49 Accessible* acc = IdToAccessible(aID);
50 return acc && acc->IsSelect() ? acc : nullptr;
51 }
52
53 HyperTextAccessible*
IdToHyperTextAccessible(const uint64_t & aID) const54 DocAccessibleChild::IdToHyperTextAccessible(const uint64_t& aID) const
55 {
56 Accessible* acc = IdToAccessible(aID);
57 return acc && acc->IsHyperText() ? acc->AsHyperText() : nullptr;
58 }
59
60 TextLeafAccessible*
IdToTextLeafAccessible(const uint64_t & aID) const61 DocAccessibleChild::IdToTextLeafAccessible(const uint64_t& aID) const
62 {
63 Accessible* acc = IdToAccessible(aID);
64 return acc && acc->IsTextLeaf() ? acc->AsTextLeaf() : nullptr;
65 }
66
67 ImageAccessible*
IdToImageAccessible(const uint64_t & aID) const68 DocAccessibleChild::IdToImageAccessible(const uint64_t& aID) const
69 {
70 Accessible* acc = IdToAccessible(aID);
71 return (acc && acc->IsImage()) ? acc->AsImage() : nullptr;
72 }
73
74 TableCellAccessible*
IdToTableCellAccessible(const uint64_t & aID) const75 DocAccessibleChild::IdToTableCellAccessible(const uint64_t& aID) const
76 {
77 Accessible* acc = IdToAccessible(aID);
78 return (acc && acc->IsTableCell()) ? acc->AsTableCell() : nullptr;
79 }
80
81 TableAccessible*
IdToTableAccessible(const uint64_t & aID) const82 DocAccessibleChild::IdToTableAccessible(const uint64_t& aID) const
83 {
84 Accessible* acc = IdToAccessible(aID);
85 return (acc && acc->IsTable()) ? acc->AsTable() : nullptr;
86 }
87
88 bool
RecvState(const uint64_t & aID,uint64_t * aState)89 DocAccessibleChild::RecvState(const uint64_t& aID, uint64_t* aState)
90 {
91 Accessible* acc = IdToAccessible(aID);
92 if (!acc) {
93 *aState = states::DEFUNCT;
94 return true;
95 }
96
97 *aState = acc->State();
98
99 return true;
100 }
101
102 bool
RecvNativeState(const uint64_t & aID,uint64_t * aState)103 DocAccessibleChild::RecvNativeState(const uint64_t& aID, uint64_t* aState)
104 {
105 Accessible* acc = IdToAccessible(aID);
106 if (!acc) {
107 *aState = states::DEFUNCT;
108 return true;
109 }
110
111 *aState = acc->NativeState();
112
113 return true;
114 }
115
116 bool
RecvName(const uint64_t & aID,nsString * aName)117 DocAccessibleChild::RecvName(const uint64_t& aID, nsString* aName)
118 {
119 Accessible* acc = IdToAccessible(aID);
120 if (!acc)
121 return true;
122
123 acc->Name(*aName);
124 return true;
125 }
126
127 bool
RecvValue(const uint64_t & aID,nsString * aValue)128 DocAccessibleChild::RecvValue(const uint64_t& aID, nsString* aValue)
129 {
130 Accessible* acc = IdToAccessible(aID);
131 if (!acc) {
132 return true;
133 }
134
135 acc->Value(*aValue);
136 return true;
137 }
138
139 bool
RecvHelp(const uint64_t & aID,nsString * aHelp)140 DocAccessibleChild::RecvHelp(const uint64_t& aID, nsString* aHelp)
141 {
142 Accessible* acc = IdToAccessible(aID);
143 if (!acc) {
144 return true;
145 }
146
147 acc->Help(*aHelp);
148 return true;
149 }
150
151 bool
RecvDescription(const uint64_t & aID,nsString * aDesc)152 DocAccessibleChild::RecvDescription(const uint64_t& aID, nsString* aDesc)
153 {
154 Accessible* acc = IdToAccessible(aID);
155 if (!acc)
156 return true;
157
158 acc->Description(*aDesc);
159 return true;
160 }
161
162 bool
RecvAttributes(const uint64_t & aID,nsTArray<Attribute> * aAttributes)163 DocAccessibleChild::RecvAttributes(const uint64_t& aID, nsTArray<Attribute>* aAttributes)
164 {
165 Accessible* acc = IdToAccessible(aID);
166 if (!acc)
167 return true;
168
169 nsCOMPtr<nsIPersistentProperties> props = acc->Attributes();
170 return PersistentPropertiesToArray(props, aAttributes);
171 }
172
173 bool
PersistentPropertiesToArray(nsIPersistentProperties * aProps,nsTArray<Attribute> * aAttributes)174 DocAccessibleChild::PersistentPropertiesToArray(nsIPersistentProperties* aProps,
175 nsTArray<Attribute>* aAttributes)
176 {
177 if (!aProps) {
178 return true;
179 }
180 nsCOMPtr<nsISimpleEnumerator> propEnum;
181 nsresult rv = aProps->Enumerate(getter_AddRefs(propEnum));
182 NS_ENSURE_SUCCESS(rv, false);
183
184 bool hasMore;
185 while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) && hasMore) {
186 nsCOMPtr<nsISupports> sup;
187 rv = propEnum->GetNext(getter_AddRefs(sup));
188 NS_ENSURE_SUCCESS(rv, false);
189
190 nsCOMPtr<nsIPropertyElement> propElem(do_QueryInterface(sup));
191 NS_ENSURE_TRUE(propElem, false);
192
193 nsAutoCString name;
194 rv = propElem->GetKey(name);
195 NS_ENSURE_SUCCESS(rv, false);
196
197 nsAutoString value;
198 rv = propElem->GetValue(value);
199 NS_ENSURE_SUCCESS(rv, false);
200
201 aAttributes->AppendElement(Attribute(name, value));
202 }
203
204 return true;
205 }
206
207 bool
RecvRelationByType(const uint64_t & aID,const uint32_t & aType,nsTArray<uint64_t> * aTargets)208 DocAccessibleChild::RecvRelationByType(const uint64_t& aID,
209 const uint32_t& aType,
210 nsTArray<uint64_t>* aTargets)
211 {
212 Accessible* acc = IdToAccessible(aID);
213 if (!acc)
214 return true;
215
216 auto type = static_cast<RelationType>(aType);
217 Relation rel = acc->RelationByType(type);
218 while (Accessible* target = rel.Next())
219 aTargets->AppendElement(reinterpret_cast<uintptr_t>(target));
220
221 return true;
222 }
223
224 static void
AddRelation(Accessible * aAcc,RelationType aType,nsTArray<RelationTargets> * aTargets)225 AddRelation(Accessible* aAcc, RelationType aType,
226 nsTArray<RelationTargets>* aTargets)
227 {
228 Relation rel = aAcc->RelationByType(aType);
229 nsTArray<uint64_t> targets;
230 while (Accessible* target = rel.Next())
231 targets.AppendElement(reinterpret_cast<uintptr_t>(target));
232
233 if (!targets.IsEmpty()) {
234 RelationTargets* newRelation =
235 aTargets->AppendElement(RelationTargets(static_cast<uint32_t>(aType),
236 nsTArray<uint64_t>()));
237 newRelation->Targets().SwapElements(targets);
238 }
239 }
240
241 bool
RecvRelations(const uint64_t & aID,nsTArray<RelationTargets> * aRelations)242 DocAccessibleChild::RecvRelations(const uint64_t& aID,
243 nsTArray<RelationTargets>* aRelations)
244 {
245 Accessible* acc = IdToAccessible(aID);
246 if (!acc)
247 return true;
248
249 #define RELATIONTYPE(gecko, s, a, m, i) AddRelation(acc, RelationType::gecko, aRelations);
250
251 #include "RelationTypeMap.h"
252 #undef RELATIONTYPE
253
254 return true;
255 }
256
257 bool
RecvIsSearchbox(const uint64_t & aID,bool * aRetVal)258 DocAccessibleChild::RecvIsSearchbox(const uint64_t& aID, bool* aRetVal)
259 {
260 Accessible* acc = IdToAccessible(aID);
261 if (!acc)
262 return true;
263
264 *aRetVal = acc->IsSearchbox();
265 return true;
266 }
267
268 bool
RecvLandmarkRole(const uint64_t & aID,nsString * aLandmark)269 DocAccessibleChild::RecvLandmarkRole(const uint64_t& aID, nsString* aLandmark)
270 {
271 Accessible* acc = IdToAccessible(aID);
272 if (!acc) {
273 return true;
274 }
275
276 if (nsIAtom* roleAtom = acc->LandmarkRole()) {
277 roleAtom->ToString(*aLandmark);
278 }
279
280 return true;
281 }
282
283 bool
RecvARIARoleAtom(const uint64_t & aID,nsString * aRole)284 DocAccessibleChild::RecvARIARoleAtom(const uint64_t& aID, nsString* aRole)
285 {
286 Accessible* acc = IdToAccessible(aID);
287 if (!acc) {
288 return true;
289 }
290
291 if (const nsRoleMapEntry* roleMap = acc->ARIARoleMap()) {
292 if (nsIAtom* roleAtom = *(roleMap->roleAtom)) {
293 roleAtom->ToString(*aRole);
294 }
295 }
296
297 return true;
298 }
299
300 bool
RecvGetLevelInternal(const uint64_t & aID,int32_t * aLevel)301 DocAccessibleChild::RecvGetLevelInternal(const uint64_t& aID, int32_t* aLevel)
302 {
303 Accessible* acc = IdToAccessible(aID);
304 if (acc) {
305 *aLevel = acc->GetLevelInternal();
306 }
307 return true;
308 }
309
310 bool
RecvScrollTo(const uint64_t & aID,const uint32_t & aScrollType)311 DocAccessibleChild::RecvScrollTo(const uint64_t& aID,
312 const uint32_t& aScrollType)
313 {
314 Accessible* acc = IdToAccessible(aID);
315 if (acc) {
316 nsCoreUtils::ScrollTo(acc->Document()->PresShell(), acc->GetContent(),
317 aScrollType);
318 }
319
320 return true;
321 }
322
323 bool
RecvScrollToPoint(const uint64_t & aID,const uint32_t & aScrollType,const int32_t & aX,const int32_t & aY)324 DocAccessibleChild::RecvScrollToPoint(const uint64_t& aID, const uint32_t& aScrollType, const int32_t& aX, const int32_t& aY)
325 {
326 Accessible* acc = IdToAccessible(aID);
327 if (acc) {
328 acc->ScrollToPoint(aScrollType, aX, aY);
329 }
330
331 return true;
332 }
333
334 bool
RecvCaretLineNumber(const uint64_t & aID,int32_t * aLineNumber)335 DocAccessibleChild::RecvCaretLineNumber(const uint64_t& aID, int32_t* aLineNumber)
336 {
337 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
338 *aLineNumber = acc && acc->IsTextRole() ? acc->CaretLineNumber() : 0;
339 return true;
340 }
341
342 bool
RecvCaretOffset(const uint64_t & aID,int32_t * aOffset)343 DocAccessibleChild::RecvCaretOffset(const uint64_t& aID, int32_t* aOffset)
344 {
345 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
346 *aOffset = acc && acc->IsTextRole() ? acc->CaretOffset() : 0;
347 return true;
348 }
349
350 bool
RecvSetCaretOffset(const uint64_t & aID,const int32_t & aOffset)351 DocAccessibleChild::RecvSetCaretOffset(const uint64_t& aID,
352 const int32_t& aOffset)
353 {
354 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
355 if (acc && acc->IsTextRole() && acc->IsValidOffset(aOffset)) {
356 acc->SetCaretOffset(aOffset);
357 }
358 return true;
359 }
360
361 bool
RecvCharacterCount(const uint64_t & aID,int32_t * aCount)362 DocAccessibleChild::RecvCharacterCount(const uint64_t& aID, int32_t* aCount)
363 {
364 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
365 *aCount = acc ? acc->CharacterCount() : 0;
366 return true;
367 }
368
369 bool
RecvSelectionCount(const uint64_t & aID,int32_t * aCount)370 DocAccessibleChild::RecvSelectionCount(const uint64_t& aID, int32_t* aCount)
371 {
372 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
373 *aCount = acc ? acc->SelectionCount() : 0;
374 return true;
375 }
376
377 bool
RecvTextSubstring(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,nsString * aText,bool * aValid)378 DocAccessibleChild::RecvTextSubstring(const uint64_t& aID,
379 const int32_t& aStartOffset,
380 const int32_t& aEndOffset,
381 nsString* aText, bool* aValid)
382 {
383 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
384 if (!acc) {
385 return true;
386 }
387
388 *aValid = acc->IsValidRange(aStartOffset, aEndOffset);
389 acc->TextSubstring(aStartOffset, aEndOffset, *aText);
390 return true;
391 }
392
393 bool
RecvGetTextAfterOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)394 DocAccessibleChild::RecvGetTextAfterOffset(const uint64_t& aID,
395 const int32_t& aOffset,
396 const int32_t& aBoundaryType,
397 nsString* aText,
398 int32_t* aStartOffset,
399 int32_t* aEndOffset)
400 {
401 *aStartOffset = 0;
402 *aEndOffset = 0;
403 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
404 if (acc) {
405 acc->TextAfterOffset(aOffset, aBoundaryType,
406 aStartOffset, aEndOffset, *aText);
407 }
408 return true;
409 }
410
411 bool
RecvGetTextAtOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)412 DocAccessibleChild::RecvGetTextAtOffset(const uint64_t& aID,
413 const int32_t& aOffset,
414 const int32_t& aBoundaryType,
415 nsString* aText,
416 int32_t* aStartOffset,
417 int32_t* aEndOffset)
418 {
419 *aStartOffset = 0;
420 *aEndOffset = 0;
421 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
422 if (acc) {
423 acc->TextAtOffset(aOffset, aBoundaryType,
424 aStartOffset, aEndOffset, *aText);
425 }
426 return true;
427 }
428
429 bool
RecvGetTextBeforeOffset(const uint64_t & aID,const int32_t & aOffset,const int32_t & aBoundaryType,nsString * aText,int32_t * aStartOffset,int32_t * aEndOffset)430 DocAccessibleChild::RecvGetTextBeforeOffset(const uint64_t& aID,
431 const int32_t& aOffset,
432 const int32_t& aBoundaryType,
433 nsString* aText,
434 int32_t* aStartOffset,
435 int32_t* aEndOffset)
436 {
437 *aStartOffset = 0;
438 *aEndOffset = 0;
439 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
440 if (acc) {
441 acc->TextBeforeOffset(aOffset, aBoundaryType,
442 aStartOffset, aEndOffset, *aText);
443 }
444 return true;
445 }
446
447 bool
RecvCharAt(const uint64_t & aID,const int32_t & aOffset,uint16_t * aChar)448 DocAccessibleChild::RecvCharAt(const uint64_t& aID,
449 const int32_t& aOffset,
450 uint16_t* aChar)
451 {
452 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
453 *aChar = acc && acc->IsTextRole() ?
454 static_cast<uint16_t>(acc->CharAt(aOffset)) : 0;
455 return true;
456 }
457
458 bool
RecvTextAttributes(const uint64_t & aID,const bool & aIncludeDefAttrs,const int32_t & aOffset,nsTArray<Attribute> * aAttributes,int32_t * aStartOffset,int32_t * aEndOffset)459 DocAccessibleChild::RecvTextAttributes(const uint64_t& aID,
460 const bool& aIncludeDefAttrs,
461 const int32_t& aOffset,
462 nsTArray<Attribute>* aAttributes,
463 int32_t* aStartOffset,
464 int32_t* aEndOffset)
465 {
466 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
467 if (!acc || !acc->IsTextRole()) {
468 return true;
469 }
470
471 nsCOMPtr<nsIPersistentProperties> props =
472 acc->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
473 return PersistentPropertiesToArray(props, aAttributes);
474 }
475
476 bool
RecvDefaultTextAttributes(const uint64_t & aID,nsTArray<Attribute> * aAttributes)477 DocAccessibleChild::RecvDefaultTextAttributes(const uint64_t& aID,
478 nsTArray<Attribute> *aAttributes)
479 {
480 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
481 if (!acc || !acc->IsTextRole()) {
482 return true;
483 }
484
485 nsCOMPtr<nsIPersistentProperties> props = acc->DefaultTextAttributes();
486 return PersistentPropertiesToArray(props, aAttributes);
487 }
488
489 bool
RecvTextBounds(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aCoordType,nsIntRect * aRetVal)490 DocAccessibleChild::RecvTextBounds(const uint64_t& aID,
491 const int32_t& aStartOffset,
492 const int32_t& aEndOffset,
493 const uint32_t& aCoordType,
494 nsIntRect* aRetVal)
495 {
496 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
497 if (acc && acc->IsTextRole()) {
498 *aRetVal = acc->TextBounds(aStartOffset, aEndOffset, aCoordType);
499 }
500
501 return true;
502 }
503
504 bool
RecvCharBounds(const uint64_t & aID,const int32_t & aOffset,const uint32_t & aCoordType,nsIntRect * aRetVal)505 DocAccessibleChild::RecvCharBounds(const uint64_t& aID,
506 const int32_t& aOffset,
507 const uint32_t& aCoordType,
508 nsIntRect* aRetVal)
509 {
510 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
511 if (acc && acc->IsTextRole()) {
512 *aRetVal = acc->CharBounds(aOffset, aCoordType);
513 }
514
515 return true;
516 }
517
518 bool
RecvOffsetAtPoint(const uint64_t & aID,const int32_t & aX,const int32_t & aY,const uint32_t & aCoordType,int32_t * aRetVal)519 DocAccessibleChild::RecvOffsetAtPoint(const uint64_t& aID,
520 const int32_t& aX,
521 const int32_t& aY,
522 const uint32_t& aCoordType,
523 int32_t* aRetVal)
524 {
525 *aRetVal = -1;
526 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
527 if (acc && acc->IsTextRole()) {
528 *aRetVal = acc->OffsetAtPoint(aX, aY, aCoordType);
529 }
530 return true;
531 }
532
533 bool
RecvSelectionBoundsAt(const uint64_t & aID,const int32_t & aSelectionNum,bool * aSucceeded,nsString * aData,int32_t * aStartOffset,int32_t * aEndOffset)534 DocAccessibleChild::RecvSelectionBoundsAt(const uint64_t& aID,
535 const int32_t& aSelectionNum,
536 bool* aSucceeded,
537 nsString* aData,
538 int32_t* aStartOffset,
539 int32_t* aEndOffset)
540 {
541 *aSucceeded = false;
542 *aStartOffset = 0;
543 *aEndOffset = 0;
544 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
545 if (acc && acc->IsTextRole()) {
546 *aSucceeded =
547 acc->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
548 if (*aSucceeded) {
549 acc->TextSubstring(*aStartOffset, *aEndOffset, *aData);
550 }
551 }
552
553 return true;
554 }
555
556 bool
RecvSetSelectionBoundsAt(const uint64_t & aID,const int32_t & aSelectionNum,const int32_t & aStartOffset,const int32_t & aEndOffset,bool * aSucceeded)557 DocAccessibleChild::RecvSetSelectionBoundsAt(const uint64_t& aID,
558 const int32_t& aSelectionNum,
559 const int32_t& aStartOffset,
560 const int32_t& aEndOffset,
561 bool* aSucceeded)
562 {
563 *aSucceeded = false;
564 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
565 if (acc && acc->IsTextRole()) {
566 *aSucceeded =
567 acc->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
568 }
569
570 return true;
571 }
572
573 bool
RecvAddToSelection(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,bool * aSucceeded)574 DocAccessibleChild::RecvAddToSelection(const uint64_t& aID,
575 const int32_t& aStartOffset,
576 const int32_t& aEndOffset,
577 bool* aSucceeded)
578 {
579 *aSucceeded = false;
580 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
581 if (acc && acc->IsTextRole()) {
582 *aSucceeded = acc->AddToSelection(aStartOffset, aEndOffset);
583 }
584
585 return true;
586 }
587
588 bool
RecvRemoveFromSelection(const uint64_t & aID,const int32_t & aSelectionNum,bool * aSucceeded)589 DocAccessibleChild::RecvRemoveFromSelection(const uint64_t& aID,
590 const int32_t& aSelectionNum,
591 bool* aSucceeded)
592 {
593 *aSucceeded = false;
594 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
595 if (acc && acc->IsTextRole()) {
596 *aSucceeded = acc->RemoveFromSelection(aSelectionNum);
597 }
598
599 return true;
600 }
601
602 bool
RecvScrollSubstringTo(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aScrollType)603 DocAccessibleChild::RecvScrollSubstringTo(const uint64_t& aID,
604 const int32_t& aStartOffset,
605 const int32_t& aEndOffset,
606 const uint32_t& aScrollType)
607 {
608 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
609 if (acc) {
610 acc->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
611 }
612
613 return true;
614 }
615
616 bool
RecvScrollSubstringToPoint(const uint64_t & aID,const int32_t & aStartOffset,const int32_t & aEndOffset,const uint32_t & aCoordinateType,const int32_t & aX,const int32_t & aY)617 DocAccessibleChild::RecvScrollSubstringToPoint(const uint64_t& aID,
618 const int32_t& aStartOffset,
619 const int32_t& aEndOffset,
620 const uint32_t& aCoordinateType,
621 const int32_t& aX,
622 const int32_t& aY)
623 {
624 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
625 if (acc) {
626 acc->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType,
627 aX, aY);
628 }
629
630 return true;
631 }
632
633 bool
RecvText(const uint64_t & aID,nsString * aText)634 DocAccessibleChild::RecvText(const uint64_t& aID,
635 nsString* aText)
636 {
637 TextLeafAccessible* acc = IdToTextLeafAccessible(aID);
638 if (acc) {
639 *aText = acc->Text();
640 }
641
642 return true;
643 }
644
645 bool
RecvReplaceText(const uint64_t & aID,const nsString & aText)646 DocAccessibleChild::RecvReplaceText(const uint64_t& aID,
647 const nsString& aText)
648 {
649 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
650 if (acc && acc->IsTextRole()) {
651 acc->ReplaceText(aText);
652 }
653
654 return true;
655 }
656
657 bool
RecvInsertText(const uint64_t & aID,const nsString & aText,const int32_t & aPosition,bool * aValid)658 DocAccessibleChild::RecvInsertText(const uint64_t& aID,
659 const nsString& aText,
660 const int32_t& aPosition, bool* aValid)
661 {
662 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
663 if (acc && acc->IsTextRole()) {
664 *aValid = acc->IsValidOffset(aPosition);
665 acc->InsertText(aText, aPosition);
666 }
667
668 return true;
669 }
670
671 bool
RecvCopyText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)672 DocAccessibleChild::RecvCopyText(const uint64_t& aID,
673 const int32_t& aStartPos,
674 const int32_t& aEndPos, bool* aValid)
675 {
676 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
677 if (acc && acc->IsTextRole()) {
678 acc->CopyText(aStartPos, aEndPos);
679 }
680
681 return true;
682 }
683
684 bool
RecvCutText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)685 DocAccessibleChild::RecvCutText(const uint64_t& aID,
686 const int32_t& aStartPos,
687 const int32_t& aEndPos, bool* aValid)
688 {
689 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
690 if (acc && acc->IsTextRole()) {
691 *aValid = acc->IsValidRange(aStartPos, aEndPos);
692 acc->CutText(aStartPos, aEndPos);
693 }
694
695 return true;
696 }
697
698 bool
RecvDeleteText(const uint64_t & aID,const int32_t & aStartPos,const int32_t & aEndPos,bool * aValid)699 DocAccessibleChild::RecvDeleteText(const uint64_t& aID,
700 const int32_t& aStartPos,
701 const int32_t& aEndPos, bool* aValid)
702 {
703 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
704 if (acc && acc->IsTextRole()) {
705 *aValid = acc->IsValidRange(aStartPos, aEndPos);
706 acc->DeleteText(aStartPos, aEndPos);
707 }
708
709 return true;
710 }
711
712 bool
RecvPasteText(const uint64_t & aID,const int32_t & aPosition,bool * aValid)713 DocAccessibleChild::RecvPasteText(const uint64_t& aID,
714 const int32_t& aPosition, bool* aValid)
715 {
716 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
717 if (acc && acc->IsTextRole()) {
718 *aValid = acc->IsValidOffset(aPosition);
719 acc->PasteText(aPosition);
720 }
721
722 return true;
723 }
724
725 bool
RecvImagePosition(const uint64_t & aID,const uint32_t & aCoordType,nsIntPoint * aRetVal)726 DocAccessibleChild::RecvImagePosition(const uint64_t& aID,
727 const uint32_t& aCoordType,
728 nsIntPoint* aRetVal)
729 {
730 ImageAccessible* acc = IdToImageAccessible(aID);
731 if (acc) {
732 *aRetVal = acc->Position(aCoordType);
733 }
734
735 return true;
736 }
737
738 bool
RecvImageSize(const uint64_t & aID,nsIntSize * aRetVal)739 DocAccessibleChild::RecvImageSize(const uint64_t& aID,
740 nsIntSize* aRetVal)
741 {
742
743 ImageAccessible* acc = IdToImageAccessible(aID);
744 if (acc) {
745 *aRetVal = acc->Size();
746 }
747
748 return true;
749 }
750
751 bool
RecvStartOffset(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)752 DocAccessibleChild::RecvStartOffset(const uint64_t& aID,
753 uint32_t* aRetVal,
754 bool* aOk)
755 {
756 Accessible* acc = IdToAccessibleLink(aID);
757 if (acc) {
758 *aRetVal = acc->StartOffset();
759 *aOk = true;
760 } else {
761 *aRetVal = 0;
762 *aOk = false;
763 }
764
765 return true;
766 }
767
768 bool
RecvEndOffset(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)769 DocAccessibleChild::RecvEndOffset(const uint64_t& aID,
770 uint32_t* aRetVal,
771 bool* aOk)
772 {
773 Accessible* acc = IdToAccessibleLink(aID);
774 if (acc) {
775 *aRetVal = acc->EndOffset();
776 *aOk = true;
777 } else {
778 *aRetVal = 0;
779 *aOk = false;
780 }
781
782 return true;
783 }
784
785 bool
RecvIsLinkValid(const uint64_t & aID,bool * aRetVal)786 DocAccessibleChild::RecvIsLinkValid(const uint64_t& aID,
787 bool* aRetVal)
788 {
789 Accessible* acc = IdToAccessibleLink(aID);
790 if (acc) {
791 *aRetVal = acc->IsLinkValid();
792 } else {
793 *aRetVal = false;
794 }
795
796 return true;
797 }
798
799 bool
RecvAnchorCount(const uint64_t & aID,uint32_t * aRetVal,bool * aOk)800 DocAccessibleChild::RecvAnchorCount(const uint64_t& aID,
801 uint32_t* aRetVal,
802 bool* aOk)
803 {
804 Accessible* acc = IdToAccessibleLink(aID);
805 if (acc) {
806 *aRetVal = acc->AnchorCount();
807 *aOk = true;
808 } else {
809 *aRetVal = 0;
810 *aOk = false;
811 }
812
813 return true;
814 }
815
816 bool
RecvAnchorURIAt(const uint64_t & aID,const uint32_t & aIndex,nsCString * aURI,bool * aOk)817 DocAccessibleChild::RecvAnchorURIAt(const uint64_t& aID,
818 const uint32_t& aIndex,
819 nsCString* aURI,
820 bool* aOk)
821 {
822 Accessible* acc = IdToAccessibleLink(aID);
823 *aOk = false;
824 if (acc) {
825 nsCOMPtr<nsIURI> uri = acc->AnchorURIAt(aIndex);
826 if (uri) {
827 uri->GetSpec(*aURI);
828 *aOk = true;
829 }
830 }
831
832 return true;
833 }
834
835 bool
RecvAnchorAt(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aIDOfAnchor,bool * aOk)836 DocAccessibleChild::RecvAnchorAt(const uint64_t& aID,
837 const uint32_t& aIndex,
838 uint64_t* aIDOfAnchor,
839 bool* aOk)
840 {
841 *aIDOfAnchor = 0;
842 *aOk = false;
843 Accessible* acc = IdToAccessibleLink(aID);
844 if (acc) {
845 Accessible* anchor = acc->AnchorAt(aIndex);
846 if (anchor) {
847 *aIDOfAnchor = reinterpret_cast<uint64_t>(anchor->UniqueID());
848 *aOk = true;
849 }
850 }
851
852 return true;
853 }
854
855 bool
RecvLinkCount(const uint64_t & aID,uint32_t * aCount)856 DocAccessibleChild::RecvLinkCount(const uint64_t& aID,
857 uint32_t* aCount)
858 {
859 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
860 *aCount = acc ? acc->LinkCount() : 0;
861 return true;
862 }
863
864 bool
RecvLinkAt(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aIDOfLink,bool * aOk)865 DocAccessibleChild::RecvLinkAt(const uint64_t& aID,
866 const uint32_t& aIndex,
867 uint64_t* aIDOfLink,
868 bool* aOk)
869 {
870 *aIDOfLink = 0;
871 *aOk = false;
872 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
873 if (acc) {
874 Accessible* link = acc->LinkAt(aIndex);
875 if (link) {
876 *aIDOfLink = reinterpret_cast<uint64_t>(link->UniqueID());
877 *aOk = true;
878 }
879 }
880
881 return true;
882 }
883
884 bool
RecvLinkIndexOf(const uint64_t & aID,const uint64_t & aLinkID,int32_t * aIndex)885 DocAccessibleChild::RecvLinkIndexOf(const uint64_t& aID,
886 const uint64_t& aLinkID,
887 int32_t* aIndex)
888 {
889 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
890 Accessible* link = IdToAccessible(aLinkID);
891 *aIndex = -1;
892 if (acc && link) {
893 *aIndex = acc->LinkIndexOf(link);
894 }
895
896 return true;
897 }
898
899 bool
RecvLinkIndexAtOffset(const uint64_t & aID,const uint32_t & aOffset,int32_t * aIndex)900 DocAccessibleChild::RecvLinkIndexAtOffset(const uint64_t& aID,
901 const uint32_t& aOffset,
902 int32_t* aIndex)
903 {
904 HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
905 *aIndex = acc ? acc->LinkIndexAtOffset(aOffset) : -1;
906 return true;
907 }
908
909 bool
RecvTableOfACell(const uint64_t & aID,uint64_t * aTableID,bool * aOk)910 DocAccessibleChild::RecvTableOfACell(const uint64_t& aID,
911 uint64_t* aTableID,
912 bool* aOk)
913 {
914 *aTableID = 0;
915 *aOk = false;
916 TableCellAccessible* acc = IdToTableCellAccessible(aID);
917 if (acc) {
918 TableAccessible* table = acc->Table();
919 if (table) {
920 *aTableID = reinterpret_cast<uint64_t>(table->AsAccessible()->UniqueID());
921 *aOk = true;
922 }
923 }
924
925 return true;
926 }
927
928 bool
RecvColIdx(const uint64_t & aID,uint32_t * aIndex)929 DocAccessibleChild::RecvColIdx(const uint64_t& aID,
930 uint32_t* aIndex)
931 {
932 *aIndex = 0;
933 TableCellAccessible* acc = IdToTableCellAccessible(aID);
934 if (acc) {
935 *aIndex = acc->ColIdx();
936 }
937
938 return true;
939 }
940
941 bool
RecvRowIdx(const uint64_t & aID,uint32_t * aIndex)942 DocAccessibleChild::RecvRowIdx(const uint64_t& aID,
943 uint32_t* aIndex)
944 {
945 *aIndex = 0;
946 TableCellAccessible* acc = IdToTableCellAccessible(aID);
947 if (acc) {
948 *aIndex = acc->RowIdx();
949 }
950
951 return true;
952 }
953
954 bool
RecvGetPosition(const uint64_t & aID,uint32_t * aColIdx,uint32_t * aRowIdx)955 DocAccessibleChild::RecvGetPosition(const uint64_t& aID,
956 uint32_t* aColIdx, uint32_t* aRowIdx)
957 {
958 *aColIdx = 0;
959 *aRowIdx = 0;
960 TableCellAccessible* acc = IdToTableCellAccessible(aID);
961 if (acc) {
962 *aColIdx = acc->ColIdx();
963 *aRowIdx = acc->RowIdx();
964 }
965
966 return true;
967 }
968
969 bool
RecvGetColRowExtents(const uint64_t & aID,uint32_t * aColIdx,uint32_t * aRowIdx,uint32_t * aColExtent,uint32_t * aRowExtent)970 DocAccessibleChild::RecvGetColRowExtents(const uint64_t& aID,
971 uint32_t* aColIdx, uint32_t* aRowIdx,
972 uint32_t* aColExtent, uint32_t* aRowExtent)
973 {
974 *aColIdx = 0;
975 *aRowIdx = 0;
976 *aColExtent = 0;
977 *aRowExtent = 0;
978 TableCellAccessible* acc = IdToTableCellAccessible(aID);
979 if (acc) {
980 *aColIdx = acc->ColIdx();
981 *aRowIdx = acc->RowIdx();
982 *aColExtent = acc->ColExtent();
983 *aRowExtent = acc->RowExtent();
984 }
985
986 return true;
987 }
988
989 bool
RecvColExtent(const uint64_t & aID,uint32_t * aExtent)990 DocAccessibleChild::RecvColExtent(const uint64_t& aID,
991 uint32_t* aExtent)
992 {
993 *aExtent = 0;
994 TableCellAccessible* acc = IdToTableCellAccessible(aID);
995 if (acc) {
996 *aExtent = acc->ColExtent();
997 }
998
999 return true;
1000 }
1001
1002 bool
RecvRowExtent(const uint64_t & aID,uint32_t * aExtent)1003 DocAccessibleChild::RecvRowExtent(const uint64_t& aID,
1004 uint32_t* aExtent)
1005 {
1006 *aExtent = 0;
1007 TableCellAccessible* acc = IdToTableCellAccessible(aID);
1008 if (acc) {
1009 *aExtent = acc->RowExtent();
1010 }
1011
1012 return true;
1013 }
1014
1015 bool
RecvColHeaderCells(const uint64_t & aID,nsTArray<uint64_t> * aCells)1016 DocAccessibleChild::RecvColHeaderCells(const uint64_t& aID,
1017 nsTArray<uint64_t>* aCells)
1018 {
1019 TableCellAccessible* acc = IdToTableCellAccessible(aID);
1020 if (acc) {
1021 AutoTArray<Accessible*, 10> headerCells;
1022 acc->ColHeaderCells(&headerCells);
1023 aCells->SetCapacity(headerCells.Length());
1024 for (uint32_t i = 0; i < headerCells.Length(); ++i) {
1025 aCells->AppendElement(
1026 reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
1027 }
1028 }
1029
1030 return true;
1031 }
1032
1033 bool
RecvRowHeaderCells(const uint64_t & aID,nsTArray<uint64_t> * aCells)1034 DocAccessibleChild::RecvRowHeaderCells(const uint64_t& aID,
1035 nsTArray<uint64_t>* aCells)
1036 {
1037 TableCellAccessible* acc = IdToTableCellAccessible(aID);
1038 if (acc) {
1039 AutoTArray<Accessible*, 10> headerCells;
1040 acc->RowHeaderCells(&headerCells);
1041 aCells->SetCapacity(headerCells.Length());
1042 for (uint32_t i = 0; i < headerCells.Length(); ++i) {
1043 aCells->AppendElement(
1044 reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
1045 }
1046 }
1047
1048 return true;
1049 }
1050
1051 bool
RecvIsCellSelected(const uint64_t & aID,bool * aSelected)1052 DocAccessibleChild::RecvIsCellSelected(const uint64_t& aID,
1053 bool* aSelected)
1054 {
1055 TableCellAccessible* acc = IdToTableCellAccessible(aID);
1056 *aSelected = acc && acc->Selected();
1057 return true;
1058 }
1059
1060 bool
RecvTableCaption(const uint64_t & aID,uint64_t * aCaptionID,bool * aOk)1061 DocAccessibleChild::RecvTableCaption(const uint64_t& aID,
1062 uint64_t* aCaptionID,
1063 bool* aOk)
1064 {
1065 *aCaptionID = 0;
1066 *aOk = false;
1067 TableAccessible* acc = IdToTableAccessible(aID);
1068 if (acc) {
1069 Accessible* caption = acc->Caption();
1070 if (caption) {
1071 *aCaptionID = reinterpret_cast<uint64_t>(caption->UniqueID());
1072 *aOk = true;
1073 }
1074 }
1075
1076 return true;
1077 }
1078
1079 bool
RecvTableSummary(const uint64_t & aID,nsString * aSummary)1080 DocAccessibleChild::RecvTableSummary(const uint64_t& aID,
1081 nsString* aSummary)
1082 {
1083 TableAccessible* acc = IdToTableAccessible(aID);
1084 if (acc) {
1085 acc->Summary(*aSummary);
1086 }
1087
1088 return true;
1089 }
1090
1091 bool
RecvTableColumnCount(const uint64_t & aID,uint32_t * aColCount)1092 DocAccessibleChild::RecvTableColumnCount(const uint64_t& aID,
1093 uint32_t* aColCount)
1094 {
1095 *aColCount = 0;
1096 TableAccessible* acc = IdToTableAccessible(aID);
1097 if (acc) {
1098 *aColCount = acc->ColCount();
1099 }
1100
1101 return true;
1102 }
1103
1104 bool
RecvTableRowCount(const uint64_t & aID,uint32_t * aRowCount)1105 DocAccessibleChild::RecvTableRowCount(const uint64_t& aID,
1106 uint32_t* aRowCount)
1107 {
1108 *aRowCount = 0;
1109 TableAccessible* acc = IdToTableAccessible(aID);
1110 if (acc) {
1111 *aRowCount = acc->RowCount();
1112 }
1113
1114 return true;
1115 }
1116
1117 bool
RecvTableCellAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint64_t * aCellID,bool * aOk)1118 DocAccessibleChild::RecvTableCellAt(const uint64_t& aID,
1119 const uint32_t& aRow,
1120 const uint32_t& aCol,
1121 uint64_t* aCellID,
1122 bool* aOk)
1123 {
1124 *aCellID = 0;
1125 *aOk = false;
1126 TableAccessible* acc = IdToTableAccessible(aID);
1127 if (acc) {
1128 Accessible* cell = acc->CellAt(aRow, aCol);
1129 if (cell) {
1130 *aCellID = reinterpret_cast<uint64_t>(cell->UniqueID());
1131 *aOk = true;
1132 }
1133 }
1134
1135 return true;
1136 }
1137
1138 bool
RecvTableCellIndexAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,int32_t * aIndex)1139 DocAccessibleChild::RecvTableCellIndexAt(const uint64_t& aID,
1140 const uint32_t& aRow,
1141 const uint32_t& aCol,
1142 int32_t* aIndex)
1143 {
1144 *aIndex = -1;
1145 TableAccessible* acc = IdToTableAccessible(aID);
1146 if (acc) {
1147 *aIndex = acc->CellIndexAt(aRow, aCol);
1148 }
1149
1150 return true;
1151 }
1152
1153 bool
RecvTableColumnIndexAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aCol)1154 DocAccessibleChild::RecvTableColumnIndexAt(const uint64_t& aID,
1155 const uint32_t& aCellIndex,
1156 int32_t* aCol)
1157 {
1158 *aCol = -1;
1159 TableAccessible* acc = IdToTableAccessible(aID);
1160 if (acc) {
1161 *aCol = acc->ColIndexAt(aCellIndex);
1162 }
1163
1164 return true;
1165 }
1166
1167 bool
RecvTableRowIndexAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aRow)1168 DocAccessibleChild::RecvTableRowIndexAt(const uint64_t& aID,
1169 const uint32_t& aCellIndex,
1170 int32_t* aRow)
1171 {
1172 *aRow = -1;
1173 TableAccessible* acc = IdToTableAccessible(aID);
1174 if (acc) {
1175 *aRow = acc->RowIndexAt(aCellIndex);
1176 }
1177
1178 return true;
1179 }
1180
1181 bool
RecvTableRowAndColumnIndicesAt(const uint64_t & aID,const uint32_t & aCellIndex,int32_t * aRow,int32_t * aCol)1182 DocAccessibleChild::RecvTableRowAndColumnIndicesAt(const uint64_t& aID,
1183 const uint32_t& aCellIndex,
1184 int32_t* aRow,
1185 int32_t* aCol)
1186 {
1187 *aRow = -1;
1188 *aCol = -1;
1189 TableAccessible* acc = IdToTableAccessible(aID);
1190 if (acc) {
1191 acc->RowAndColIndicesAt(aCellIndex, aRow, aCol);
1192 }
1193
1194 return true;
1195 }
1196
1197 bool
RecvTableColumnExtentAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint32_t * aExtent)1198 DocAccessibleChild::RecvTableColumnExtentAt(const uint64_t& aID,
1199 const uint32_t& aRow,
1200 const uint32_t& aCol,
1201 uint32_t* aExtent)
1202 {
1203 *aExtent = 0;
1204 TableAccessible* acc = IdToTableAccessible(aID);
1205 if (acc) {
1206 *aExtent = acc->ColExtentAt(aRow, aCol);
1207 }
1208
1209 return true;
1210 }
1211
1212 bool
RecvTableRowExtentAt(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,uint32_t * aExtent)1213 DocAccessibleChild::RecvTableRowExtentAt(const uint64_t& aID,
1214 const uint32_t& aRow,
1215 const uint32_t& aCol,
1216 uint32_t* aExtent)
1217 {
1218 *aExtent = 0;
1219 TableAccessible* acc = IdToTableAccessible(aID);
1220 if (acc) {
1221 *aExtent = acc->RowExtentAt(aRow, aCol);
1222 }
1223
1224 return true;
1225 }
1226
1227 bool
RecvTableColumnDescription(const uint64_t & aID,const uint32_t & aCol,nsString * aDescription)1228 DocAccessibleChild::RecvTableColumnDescription(const uint64_t& aID,
1229 const uint32_t& aCol,
1230 nsString* aDescription)
1231 {
1232 TableAccessible* acc = IdToTableAccessible(aID);
1233 if (acc) {
1234 acc->ColDescription(aCol, *aDescription);
1235 }
1236
1237 return true;
1238 }
1239
1240 bool
RecvTableRowDescription(const uint64_t & aID,const uint32_t & aRow,nsString * aDescription)1241 DocAccessibleChild::RecvTableRowDescription(const uint64_t& aID,
1242 const uint32_t& aRow,
1243 nsString* aDescription)
1244 {
1245 TableAccessible* acc = IdToTableAccessible(aID);
1246 if (acc) {
1247 acc->RowDescription(aRow, *aDescription);
1248 }
1249
1250 return true;
1251 }
1252
1253 bool
RecvTableColumnSelected(const uint64_t & aID,const uint32_t & aCol,bool * aSelected)1254 DocAccessibleChild::RecvTableColumnSelected(const uint64_t& aID,
1255 const uint32_t& aCol,
1256 bool* aSelected)
1257 {
1258 *aSelected = false;
1259 TableAccessible* acc = IdToTableAccessible(aID);
1260 if (acc) {
1261 *aSelected = acc->IsColSelected(aCol);
1262 }
1263
1264 return true;
1265 }
1266
1267 bool
RecvTableRowSelected(const uint64_t & aID,const uint32_t & aRow,bool * aSelected)1268 DocAccessibleChild::RecvTableRowSelected(const uint64_t& aID,
1269 const uint32_t& aRow,
1270 bool* aSelected)
1271 {
1272 *aSelected = false;
1273 TableAccessible* acc = IdToTableAccessible(aID);
1274 if (acc) {
1275 *aSelected = acc->IsRowSelected(aRow);
1276 }
1277
1278 return true;
1279 }
1280
1281 bool
RecvTableCellSelected(const uint64_t & aID,const uint32_t & aRow,const uint32_t & aCol,bool * aSelected)1282 DocAccessibleChild::RecvTableCellSelected(const uint64_t& aID,
1283 const uint32_t& aRow,
1284 const uint32_t& aCol,
1285 bool* aSelected)
1286 {
1287 *aSelected = false;
1288 TableAccessible* acc = IdToTableAccessible(aID);
1289 if (acc) {
1290 *aSelected = acc->IsCellSelected(aRow, aCol);
1291 }
1292
1293 return true;
1294 }
1295
1296 bool
RecvTableSelectedCellCount(const uint64_t & aID,uint32_t * aSelectedCells)1297 DocAccessibleChild::RecvTableSelectedCellCount(const uint64_t& aID,
1298 uint32_t* aSelectedCells)
1299 {
1300 *aSelectedCells = 0;
1301 TableAccessible* acc = IdToTableAccessible(aID);
1302 if (acc) {
1303 *aSelectedCells = acc->SelectedCellCount();
1304 }
1305
1306 return true;
1307 }
1308
1309 bool
RecvTableSelectedColumnCount(const uint64_t & aID,uint32_t * aSelectedColumns)1310 DocAccessibleChild::RecvTableSelectedColumnCount(const uint64_t& aID,
1311 uint32_t* aSelectedColumns)
1312 {
1313 *aSelectedColumns = 0;
1314 TableAccessible* acc = IdToTableAccessible(aID);
1315 if (acc) {
1316 *aSelectedColumns = acc->SelectedColCount();
1317 }
1318
1319 return true;
1320 }
1321
1322 bool
RecvTableSelectedRowCount(const uint64_t & aID,uint32_t * aSelectedRows)1323 DocAccessibleChild::RecvTableSelectedRowCount(const uint64_t& aID,
1324 uint32_t* aSelectedRows)
1325 {
1326 *aSelectedRows = 0;
1327 TableAccessible* acc = IdToTableAccessible(aID);
1328 if (acc) {
1329 *aSelectedRows = acc->SelectedRowCount();
1330 }
1331
1332 return true;
1333 }
1334
1335 bool
RecvTableSelectedCells(const uint64_t & aID,nsTArray<uint64_t> * aCellIDs)1336 DocAccessibleChild::RecvTableSelectedCells(const uint64_t& aID,
1337 nsTArray<uint64_t>* aCellIDs)
1338 {
1339 TableAccessible* acc = IdToTableAccessible(aID);
1340 if (acc) {
1341 AutoTArray<Accessible*, 30> cells;
1342 acc->SelectedCells(&cells);
1343 aCellIDs->SetCapacity(cells.Length());
1344 for (uint32_t i = 0; i < cells.Length(); ++i) {
1345 aCellIDs->AppendElement(
1346 reinterpret_cast<uint64_t>(cells[i]->UniqueID()));
1347 }
1348 }
1349
1350 return true;
1351 }
1352
1353 bool
RecvTableSelectedCellIndices(const uint64_t & aID,nsTArray<uint32_t> * aCellIndices)1354 DocAccessibleChild::RecvTableSelectedCellIndices(const uint64_t& aID,
1355 nsTArray<uint32_t>* aCellIndices)
1356 {
1357 TableAccessible* acc = IdToTableAccessible(aID);
1358 if (acc) {
1359 acc->SelectedCellIndices(aCellIndices);
1360 }
1361
1362 return true;
1363 }
1364
1365 bool
RecvTableSelectedColumnIndices(const uint64_t & aID,nsTArray<uint32_t> * aColumnIndices)1366 DocAccessibleChild::RecvTableSelectedColumnIndices(const uint64_t& aID,
1367 nsTArray<uint32_t>* aColumnIndices)
1368 {
1369 TableAccessible* acc = IdToTableAccessible(aID);
1370 if (acc) {
1371 acc->SelectedColIndices(aColumnIndices);
1372 }
1373
1374 return true;
1375 }
1376
1377 bool
RecvTableSelectedRowIndices(const uint64_t & aID,nsTArray<uint32_t> * aRowIndices)1378 DocAccessibleChild::RecvTableSelectedRowIndices(const uint64_t& aID,
1379 nsTArray<uint32_t>* aRowIndices)
1380 {
1381 TableAccessible* acc = IdToTableAccessible(aID);
1382 if (acc) {
1383 acc->SelectedRowIndices(aRowIndices);
1384 }
1385
1386 return true;
1387 }
1388
1389 bool
RecvTableSelectColumn(const uint64_t & aID,const uint32_t & aCol)1390 DocAccessibleChild::RecvTableSelectColumn(const uint64_t& aID,
1391 const uint32_t& aCol)
1392 {
1393 TableAccessible* acc = IdToTableAccessible(aID);
1394 if (acc) {
1395 acc->SelectCol(aCol);
1396 }
1397
1398 return true;
1399 }
1400
1401 bool
RecvTableSelectRow(const uint64_t & aID,const uint32_t & aRow)1402 DocAccessibleChild::RecvTableSelectRow(const uint64_t& aID,
1403 const uint32_t& aRow)
1404 {
1405 TableAccessible* acc = IdToTableAccessible(aID);
1406 if (acc) {
1407 acc->SelectRow(aRow);
1408 }
1409
1410 return true;
1411 }
1412
1413 bool
RecvTableUnselectColumn(const uint64_t & aID,const uint32_t & aCol)1414 DocAccessibleChild::RecvTableUnselectColumn(const uint64_t& aID,
1415 const uint32_t& aCol)
1416 {
1417 TableAccessible* acc = IdToTableAccessible(aID);
1418 if (acc) {
1419 acc->UnselectCol(aCol);
1420 }
1421
1422 return true;
1423 }
1424
1425 bool
RecvTableUnselectRow(const uint64_t & aID,const uint32_t & aRow)1426 DocAccessibleChild::RecvTableUnselectRow(const uint64_t& aID,
1427 const uint32_t& aRow)
1428 {
1429 TableAccessible* acc = IdToTableAccessible(aID);
1430 if (acc) {
1431 acc->UnselectRow(aRow);
1432 }
1433
1434 return true;
1435 }
1436
1437 bool
RecvTableIsProbablyForLayout(const uint64_t & aID,bool * aForLayout)1438 DocAccessibleChild::RecvTableIsProbablyForLayout(const uint64_t& aID,
1439 bool* aForLayout)
1440 {
1441 *aForLayout = false;
1442 TableAccessible* acc = IdToTableAccessible(aID);
1443 if (acc) {
1444 *aForLayout = acc->IsProbablyLayoutTable();
1445 }
1446
1447 return true;
1448 }
1449
1450 bool
RecvAtkTableColumnHeader(const uint64_t & aID,const int32_t & aCol,uint64_t * aHeader,bool * aOk)1451 DocAccessibleChild::RecvAtkTableColumnHeader(const uint64_t& aID,
1452 const int32_t& aCol,
1453 uint64_t* aHeader,
1454 bool* aOk)
1455 {
1456 *aHeader = 0;
1457 *aOk = false;
1458
1459 #ifdef MOZ_ACCESSIBILITY_ATK
1460 TableAccessible* acc = IdToTableAccessible(aID);
1461 if (acc) {
1462 Accessible* header = AccessibleWrap::GetColumnHeader(acc, aCol);
1463 if (header) {
1464 *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
1465 *aOk = true;
1466 }
1467 }
1468 #endif
1469
1470 return true;
1471 }
1472
1473 bool
RecvAtkTableRowHeader(const uint64_t & aID,const int32_t & aRow,uint64_t * aHeader,bool * aOk)1474 DocAccessibleChild::RecvAtkTableRowHeader(const uint64_t& aID,
1475 const int32_t& aRow,
1476 uint64_t* aHeader,
1477 bool* aOk)
1478 {
1479 *aHeader = 0;
1480 *aOk = false;
1481
1482 #ifdef MOZ_ACCESSIBILITY_ATK
1483 TableAccessible* acc = IdToTableAccessible(aID);
1484 if (acc) {
1485 Accessible* header = AccessibleWrap::GetRowHeader(acc, aRow);
1486 if (header) {
1487 *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
1488 *aOk = true;
1489 }
1490 }
1491 #endif
1492
1493 return true;
1494 }
1495
1496 bool
RecvSelectedItems(const uint64_t & aID,nsTArray<uint64_t> * aSelectedItemIDs)1497 DocAccessibleChild::RecvSelectedItems(const uint64_t& aID,
1498 nsTArray<uint64_t>* aSelectedItemIDs)
1499 {
1500 Accessible* acc = IdToAccessibleSelect(aID);
1501 if (acc) {
1502 AutoTArray<Accessible*, 10> selectedItems;
1503 acc->SelectedItems(&selectedItems);
1504 aSelectedItemIDs->SetCapacity(selectedItems.Length());
1505 for (size_t i = 0; i < selectedItems.Length(); ++i) {
1506 aSelectedItemIDs->AppendElement(
1507 reinterpret_cast<uint64_t>(selectedItems[i]->UniqueID()));
1508 }
1509 }
1510
1511 return true;
1512 }
1513
1514 bool
RecvSelectedItemCount(const uint64_t & aID,uint32_t * aCount)1515 DocAccessibleChild::RecvSelectedItemCount(const uint64_t& aID,
1516 uint32_t* aCount)
1517 {
1518 *aCount = 0;
1519 Accessible* acc = IdToAccessibleSelect(aID);
1520 if (acc) {
1521 *aCount = acc->SelectedItemCount();
1522 }
1523
1524 return true;
1525 }
1526
1527 bool
RecvGetSelectedItem(const uint64_t & aID,const uint32_t & aIndex,uint64_t * aSelected,bool * aOk)1528 DocAccessibleChild::RecvGetSelectedItem(const uint64_t& aID,
1529 const uint32_t& aIndex,
1530 uint64_t* aSelected,
1531 bool* aOk)
1532 {
1533 *aSelected = 0;
1534 *aOk = false;
1535 Accessible* acc = IdToAccessibleSelect(aID);
1536 if (acc) {
1537 Accessible* item = acc->GetSelectedItem(aIndex);
1538 if (item) {
1539 *aSelected = reinterpret_cast<uint64_t>(item->UniqueID());
1540 *aOk = true;
1541 }
1542 }
1543
1544 return true;
1545 }
1546
1547 bool
RecvIsItemSelected(const uint64_t & aID,const uint32_t & aIndex,bool * aSelected)1548 DocAccessibleChild::RecvIsItemSelected(const uint64_t& aID,
1549 const uint32_t& aIndex,
1550 bool* aSelected)
1551 {
1552 *aSelected = false;
1553 Accessible* acc = IdToAccessibleSelect(aID);
1554 if (acc) {
1555 *aSelected = acc->IsItemSelected(aIndex);
1556 }
1557
1558 return true;
1559 }
1560
1561 bool
RecvAddItemToSelection(const uint64_t & aID,const uint32_t & aIndex,bool * aSuccess)1562 DocAccessibleChild::RecvAddItemToSelection(const uint64_t& aID,
1563 const uint32_t& aIndex,
1564 bool* aSuccess)
1565 {
1566 *aSuccess = false;
1567 Accessible* acc = IdToAccessibleSelect(aID);
1568 if (acc) {
1569 *aSuccess = acc->AddItemToSelection(aIndex);
1570 }
1571
1572 return true;
1573 }
1574
1575 bool
RecvRemoveItemFromSelection(const uint64_t & aID,const uint32_t & aIndex,bool * aSuccess)1576 DocAccessibleChild::RecvRemoveItemFromSelection(const uint64_t& aID,
1577 const uint32_t& aIndex,
1578 bool* aSuccess)
1579 {
1580 *aSuccess = false;
1581 Accessible* acc = IdToAccessibleSelect(aID);
1582 if (acc) {
1583 *aSuccess = acc->RemoveItemFromSelection(aIndex);
1584 }
1585
1586 return true;
1587 }
1588
1589 bool
RecvSelectAll(const uint64_t & aID,bool * aSuccess)1590 DocAccessibleChild::RecvSelectAll(const uint64_t& aID,
1591 bool* aSuccess)
1592 {
1593 *aSuccess = false;
1594 Accessible* acc = IdToAccessibleSelect(aID);
1595 if (acc) {
1596 *aSuccess = acc->SelectAll();
1597 }
1598
1599 return true;
1600 }
1601
1602 bool
RecvUnselectAll(const uint64_t & aID,bool * aSuccess)1603 DocAccessibleChild::RecvUnselectAll(const uint64_t& aID,
1604 bool* aSuccess)
1605 {
1606 *aSuccess = false;
1607 Accessible* acc = IdToAccessibleSelect(aID);
1608 if (acc) {
1609 *aSuccess = acc->UnselectAll();
1610 }
1611
1612 return true;
1613 }
1614
1615 bool
RecvTakeSelection(const uint64_t & aID)1616 DocAccessibleChild::RecvTakeSelection(const uint64_t& aID)
1617 {
1618 Accessible* acc = IdToAccessible(aID);
1619 if (acc) {
1620 acc->TakeSelection();
1621 }
1622
1623 return true;
1624 }
1625
1626 bool
RecvSetSelected(const uint64_t & aID,const bool & aSelect)1627 DocAccessibleChild::RecvSetSelected(const uint64_t& aID, const bool& aSelect)
1628 {
1629 Accessible* acc = IdToAccessible(aID);
1630 if (acc) {
1631 acc->SetSelected(aSelect);
1632 }
1633
1634 return true;
1635 }
1636
1637 bool
RecvDoAction(const uint64_t & aID,const uint8_t & aIndex,bool * aSuccess)1638 DocAccessibleChild::RecvDoAction(const uint64_t& aID,
1639 const uint8_t& aIndex,
1640 bool* aSuccess)
1641 {
1642 *aSuccess = false;
1643 Accessible* acc = IdToAccessible(aID);
1644 if (acc) {
1645 *aSuccess = acc->DoAction(aIndex);
1646 }
1647
1648 return true;
1649 }
1650
1651 bool
RecvActionCount(const uint64_t & aID,uint8_t * aCount)1652 DocAccessibleChild::RecvActionCount(const uint64_t& aID,
1653 uint8_t* aCount)
1654 {
1655 *aCount = 0;
1656 Accessible* acc = IdToAccessible(aID);
1657 if (acc) {
1658 *aCount = acc->ActionCount();
1659 }
1660
1661 return true;
1662 }
1663
1664 bool
RecvActionDescriptionAt(const uint64_t & aID,const uint8_t & aIndex,nsString * aDescription)1665 DocAccessibleChild::RecvActionDescriptionAt(const uint64_t& aID,
1666 const uint8_t& aIndex,
1667 nsString* aDescription)
1668 {
1669 Accessible* acc = IdToAccessible(aID);
1670 if (acc) {
1671 acc->ActionDescriptionAt(aIndex, *aDescription);
1672 }
1673
1674 return true;
1675 }
1676
1677 bool
RecvActionNameAt(const uint64_t & aID,const uint8_t & aIndex,nsString * aName)1678 DocAccessibleChild::RecvActionNameAt(const uint64_t& aID,
1679 const uint8_t& aIndex,
1680 nsString* aName)
1681 {
1682 Accessible* acc = IdToAccessible(aID);
1683 if (acc) {
1684 acc->ActionNameAt(aIndex, *aName);
1685 }
1686
1687 return true;
1688 }
1689
1690 bool
RecvAccessKey(const uint64_t & aID,uint32_t * aKey,uint32_t * aModifierMask)1691 DocAccessibleChild::RecvAccessKey(const uint64_t& aID,
1692 uint32_t* aKey,
1693 uint32_t* aModifierMask)
1694 {
1695 *aKey = 0;
1696 *aModifierMask = 0;
1697 Accessible* acc = IdToAccessible(aID);
1698 if (acc) {
1699 KeyBinding kb = acc->AccessKey();
1700 *aKey = kb.Key();
1701 *aModifierMask = kb.ModifierMask();
1702 }
1703
1704 return true;
1705 }
1706
1707 bool
RecvKeyboardShortcut(const uint64_t & aID,uint32_t * aKey,uint32_t * aModifierMask)1708 DocAccessibleChild::RecvKeyboardShortcut(const uint64_t& aID,
1709 uint32_t* aKey,
1710 uint32_t* aModifierMask)
1711 {
1712 *aKey = 0;
1713 *aModifierMask = 0;
1714 Accessible* acc = IdToAccessible(aID);
1715 if (acc) {
1716 KeyBinding kb = acc->KeyboardShortcut();
1717 *aKey = kb.Key();
1718 *aModifierMask = kb.ModifierMask();
1719 }
1720
1721 return true;
1722 }
1723
1724 bool
RecvAtkKeyBinding(const uint64_t & aID,nsString * aResult)1725 DocAccessibleChild::RecvAtkKeyBinding(const uint64_t& aID,
1726 nsString* aResult)
1727 {
1728 #ifdef MOZ_ACCESSIBILITY_ATK
1729 Accessible* acc = IdToAccessible(aID);
1730 if (acc) {
1731 AccessibleWrap::GetKeyBinding(acc, *aResult);
1732 }
1733 #endif
1734 return true;
1735 }
1736
1737 bool
RecvCurValue(const uint64_t & aID,double * aValue)1738 DocAccessibleChild::RecvCurValue(const uint64_t& aID,
1739 double* aValue)
1740 {
1741 *aValue = UnspecifiedNaN<double>();
1742 Accessible* acc = IdToAccessible(aID);
1743 if (acc) {
1744 *aValue = acc->CurValue();
1745 }
1746
1747 return true;
1748 }
1749
1750 bool
RecvSetCurValue(const uint64_t & aID,const double & aValue,bool * aRetVal)1751 DocAccessibleChild::RecvSetCurValue(const uint64_t& aID,
1752 const double& aValue,
1753 bool* aRetVal)
1754 {
1755 *aRetVal = false;
1756 Accessible* acc = IdToAccessible(aID);
1757 if (acc) {
1758 *aRetVal = acc->SetCurValue(aValue);
1759 }
1760
1761 return true;
1762 }
1763
1764 bool
RecvMinValue(const uint64_t & aID,double * aValue)1765 DocAccessibleChild::RecvMinValue(const uint64_t& aID,
1766 double* aValue)
1767 {
1768 *aValue = UnspecifiedNaN<double>();
1769 Accessible* acc = IdToAccessible(aID);
1770 if (acc) {
1771 *aValue = acc->MinValue();
1772 }
1773
1774 return true;
1775 }
1776
1777 bool
RecvMaxValue(const uint64_t & aID,double * aValue)1778 DocAccessibleChild::RecvMaxValue(const uint64_t& aID,
1779 double* aValue)
1780 {
1781 *aValue = UnspecifiedNaN<double>();
1782 Accessible* acc = IdToAccessible(aID);
1783 if (acc) {
1784 *aValue = acc->MaxValue();
1785 }
1786
1787 return true;
1788 }
1789
1790 bool
RecvStep(const uint64_t & aID,double * aStep)1791 DocAccessibleChild::RecvStep(const uint64_t& aID,
1792 double* aStep)
1793 {
1794 *aStep = UnspecifiedNaN<double>();
1795 Accessible* acc = IdToAccessible(aID);
1796 if (acc) {
1797 *aStep = acc->Step();
1798 }
1799
1800 return true;
1801 }
1802
1803 bool
RecvTakeFocus(const uint64_t & aID)1804 DocAccessibleChild::RecvTakeFocus(const uint64_t& aID)
1805 {
1806 Accessible* acc = IdToAccessible(aID);
1807 if (acc) {
1808 acc->TakeFocus();
1809 }
1810
1811 return true;
1812 }
1813
1814 bool
RecvFocusedChild(const uint64_t & aID,uint64_t * aChild,bool * aOk)1815 DocAccessibleChild::RecvFocusedChild(const uint64_t& aID,
1816 uint64_t* aChild,
1817 bool* aOk)
1818 {
1819 *aChild = 0;
1820 *aOk = false;
1821 Accessible* acc = IdToAccessible(aID);
1822 if (acc) {
1823 Accessible* child = acc->FocusedChild();
1824 if (child) {
1825 *aChild = reinterpret_cast<uint64_t>(child->UniqueID());
1826 *aOk = true;
1827 }
1828 }
1829 return true;
1830 }
1831
1832 bool
RecvLanguage(const uint64_t & aID,nsString * aLocale)1833 DocAccessibleChild::RecvLanguage(const uint64_t& aID,
1834 nsString* aLocale)
1835 {
1836 Accessible* acc = IdToAccessible(aID);
1837 if (acc) {
1838 acc->Language(*aLocale);
1839 }
1840
1841 return true;
1842 }
1843
1844 bool
RecvDocType(const uint64_t & aID,nsString * aType)1845 DocAccessibleChild::RecvDocType(const uint64_t& aID,
1846 nsString* aType)
1847 {
1848 Accessible* acc = IdToAccessible(aID);
1849 if (acc && acc->IsDoc()) {
1850 acc->AsDoc()->DocType(*aType);
1851 }
1852
1853 return true;
1854 }
1855
1856 bool
RecvTitle(const uint64_t & aID,nsString * aTitle)1857 DocAccessibleChild::RecvTitle(const uint64_t& aID,
1858 nsString* aTitle)
1859 {
1860 Accessible* acc = IdToAccessible(aID);
1861 if (acc) {
1862 mozilla::ErrorResult rv;
1863 acc->GetContent()->GetTextContent(*aTitle, rv);
1864 }
1865
1866 return true;
1867 }
1868
1869 bool
RecvURL(const uint64_t & aID,nsString * aURL)1870 DocAccessibleChild::RecvURL(const uint64_t& aID,
1871 nsString* aURL)
1872 {
1873 Accessible* acc = IdToAccessible(aID);
1874 if (acc && acc->IsDoc()) {
1875 acc->AsDoc()->URL(*aURL);
1876 }
1877
1878 return true;
1879 }
1880
1881 bool
RecvMimeType(const uint64_t & aID,nsString * aMime)1882 DocAccessibleChild::RecvMimeType(const uint64_t& aID,
1883 nsString* aMime)
1884 {
1885 Accessible* acc = IdToAccessible(aID);
1886 if (acc && acc->IsDoc()) {
1887 acc->AsDoc()->MimeType(*aMime);
1888 }
1889
1890 return true;
1891 }
1892
1893 bool
RecvURLDocTypeMimeType(const uint64_t & aID,nsString * aURL,nsString * aDocType,nsString * aMimeType)1894 DocAccessibleChild::RecvURLDocTypeMimeType(const uint64_t& aID,
1895 nsString* aURL,
1896 nsString* aDocType,
1897 nsString* aMimeType)
1898 {
1899 Accessible* acc = IdToAccessible(aID);
1900 if (acc && acc->IsDoc()) {
1901 DocAccessible* doc = acc->AsDoc();
1902 doc->URL(*aURL);
1903 doc->DocType(*aDocType);
1904 doc->MimeType(*aMimeType);
1905 }
1906
1907 return true;
1908 }
1909
1910 bool
RecvAccessibleAtPoint(const uint64_t & aID,const int32_t & aX,const int32_t & aY,const bool & aNeedsScreenCoords,const uint32_t & aWhich,uint64_t * aResult,bool * aOk)1911 DocAccessibleChild::RecvAccessibleAtPoint(const uint64_t& aID,
1912 const int32_t& aX,
1913 const int32_t& aY,
1914 const bool& aNeedsScreenCoords,
1915 const uint32_t& aWhich,
1916 uint64_t* aResult,
1917 bool* aOk)
1918 {
1919 *aResult = 0;
1920 *aOk = false;
1921 Accessible* acc = IdToAccessible(aID);
1922 if (acc && !acc->IsDefunct() && !nsAccUtils::MustPrune(acc)) {
1923 int32_t x = aX;
1924 int32_t y = aY;
1925 if (aNeedsScreenCoords) {
1926 nsIntPoint winCoords =
1927 nsCoreUtils::GetScreenCoordsForWindow(acc->GetNode());
1928 x += winCoords.x;
1929 y += winCoords.y;
1930 }
1931
1932 Accessible* result =
1933 acc->ChildAtPoint(x, y,
1934 static_cast<Accessible::EWhichChildAtPoint>(aWhich));
1935 if (result) {
1936 *aResult = reinterpret_cast<uint64_t>(result->UniqueID());
1937 *aOk = true;
1938 }
1939 }
1940
1941 return true;
1942 }
1943
1944 bool
RecvExtents(const uint64_t & aID,const bool & aNeedsScreenCoords,int32_t * aX,int32_t * aY,int32_t * aWidth,int32_t * aHeight)1945 DocAccessibleChild::RecvExtents(const uint64_t& aID,
1946 const bool& aNeedsScreenCoords,
1947 int32_t* aX,
1948 int32_t* aY,
1949 int32_t* aWidth,
1950 int32_t* aHeight)
1951 {
1952 *aX = 0;
1953 *aY = 0;
1954 *aWidth = 0;
1955 *aHeight = 0;
1956 Accessible* acc = IdToAccessible(aID);
1957 if (acc && !acc->IsDefunct()) {
1958 nsIntRect screenRect = acc->Bounds();
1959 if (!screenRect.IsEmpty()) {
1960 if (aNeedsScreenCoords) {
1961 nsIntPoint winCoords =
1962 nsCoreUtils::GetScreenCoordsForWindow(acc->GetNode());
1963 screenRect.x -= winCoords.x;
1964 screenRect.y -= winCoords.y;
1965 }
1966
1967 *aX = screenRect.x;
1968 *aY = screenRect.y;
1969 *aWidth = screenRect.width;
1970 *aHeight = screenRect.height;
1971 }
1972 }
1973 return true;
1974 }
1975
1976 bool
RecvDOMNodeID(const uint64_t & aID,nsString * aDOMNodeID)1977 DocAccessibleChild::RecvDOMNodeID(const uint64_t& aID, nsString* aDOMNodeID)
1978 {
1979 Accessible* acc = IdToAccessible(aID);
1980 if (!acc) {
1981 return true;
1982 }
1983
1984 nsIContent* content = acc->GetContent();
1985 if (!content) {
1986 return true;
1987 }
1988
1989 nsIAtom* id = content->GetID();
1990 if (id) {
1991 id->ToString(*aDOMNodeID);
1992 }
1993
1994 return true;
1995 }
1996
1997 }
1998 }
1999