accessible/xpcom/xpcAccessibleHyperText.cpp

   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "xpcAccessibleHyperText.h"
   8
   9 #include "LocalAccessible-inl.h"
  10 #include "HyperTextAccessible-inl.h"
  11 #include "mozilla/a11y/PDocAccessible.h"
  12 #include "mozilla/StaticPrefs_accessibility.h"
  13 #include "TextRange.h"
  14 #include "AccAttributes.h"
  15 #include "nsComponentManagerUtils.h"
  16 #include "nsPersistentProperties.h"
  17 #include "xpcAccessibleDocument.h"
  18 #include "xpcAccessibleTextRange.h"
  19
  20 #include "nsIMutableArray.h"
  21
  22 using namespace mozilla::a11y;
  23
  24 ////////////////////////////////////////////////////////////////////////////////
  25 // nsISupports
  26
  27 NS_INTERFACE_MAP_BEGIN(xpcAccessibleHyperText)
  28   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleText,
  29                                      mSupportedIfaces & eText)
  30   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleEditableText,
  31                                      mSupportedIfaces & eText)
  32   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperText,
  33                                      mSupportedIfaces & eText)
  34 NS_INTERFACE_MAP_END_INHERITING(xpcAccessibleGeneric)
  35
  36 NS_IMPL_ADDREF_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
  37 NS_IMPL_RELEASE_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
  38
  39 ////////////////////////////////////////////////////////////////////////////////
  40 // nsIAccessibleText
  41
  42 NS_IMETHODIMP
  43 xpcAccessibleHyperText::GetCharacterCount(int32_t* aCharacterCount) {
  44   NS_ENSURE_ARG_POINTER(aCharacterCount);
  45   *aCharacterCount = 0;
  46
  47   if (!mIntl) return NS_ERROR_FAILURE;
  48
  49 #if defined(XP_WIN)
  50   if (mIntl->IsRemote() &&
  51       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
  52     return NS_ERROR_NOT_IMPLEMENTED;
  53   }
  54 #endif
  55
  56   *aCharacterCount = static_cast<int32_t>(Intl()->CharacterCount());
  57   return NS_OK;
  58 }
  59
  60 NS_IMETHODIMP
  61 xpcAccessibleHyperText::GetText(int32_t aStartOffset, int32_t aEndOffset,
  62                                 nsAString& aText) {
  63   aText.Truncate();
  64
  65   if (!mIntl) return NS_ERROR_FAILURE;
  66
  67   Intl()->TextSubstring(aStartOffset, aEndOffset, aText);
  68   return NS_OK;
  69 }
  70
  71 NS_IMETHODIMP
  72 xpcAccessibleHyperText::GetTextBeforeOffset(
  73     int32_t aOffset, AccessibleTextBoundary aBoundaryType,
  74     int32_t* aStartOffset, int32_t* aEndOffset, nsAString& aText) {
  75   NS_ENSURE_ARG_POINTER(aStartOffset);
  76   NS_ENSURE_ARG_POINTER(aEndOffset);
  77   *aStartOffset = *aEndOffset = 0;
  78   aText.Truncate();
  79
  80   if (!mIntl) return NS_ERROR_FAILURE;
  81
  82   Intl()->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
  83                            aText);
  84   return NS_OK;
  85 }
  86
  87 NS_IMETHODIMP
  88 xpcAccessibleHyperText::GetTextAtOffset(int32_t aOffset,
  89                                         AccessibleTextBoundary aBoundaryType,
  90                                         int32_t* aStartOffset,
  91                                         int32_t* aEndOffset, nsAString& aText) {
  92   NS_ENSURE_ARG_POINTER(aStartOffset);
  93   NS_ENSURE_ARG_POINTER(aEndOffset);
  94   *aStartOffset = *aEndOffset = 0;
  95   aText.Truncate();
  96
  97   if (!mIntl) return NS_ERROR_FAILURE;
  98
  99   Intl()->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
 100   return NS_OK;
 101 }
 102
 103 NS_IMETHODIMP
 104 xpcAccessibleHyperText::GetTextAfterOffset(int32_t aOffset,
 105                                            AccessibleTextBoundary aBoundaryType,
 106                                            int32_t* aStartOffset,
 107                                            int32_t* aEndOffset,
 108                                            nsAString& aText) {
 109   NS_ENSURE_ARG_POINTER(aStartOffset);
 110   NS_ENSURE_ARG_POINTER(aEndOffset);
 111   *aStartOffset = *aEndOffset = 0;
 112   aText.Truncate();
 113
 114   Intl()->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
 115                           aText);
 116   return NS_OK;
 117 }
 118
 119 NS_IMETHODIMP
 120 xpcAccessibleHyperText::GetCharacterAtOffset(int32_t aOffset,
 121                                              char16_t* aCharacter) {
 122   NS_ENSURE_ARG_POINTER(aCharacter);
 123   *aCharacter = L'\0';
 124
 125   if (!mIntl) return NS_ERROR_FAILURE;
 126
 127   if (mIntl->IsLocal()) {
 128     *aCharacter = IntlLocal()->CharAt(aOffset);
 129   } else {
 130 #if defined(XP_WIN)
 131     return NS_ERROR_NOT_IMPLEMENTED;
 132 #else
 133     *aCharacter = mIntl->AsRemote()->CharAt(aOffset);
 134 #endif
 135   }
 136   return NS_OK;
 137 }
 138
 139 NS_IMETHODIMP
 140 xpcAccessibleHyperText::GetTextAttributes(
 141     bool aIncludeDefAttrs, int32_t aOffset, int32_t* aStartOffset,
 142     int32_t* aEndOffset, nsIPersistentProperties** aAttributes) {
 143   NS_ENSURE_ARG_POINTER(aStartOffset);
 144   NS_ENSURE_ARG_POINTER(aEndOffset);
 145   NS_ENSURE_ARG_POINTER(aAttributes);
 146   *aStartOffset = *aEndOffset = 0;
 147   *aAttributes = nullptr;
 148
 149   if (!mIntl) return NS_ERROR_FAILURE;
 150
 151   if (mIntl->IsRemote() &&
 152       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 153     return NS_ERROR_NOT_IMPLEMENTED;
 154   }
 155
 156   RefPtr<AccAttributes> attributes = Intl()->TextAttributes(
 157       aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
 158   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 159   nsAutoString unused;
 160   for (auto iter : *attributes) {
 161     nsAutoString name;
 162     iter.NameAsString(name);
 163
 164     nsAutoString value;
 165     iter.ValueAsString(value);
 166
 167     props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 168   }
 169
 170   props.forget(aAttributes);
 171   return NS_OK;
 172 }
 173
 174 NS_IMETHODIMP
 175 xpcAccessibleHyperText::GetDefaultTextAttributes(
 176     nsIPersistentProperties** aAttributes) {
 177   NS_ENSURE_ARG_POINTER(aAttributes);
 178   *aAttributes = nullptr;
 179
 180   if (!mIntl) return NS_ERROR_FAILURE;
 181
 182   if (mIntl->IsRemote() &&
 183       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 184     return NS_ERROR_NOT_IMPLEMENTED;
 185   }
 186
 187   RefPtr<AccAttributes> attributes = Intl()->DefaultTextAttributes();
 188   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 189   nsAutoString unused;
 190   for (auto iter : *attributes) {
 191     nsAutoString name;
 192     iter.NameAsString(name);
 193
 194     nsAutoString value;
 195     iter.ValueAsString(value);
 196
 197     props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 198   }
 199
 200   props.forget(aAttributes);
 201
 202   return NS_OK;
 203 }
 204
 205 NS_IMETHODIMP
 206 xpcAccessibleHyperText::GetCharacterExtents(int32_t aOffset, int32_t* aX,
 207                                             int32_t* aY, int32_t* aWidth,
 208                                             int32_t* aHeight,
 209                                             uint32_t aCoordType) {
 210   NS_ENSURE_ARG_POINTER(aX);
 211   NS_ENSURE_ARG_POINTER(aY);
 212   NS_ENSURE_ARG_POINTER(aWidth);
 213   NS_ENSURE_ARG_POINTER(aHeight);
 214   *aX = *aY = *aWidth = *aHeight;
 215
 216   if (!mIntl) return NS_ERROR_FAILURE;
 217
 218 #if defined(XP_WIN)
 219   if (mIntl->IsRemote() &&
 220       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 221     return NS_ERROR_NOT_IMPLEMENTED;
 222   }
 223 #endif
 224
 225   LayoutDeviceIntRect rect = Intl()->CharBounds(aOffset, aCoordType);
 226   rect.GetRect(aX, aY, aWidth, aHeight);
 227   return NS_OK;
 228 }
 229
 230 NS_IMETHODIMP
 231 xpcAccessibleHyperText::GetRangeExtents(int32_t aStartOffset,
 232                                         int32_t aEndOffset, int32_t* aX,
 233                                         int32_t* aY, int32_t* aWidth,
 234                                         int32_t* aHeight, uint32_t aCoordType) {
 235   NS_ENSURE_ARG_POINTER(aX);
 236   NS_ENSURE_ARG_POINTER(aY);
 237   NS_ENSURE_ARG_POINTER(aWidth);
 238   NS_ENSURE_ARG_POINTER(aHeight);
 239   *aX = *aY = *aWidth = *aHeight = 0;
 240
 241   if (!mIntl) return NS_ERROR_FAILURE;
 242
 243 #if defined(XP_WIN)
 244   if (mIntl->IsRemote() &&
 245       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 246     return NS_ERROR_NOT_IMPLEMENTED;
 247   }
 248 #endif
 249
 250   LayoutDeviceIntRect rect =
 251       Intl()->TextBounds(aStartOffset, aEndOffset, aCoordType);
 252   rect.GetRect(aX, aY, aWidth, aHeight);
 253   return NS_OK;
 254 }
 255
 256 NS_IMETHODIMP
 257 xpcAccessibleHyperText::GetOffsetAtPoint(int32_t aX, int32_t aY,
 258                                          uint32_t aCoordType,
 259                                          int32_t* aOffset) {
 260   NS_ENSURE_ARG_POINTER(aOffset);
 261   *aOffset = -1;
 262
 263   if (!mIntl) return NS_ERROR_FAILURE;
 264
 265   *aOffset = Intl()->OffsetAtPoint(aX, aY, aCoordType);
 266   return NS_OK;
 267 }
 268
 269 NS_IMETHODIMP
 270 xpcAccessibleHyperText::GetCaretOffset(int32_t* aCaretOffset) {
 271   NS_ENSURE_ARG_POINTER(aCaretOffset);
 272   *aCaretOffset = -1;
 273
 274   if (!mIntl) return NS_ERROR_FAILURE;
 275
 276   *aCaretOffset = Intl()->CaretOffset();
 277   return NS_OK;
 278 }
 279
 280 NS_IMETHODIMP
 281 xpcAccessibleHyperText::SetCaretOffset(int32_t aCaretOffset) {
 282   if (!mIntl) return NS_ERROR_FAILURE;
 283
 284   Intl()->SetCaretOffset(aCaretOffset);
 285   return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 xpcAccessibleHyperText::GetSelectionCount(int32_t* aSelectionCount) {
 290   NS_ENSURE_ARG_POINTER(aSelectionCount);
 291   *aSelectionCount = 0;
 292
 293   if (!mIntl) return NS_ERROR_FAILURE;
 294
 295 #if defined(XP_WIN)
 296   if (mIntl->IsRemote() &&
 297       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 298     return NS_ERROR_NOT_IMPLEMENTED;
 299   }
 300 #endif
 301
 302   *aSelectionCount = Intl()->SelectionCount();
 303   return NS_OK;
 304 }
 305
 306 NS_IMETHODIMP
 307 xpcAccessibleHyperText::GetSelectionBounds(int32_t aSelectionNum,
 308                                            int32_t* aStartOffset,
 309                                            int32_t* aEndOffset) {
 310   NS_ENSURE_ARG_POINTER(aStartOffset);
 311   NS_ENSURE_ARG_POINTER(aEndOffset);
 312   *aStartOffset = *aEndOffset = 0;
 313
 314   if (!mIntl) return NS_ERROR_FAILURE;
 315
 316   if (aSelectionNum < 0) return NS_ERROR_INVALID_ARG;
 317
 318   if (mIntl->IsLocal() ||
 319       StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 320     if (aSelectionNum >= Intl()->SelectionCount()) {
 321       return NS_ERROR_INVALID_ARG;
 322     }
 323
 324     Intl()->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
 325   } else {
 326 #if defined(XP_WIN)
 327     return NS_ERROR_NOT_IMPLEMENTED;
 328 #else
 329     nsString unused;
 330     mIntl->AsRemote()->SelectionBoundsAt(aSelectionNum, unused, aStartOffset,
 331                                          aEndOffset);
 332 #endif
 333   }
 334   return NS_OK;
 335 }
 336
 337 NS_IMETHODIMP
 338 xpcAccessibleHyperText::SetSelectionBounds(int32_t aSelectionNum,
 339                                            int32_t aStartOffset,
 340                                            int32_t aEndOffset) {
 341   if (!mIntl) return NS_ERROR_FAILURE;
 342
 343   if (aSelectionNum < 0) return NS_ERROR_INVALID_ARG;
 344
 345   if (mIntl->IsLocal()) {
 346     if (!IntlLocal()->SetSelectionBoundsAt(aSelectionNum, aStartOffset,
 347                                            aEndOffset)) {
 348       return NS_ERROR_INVALID_ARG;
 349     }
 350   } else {
 351 #if defined(XP_WIN)
 352     return NS_ERROR_NOT_IMPLEMENTED;
 353 #else
 354     if (!mIntl->AsRemote()->SetSelectionBoundsAt(aSelectionNum, aStartOffset,
 355                                                  aEndOffset)) {
 356       return NS_ERROR_INVALID_ARG;
 357     }
 358 #endif
 359   }
 360   return NS_OK;
 361 }
 362
 363 NS_IMETHODIMP
 364 xpcAccessibleHyperText::AddSelection(int32_t aStartOffset, int32_t aEndOffset) {
 365   if (!mIntl) return NS_ERROR_FAILURE;
 366
 367   if (mIntl->IsLocal()) {
 368     IntlLocal()->AddToSelection(aStartOffset, aEndOffset);
 369   } else {
 370     mIntl->AsRemote()->AddToSelection(aStartOffset, aEndOffset);
 371   }
 372   return NS_OK;
 373 }
 374
 375 NS_IMETHODIMP
 376 xpcAccessibleHyperText::RemoveSelection(int32_t aSelectionNum) {
 377   if (!mIntl) return NS_ERROR_FAILURE;
 378
 379   if (mIntl->IsLocal()) {
 380     IntlLocal()->RemoveFromSelection(aSelectionNum);
 381   } else {
 382     mIntl->AsRemote()->RemoveFromSelection(aSelectionNum);
 383   }
 384   return NS_OK;
 385 }
 386
 387 NS_IMETHODIMP
 388 xpcAccessibleHyperText::ScrollSubstringTo(int32_t aStartOffset,
 389                                           int32_t aEndOffset,
 390                                           uint32_t aScrollType) {
 391   if (!mIntl) return NS_ERROR_FAILURE;
 392
 393   if (mIntl->IsLocal()) {
 394     IntlLocal()->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
 395   } else {
 396     mIntl->AsRemote()->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
 397   }
 398   return NS_OK;
 399 }
 400
 401 NS_IMETHODIMP
 402 xpcAccessibleHyperText::ScrollSubstringToPoint(int32_t aStartOffset,
 403                                                int32_t aEndOffset,
 404                                                uint32_t aCoordinateType,
 405                                                int32_t aX, int32_t aY) {
 406   if (!mIntl) return NS_ERROR_FAILURE;
 407
 408   if (mIntl->IsLocal()) {
 409     IntlLocal()->ScrollSubstringToPoint(aStartOffset, aEndOffset,
 410                                         aCoordinateType, aX, aY);
 411   } else {
 412     mIntl->AsRemote()->ScrollSubstringToPoint(aStartOffset, aEndOffset,
 413                                               aCoordinateType, aX, aY);
 414   }
 415   return NS_OK;
 416 }
 417
 418 NS_IMETHODIMP
 419 xpcAccessibleHyperText::GetEnclosingRange(nsIAccessibleTextRange** aRange) {
 420   NS_ENSURE_ARG_POINTER(aRange);
 421   *aRange = nullptr;
 422
 423   if (!IntlLocal()) return NS_ERROR_FAILURE;
 424
 425   TextRange range;
 426   IntlLocal()->EnclosingRange(range);
 427   NS_ASSERTION(range.IsValid(), "Should always have an enclosing range!");
 428   RefPtr<xpcAccessibleTextRange> xpcRange = new xpcAccessibleTextRange(range);
 429
 430   xpcRange.forget(aRange);
 431
 432   return NS_OK;
 433 }
 434
 435 NS_IMETHODIMP
 436 xpcAccessibleHyperText::GetSelectionRanges(nsIArray** aRanges) {
 437   NS_ENSURE_ARG_POINTER(aRanges);
 438   *aRanges = nullptr;
 439
 440   if (!IntlLocal() && !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 441     return NS_ERROR_FAILURE;
 442   }
 443
 444   nsresult rv = NS_OK;
 445   nsCOMPtr<nsIMutableArray> xpcRanges =
 446       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 447   NS_ENSURE_SUCCESS(rv, rv);
 448
 449   AutoTArray<TextRange, 1> ranges;
 450   Intl()->SelectionRanges(&ranges);
 451   uint32_t len = ranges.Length();
 452   for (uint32_t idx = 0; idx < len; idx++) {
 453     xpcRanges->AppendElement(new xpcAccessibleTextRange(ranges[idx]));
 454   }
 455
 456   xpcRanges.forget(aRanges);
 457   return NS_OK;
 458 }
 459
 460 NS_IMETHODIMP
 461 xpcAccessibleHyperText::GetVisibleRanges(nsIArray** aRanges) {
 462   NS_ENSURE_ARG_POINTER(aRanges);
 463   *aRanges = nullptr;
 464
 465   if (!IntlLocal()) return NS_ERROR_FAILURE;
 466
 467   nsresult rv = NS_OK;
 468   nsCOMPtr<nsIMutableArray> xpcRanges =
 469       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 470   NS_ENSURE_SUCCESS(rv, rv);
 471
 472   nsTArray<TextRange> ranges;
 473   IntlLocal()->VisibleRanges(&ranges);
 474   uint32_t len = ranges.Length();
 475   for (uint32_t idx = 0; idx < len; idx++) {
 476     xpcRanges->AppendElement(new xpcAccessibleTextRange(ranges[idx]));
 477   }
 478
 479   xpcRanges.forget(aRanges);
 480   return NS_OK;
 481 }
 482
 483 NS_IMETHODIMP
 484 xpcAccessibleHyperText::GetRangeByChild(nsIAccessible* aChild,
 485                                         nsIAccessibleTextRange** aRange) {
 486   NS_ENSURE_ARG_POINTER(aRange);
 487   *aRange = nullptr;
 488
 489   if (!IntlLocal()) return NS_ERROR_FAILURE;
 490
 491   LocalAccessible* child = aChild->ToInternalAccessible();
 492   if (child) {
 493     TextRange range;
 494     IntlLocal()->RangeByChild(child, range);
 495     if (range.IsValid()) {
 496       RefPtr<xpcAccessibleTextRange> xpcRange =
 497           new xpcAccessibleTextRange(range);
 498       xpcRange.forget(aRange);
 499     }
 500   }
 501
 502   return NS_OK;
 503 }
 504
 505 NS_IMETHODIMP
 506 xpcAccessibleHyperText::GetRangeAtPoint(int32_t aX, int32_t aY,
 507                                         nsIAccessibleTextRange** aRange) {
 508   NS_ENSURE_ARG_POINTER(aRange);
 509   *aRange = nullptr;
 510
 511   if (!IntlLocal()) return NS_ERROR_FAILURE;
 512
 513   TextRange range;
 514   IntlLocal()->RangeAtPoint(aX, aY, range);
 515   if (range.IsValid()) {
 516     RefPtr<xpcAccessibleTextRange> xpcRange = new xpcAccessibleTextRange(range);
 517     xpcRange.forget(aRange);
 518   }
 519
 520   return NS_OK;
 521 }
 522
 523 ////////////////////////////////////////////////////////////////////////////////
 524 // nsIAccessibleEditableText
 525
 526 NS_IMETHODIMP
 527 xpcAccessibleHyperText::SetTextContents(const nsAString& aText) {
 528   if (!mIntl) return NS_ERROR_FAILURE;
 529
 530   if (mIntl->IsLocal()) {
 531     IntlLocal()->ReplaceText(aText);
 532   } else {
 533 #if defined(XP_WIN)
 534     return NS_ERROR_NOT_IMPLEMENTED;
 535 #else
 536     nsString text(aText);
 537     mIntl->AsRemote()->ReplaceText(text);
 538 #endif
 539   }
 540   return NS_OK;
 541 }
 542
 543 NS_IMETHODIMP
 544 xpcAccessibleHyperText::InsertText(const nsAString& aText, int32_t aOffset) {
 545   if (!mIntl) return NS_ERROR_FAILURE;
 546
 547   if (mIntl->IsLocal()) {
 548     IntlLocal()->InsertText(aText, aOffset);
 549   } else {
 550 #if defined(XP_WIN)
 551     return NS_ERROR_NOT_IMPLEMENTED;
 552 #else
 553     nsString text(aText);
 554     mIntl->AsRemote()->InsertText(text, aOffset);
 555 #endif
 556   }
 557   return NS_OK;
 558 }
 559
 560 NS_IMETHODIMP
 561 xpcAccessibleHyperText::CopyText(int32_t aStartOffset, int32_t aEndOffset) {
 562   if (!mIntl) return NS_ERROR_FAILURE;
 563
 564   if (mIntl->IsLocal()) {
 565     IntlLocal()->CopyText(aStartOffset, aEndOffset);
 566   } else {
 567 #if defined(XP_WIN)
 568     return NS_ERROR_NOT_IMPLEMENTED;
 569 #else
 570     mIntl->AsRemote()->CopyText(aStartOffset, aEndOffset);
 571 #endif
 572   }
 573   return NS_OK;
 574 }
 575
 576 NS_IMETHODIMP
 577 xpcAccessibleHyperText::CutText(int32_t aStartOffset, int32_t aEndOffset) {
 578   if (!mIntl) return NS_ERROR_FAILURE;
 579
 580   if (mIntl->IsLocal()) {
 581     IntlLocal()->CutText(aStartOffset, aEndOffset);
 582   } else {
 583 #if defined(XP_WIN)
 584     return NS_ERROR_NOT_IMPLEMENTED;
 585 #else
 586     mIntl->AsRemote()->CutText(aStartOffset, aEndOffset);
 587 #endif
 588   }
 589   return NS_OK;
 590 }
 591
 592 NS_IMETHODIMP
 593 xpcAccessibleHyperText::DeleteText(int32_t aStartOffset, int32_t aEndOffset) {
 594   if (!mIntl) return NS_ERROR_FAILURE;
 595
 596   if (mIntl->IsLocal()) {
 597     IntlLocal()->DeleteText(aStartOffset, aEndOffset);
 598   } else {
 599 #if defined(XP_WIN)
 600     return NS_ERROR_NOT_IMPLEMENTED;
 601 #else
 602     mIntl->AsRemote()->DeleteText(aStartOffset, aEndOffset);
 603 #endif
 604   }
 605   return NS_OK;
 606 }
 607
 608 NS_IMETHODIMP
 609 xpcAccessibleHyperText::PasteText(int32_t aOffset) {
 610   if (!mIntl) return NS_ERROR_FAILURE;
 611
 612   if (mIntl->IsLocal()) {
 613     RefPtr<HyperTextAccessible> acc = IntlLocal();
 614     acc->PasteText(aOffset);
 615   } else {
 616 #if defined(XP_WIN)
 617     return NS_ERROR_NOT_IMPLEMENTED;
 618 #else
 619     mIntl->AsRemote()->PasteText(aOffset);
 620 #endif
 621   }
 622   return NS_OK;
 623 }
 624
 625 ////////////////////////////////////////////////////////////////////////////////
 626 // nsIAccessibleHyperText
 627
 628 NS_IMETHODIMP
 629 xpcAccessibleHyperText::GetLinkCount(int32_t* aLinkCount) {
 630   NS_ENSURE_ARG_POINTER(aLinkCount);
 631   *aLinkCount = 0;
 632
 633   if (!mIntl) return NS_ERROR_FAILURE;
 634
 635 #if defined(XP_WIN)
 636   if (mIntl->IsRemote() &&
 637       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 638     return NS_ERROR_NOT_IMPLEMENTED;
 639   }
 640 #endif
 641
 642   *aLinkCount = static_cast<int32_t>(Intl()->LinkCount());
 643   return NS_OK;
 644 }
 645
 646 NS_IMETHODIMP
 647 xpcAccessibleHyperText::GetLinkAt(int32_t aIndex,
 648                                   nsIAccessibleHyperLink** aLink) {
 649   NS_ENSURE_ARG_POINTER(aLink);
 650   *aLink = nullptr;
 651
 652   if (!mIntl) return NS_ERROR_FAILURE;
 653
 654 #if defined(XP_WIN)
 655   if (mIntl->IsRemote() &&
 656       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 657     return NS_ERROR_NOT_IMPLEMENTED;
 658   }
 659 #endif
 660
 661   NS_IF_ADDREF(*aLink = ToXPC(Intl()->LinkAt(aIndex)));
 662   return NS_OK;
 663 }
 664
 665 NS_IMETHODIMP
 666 xpcAccessibleHyperText::GetLinkIndex(nsIAccessibleHyperLink* aLink,
 667                                      int32_t* aIndex) {
 668   NS_ENSURE_ARG_POINTER(aLink);
 669   NS_ENSURE_ARG_POINTER(aIndex);
 670   *aIndex = -1;
 671
 672   if (!mIntl) return NS_ERROR_FAILURE;
 673
 674   nsCOMPtr<nsIAccessible> xpcLink(do_QueryInterface(aLink));
 675   Accessible* accLink = xpcLink->ToInternalGeneric();
 676 #if defined(XP_WIN)
 677   if (accLink->IsRemote() &&
 678       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 679     return NS_ERROR_NOT_IMPLEMENTED;
 680   }
 681 #endif
 682   *aIndex = Intl()->LinkIndexOf(accLink);
 683   return NS_OK;
 684 }
 685
 686 NS_IMETHODIMP
 687 xpcAccessibleHyperText::GetLinkIndexAtOffset(int32_t aOffset,
 688                                              int32_t* aLinkIndex) {
 689   NS_ENSURE_ARG_POINTER(aLinkIndex);
 690   *aLinkIndex = -1;  // API says this magic value means 'not found'
 691
 692   if (!mIntl) return NS_ERROR_FAILURE;
 693
 694 #if defined(XP_WIN)
 695   if (mIntl->IsRemote() &&
 696       !StaticPrefs::accessibility_cache_enabled_AtStartup()) {
 697     return NS_ERROR_NOT_IMPLEMENTED;
 698   }
 699 #endif
 700
 701   *aLinkIndex = Intl()->LinkIndexAtOffset(aOffset);
 702   return NS_OK;
 703 }