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 "TextRange.h"
  10 #include "AccAttributes.h"
  11 #include "nsComponentManagerUtils.h"
  12 #include "nsPersistentProperties.h"
  13 #include "xpcAccessibleDocument.h"
  14 #include "xpcAccessibleTextRange.h"
  15
  16 #include "nsIMutableArray.h"
  17
  18 using namespace mozilla::a11y;
  19
  20 ////////////////////////////////////////////////////////////////////////////////
  21 // nsISupports
  22
  23 NS_INTERFACE_MAP_BEGIN(xpcAccessibleHyperText)
  24   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleText,
  25                                      mSupportedIfaces & eText)
  26   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleEditableText,
  27                                      mSupportedIfaces & eText)
  28   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperText,
  29                                      mSupportedIfaces & eText)
  30 NS_INTERFACE_MAP_END_INHERITING(xpcAccessibleGeneric)
  31
  32 NS_IMPL_ADDREF_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
  33 NS_IMPL_RELEASE_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
  34
  35 ////////////////////////////////////////////////////////////////////////////////
  36 // nsIAccessibleText
  37
  38 NS_IMETHODIMP
  39 xpcAccessibleHyperText::GetCharacterCount(int32_t* aCharacterCount) {
  40   NS_ENSURE_ARG_POINTER(aCharacterCount);
  41   *aCharacterCount = 0;
  42
  43   if (!mIntl) return NS_ERROR_FAILURE;
  44
  45   *aCharacterCount = static_cast<int32_t>(Intl()->CharacterCount());
  46   return NS_OK;
  47 }
  48
  49 NS_IMETHODIMP
  50 xpcAccessibleHyperText::GetText(int32_t aStartOffset, int32_t aEndOffset,
  51                                 nsAString& aText) {
  52   aText.Truncate();
  53
  54   if (!mIntl) return NS_ERROR_FAILURE;
  55
  56   Intl()->TextSubstring(aStartOffset, aEndOffset, aText);
  57   return NS_OK;
  58 }
  59
  60 NS_IMETHODIMP
  61 xpcAccessibleHyperText::GetTextBeforeOffset(
  62     int32_t aOffset, AccessibleTextBoundary aBoundaryType,
  63     int32_t* aStartOffset, int32_t* aEndOffset, nsAString& aText) {
  64   NS_ENSURE_ARG_POINTER(aStartOffset);
  65   NS_ENSURE_ARG_POINTER(aEndOffset);
  66   *aStartOffset = *aEndOffset = 0;
  67   aText.Truncate();
  68
  69   if (!mIntl) return NS_ERROR_FAILURE;
  70
  71   Intl()->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
  72                            aText);
  73   return NS_OK;
  74 }
  75
  76 NS_IMETHODIMP
  77 xpcAccessibleHyperText::GetTextAtOffset(int32_t aOffset,
  78                                         AccessibleTextBoundary aBoundaryType,
  79                                         int32_t* aStartOffset,
  80                                         int32_t* aEndOffset, nsAString& aText) {
  81   NS_ENSURE_ARG_POINTER(aStartOffset);
  82   NS_ENSURE_ARG_POINTER(aEndOffset);
  83   *aStartOffset = *aEndOffset = 0;
  84   aText.Truncate();
  85
  86   if (!mIntl) return NS_ERROR_FAILURE;
  87
  88   Intl()->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
  89   return NS_OK;
  90 }
  91
  92 NS_IMETHODIMP
  93 xpcAccessibleHyperText::GetTextAfterOffset(int32_t aOffset,
  94                                            AccessibleTextBoundary aBoundaryType,
  95                                            int32_t* aStartOffset,
  96                                            int32_t* aEndOffset,
  97                                            nsAString& aText) {
  98   NS_ENSURE_ARG_POINTER(aStartOffset);
  99   NS_ENSURE_ARG_POINTER(aEndOffset);
 100   *aStartOffset = *aEndOffset = 0;
 101   aText.Truncate();
 102
 103   Intl()->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset,
 104                           aText);
 105   return NS_OK;
 106 }
 107
 108 NS_IMETHODIMP
 109 xpcAccessibleHyperText::GetCharacterAtOffset(int32_t aOffset,
 110                                              char16_t* aCharacter) {
 111   NS_ENSURE_ARG_POINTER(aCharacter);
 112   *aCharacter = L'\0';
 113
 114   if (!mIntl) return NS_ERROR_FAILURE;
 115
 116   *aCharacter = Intl()->CharAt(aOffset);
 117   return NS_OK;
 118 }
 119
 120 NS_IMETHODIMP
 121 xpcAccessibleHyperText::GetTextAttributes(
 122     bool aIncludeDefAttrs, int32_t aOffset, int32_t* aStartOffset,
 123     int32_t* aEndOffset, nsIPersistentProperties** aAttributes) {
 124   NS_ENSURE_ARG_POINTER(aStartOffset);
 125   NS_ENSURE_ARG_POINTER(aEndOffset);
 126   NS_ENSURE_ARG_POINTER(aAttributes);
 127   *aStartOffset = *aEndOffset = 0;
 128   *aAttributes = nullptr;
 129
 130   if (!mIntl) return NS_ERROR_FAILURE;
 131
 132   RefPtr<AccAttributes> attributes = Intl()->TextAttributes(
 133       aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
 134   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 135   nsAutoString unused;
 136   for (auto iter : *attributes) {
 137     nsAutoString name;
 138     iter.NameAsString(name);
 139
 140     nsAutoString value;
 141     iter.ValueAsString(value);
 142
 143     props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 144   }
 145
 146   props.forget(aAttributes);
 147   return NS_OK;
 148 }
 149
 150 NS_IMETHODIMP
 151 xpcAccessibleHyperText::GetDefaultTextAttributes(
 152     nsIPersistentProperties** aAttributes) {
 153   NS_ENSURE_ARG_POINTER(aAttributes);
 154   *aAttributes = nullptr;
 155
 156   if (!mIntl) return NS_ERROR_FAILURE;
 157
 158   RefPtr<AccAttributes> attributes = Intl()->DefaultTextAttributes();
 159   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 160   nsAutoString unused;
 161   for (auto iter : *attributes) {
 162     nsAutoString name;
 163     iter.NameAsString(name);
 164
 165     nsAutoString value;
 166     iter.ValueAsString(value);
 167
 168     props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 169   }
 170
 171   props.forget(aAttributes);
 172
 173   return NS_OK;
 174 }
 175
 176 NS_IMETHODIMP
 177 xpcAccessibleHyperText::GetCharacterExtents(int32_t aOffset, int32_t* aX,
 178                                             int32_t* aY, int32_t* aWidth,
 179                                             int32_t* aHeight,
 180                                             uint32_t aCoordType) {
 181   NS_ENSURE_ARG_POINTER(aX);
 182   NS_ENSURE_ARG_POINTER(aY);
 183   NS_ENSURE_ARG_POINTER(aWidth);
 184   NS_ENSURE_ARG_POINTER(aHeight);
 185   *aX = *aY = *aWidth = *aHeight;
 186
 187   if (!mIntl) return NS_ERROR_FAILURE;
 188
 189   LayoutDeviceIntRect rect = Intl()->CharBounds(aOffset, aCoordType);
 190   rect.GetRect(aX, aY, aWidth, aHeight);
 191   return NS_OK;
 192 }
 193
 194 NS_IMETHODIMP
 195 xpcAccessibleHyperText::GetRangeExtents(int32_t aStartOffset,
 196                                         int32_t aEndOffset, int32_t* aX,
 197                                         int32_t* aY, int32_t* aWidth,
 198                                         int32_t* aHeight, uint32_t aCoordType) {
 199   NS_ENSURE_ARG_POINTER(aX);
 200   NS_ENSURE_ARG_POINTER(aY);
 201   NS_ENSURE_ARG_POINTER(aWidth);
 202   NS_ENSURE_ARG_POINTER(aHeight);
 203   *aX = *aY = *aWidth = *aHeight = 0;
 204
 205   if (!mIntl) return NS_ERROR_FAILURE;
 206
 207   LayoutDeviceIntRect rect =
 208       Intl()->TextBounds(aStartOffset, aEndOffset, aCoordType);
 209   rect.GetRect(aX, aY, aWidth, aHeight);
 210   return NS_OK;
 211 }
 212
 213 NS_IMETHODIMP
 214 xpcAccessibleHyperText::GetOffsetAtPoint(int32_t aX, int32_t aY,
 215                                          uint32_t aCoordType,
 216                                          int32_t* aOffset) {
 217   NS_ENSURE_ARG_POINTER(aOffset);
 218   *aOffset = -1;
 219
 220   if (!mIntl) return NS_ERROR_FAILURE;
 221
 222   *aOffset = Intl()->OffsetAtPoint(aX, aY, aCoordType);
 223   return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 xpcAccessibleHyperText::GetCaretOffset(int32_t* aCaretOffset) {
 228   NS_ENSURE_ARG_POINTER(aCaretOffset);
 229   *aCaretOffset = -1;
 230
 231   if (!mIntl) return NS_ERROR_FAILURE;
 232
 233   *aCaretOffset = Intl()->CaretOffset();
 234   return NS_OK;
 235 }
 236
 237 NS_IMETHODIMP
 238 xpcAccessibleHyperText::SetCaretOffset(int32_t aCaretOffset) {
 239   if (!mIntl) return NS_ERROR_FAILURE;
 240
 241   Intl()->SetCaretOffset(aCaretOffset);
 242   return NS_OK;
 243 }
 244
 245 NS_IMETHODIMP
 246 xpcAccessibleHyperText::GetCaretRect(int32_t* aX, int32_t* aY, int32_t* aWidth,
 247                                      int32_t* aHeight) {
 248   NS_ENSURE_ARG_POINTER(aX);
 249   NS_ENSURE_ARG_POINTER(aY);
 250   NS_ENSURE_ARG_POINTER(aWidth);
 251   NS_ENSURE_ARG_POINTER(aHeight);
 252   *aX = *aY = *aWidth = *aHeight;
 253
 254   if (!mIntl) {
 255     return NS_ERROR_FAILURE;
 256   }
 257   if (mIntl->IsRemote()) {
 258     return NS_ERROR_NOT_IMPLEMENTED;
 259   }
 260
 261   nsIWidget* widget;
 262   LayoutDeviceIntRect rect = IntlLocal()->GetCaretRect(&widget);
 263   rect.GetRect(aX, aY, aWidth, aHeight);
 264   return NS_OK;
 265 }
 266
 267 NS_IMETHODIMP
 268 xpcAccessibleHyperText::GetSelectionCount(int32_t* aSelectionCount) {
 269   NS_ENSURE_ARG_POINTER(aSelectionCount);
 270   *aSelectionCount = 0;
 271
 272   if (!mIntl) return NS_ERROR_FAILURE;
 273
 274   *aSelectionCount = Intl()->SelectionCount();
 275   return NS_OK;
 276 }
 277
 278 NS_IMETHODIMP
 279 xpcAccessibleHyperText::GetSelectionBounds(int32_t aSelectionNum,
 280                                            int32_t* aStartOffset,
 281                                            int32_t* aEndOffset) {
 282   NS_ENSURE_ARG_POINTER(aStartOffset);
 283   NS_ENSURE_ARG_POINTER(aEndOffset);
 284   *aStartOffset = *aEndOffset = 0;
 285
 286   if (!mIntl) return NS_ERROR_FAILURE;
 287
 288   if (aSelectionNum < 0) return NS_ERROR_INVALID_ARG;
 289
 290   if (aSelectionNum >= Intl()->SelectionCount()) {
 291     return NS_ERROR_INVALID_ARG;
 292   }
 293
 294   Intl()->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
 295   return NS_OK;
 296 }
 297
 298 NS_IMETHODIMP
 299 xpcAccessibleHyperText::SetSelectionBounds(int32_t aSelectionNum,
 300                                            int32_t aStartOffset,
 301                                            int32_t aEndOffset) {
 302   if (!mIntl) return NS_ERROR_FAILURE;
 303
 304   if (aSelectionNum < 0) return NS_ERROR_INVALID_ARG;
 305
 306   Intl()->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
 307   return NS_OK;
 308 }
 309
 310 NS_IMETHODIMP
 311 xpcAccessibleHyperText::AddSelection(int32_t aStartOffset, int32_t aEndOffset) {
 312   if (!mIntl) return NS_ERROR_FAILURE;
 313
 314   Intl()->AddToSelection(aStartOffset, aEndOffset);
 315   return NS_OK;
 316 }
 317
 318 NS_IMETHODIMP
 319 xpcAccessibleHyperText::RemoveSelection(int32_t aSelectionNum) {
 320   if (!mIntl) return NS_ERROR_FAILURE;
 321
 322   Intl()->RemoveFromSelection(aSelectionNum);
 323   return NS_OK;
 324 }
 325
 326 NS_IMETHODIMP
 327 xpcAccessibleHyperText::ScrollSubstringTo(int32_t aStartOffset,
 328                                           int32_t aEndOffset,
 329                                           uint32_t aScrollType) {
 330   if (!mIntl) return NS_ERROR_FAILURE;
 331
 332   Intl()->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
 333   return NS_OK;
 334 }
 335
 336 NS_IMETHODIMP
 337 xpcAccessibleHyperText::ScrollSubstringToPoint(int32_t aStartOffset,
 338                                                int32_t aEndOffset,
 339                                                uint32_t aCoordinateType,
 340                                                int32_t aX, int32_t aY) {
 341   if (!mIntl) return NS_ERROR_FAILURE;
 342
 343   Intl()->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType, aX,
 344                                  aY);
 345   return NS_OK;
 346 }
 347
 348 NS_IMETHODIMP
 349 xpcAccessibleHyperText::GetSelectionRanges(nsIArray** aRanges) {
 350   NS_ENSURE_ARG_POINTER(aRanges);
 351   *aRanges = nullptr;
 352
 353   nsresult rv = NS_OK;
 354   nsCOMPtr<nsIMutableArray> xpcRanges =
 355       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 356   NS_ENSURE_SUCCESS(rv, rv);
 357
 358   AutoTArray<TextRange, 1> ranges;
 359   Intl()->SelectionRanges(&ranges);
 360   uint32_t len = ranges.Length();
 361   for (uint32_t idx = 0; idx < len; idx++) {
 362     xpcRanges->AppendElement(new xpcAccessibleTextRange(ranges[idx]));
 363   }
 364
 365   xpcRanges.forget(aRanges);
 366   return NS_OK;
 367 }
 368
 369 ////////////////////////////////////////////////////////////////////////////////
 370 // nsIAccessibleEditableText
 371
 372 NS_IMETHODIMP
 373 xpcAccessibleHyperText::SetTextContents(const nsAString& aText) {
 374   if (!mIntl) return NS_ERROR_FAILURE;
 375
 376   Intl()->ReplaceText(aText);
 377
 378   return NS_OK;
 379 }
 380
 381 NS_IMETHODIMP
 382 xpcAccessibleHyperText::InsertText(const nsAString& aText, int32_t aOffset) {
 383   if (!mIntl) return NS_ERROR_FAILURE;
 384
 385   Intl()->InsertText(aText, aOffset);
 386
 387   return NS_OK;
 388 }
 389
 390 NS_IMETHODIMP
 391 xpcAccessibleHyperText::CopyText(int32_t aStartOffset, int32_t aEndOffset) {
 392   if (!mIntl) return NS_ERROR_FAILURE;
 393
 394   Intl()->CopyText(aStartOffset, aEndOffset);
 395
 396   return NS_OK;
 397 }
 398
 399 NS_IMETHODIMP
 400 xpcAccessibleHyperText::CutText(int32_t aStartOffset, int32_t aEndOffset) {
 401   if (!mIntl) return NS_ERROR_FAILURE;
 402
 403   Intl()->CutText(aStartOffset, aEndOffset);
 404
 405   return NS_OK;
 406 }
 407
 408 NS_IMETHODIMP
 409 xpcAccessibleHyperText::DeleteText(int32_t aStartOffset, int32_t aEndOffset) {
 410   if (!mIntl) return NS_ERROR_FAILURE;
 411
 412   Intl()->DeleteText(aStartOffset, aEndOffset);
 413
 414   return NS_OK;
 415 }
 416
 417 NS_IMETHODIMP
 418 xpcAccessibleHyperText::PasteText(int32_t aOffset) {
 419   if (!mIntl) return NS_ERROR_FAILURE;
 420
 421   Intl()->PasteText(aOffset);
 422
 423   return NS_OK;
 424 }
 425
 426 ////////////////////////////////////////////////////////////////////////////////
 427 // nsIAccessibleHyperText
 428
 429 NS_IMETHODIMP
 430 xpcAccessibleHyperText::GetLinkCount(int32_t* aLinkCount) {
 431   NS_ENSURE_ARG_POINTER(aLinkCount);
 432   *aLinkCount = 0;
 433
 434   if (!mIntl) return NS_ERROR_FAILURE;
 435
 436   *aLinkCount = static_cast<int32_t>(Intl()->LinkCount());
 437   return NS_OK;
 438 }
 439
 440 NS_IMETHODIMP
 441 xpcAccessibleHyperText::GetLinkAt(int32_t aIndex,
 442                                   nsIAccessibleHyperLink** aLink) {
 443   NS_ENSURE_ARG_POINTER(aLink);
 444   *aLink = nullptr;
 445
 446   if (!mIntl) return NS_ERROR_FAILURE;
 447
 448   NS_IF_ADDREF(*aLink = ToXPC(Intl()->LinkAt(aIndex)));
 449   return NS_OK;
 450 }
 451
 452 NS_IMETHODIMP
 453 xpcAccessibleHyperText::GetLinkIndex(nsIAccessibleHyperLink* aLink,
 454                                      int32_t* aIndex) {
 455   NS_ENSURE_ARG_POINTER(aLink);
 456   NS_ENSURE_ARG_POINTER(aIndex);
 457   *aIndex = -1;
 458
 459   if (!mIntl) return NS_ERROR_FAILURE;
 460
 461   nsCOMPtr<nsIAccessible> xpcLink(do_QueryInterface(aLink));
 462   Accessible* accLink = xpcLink->ToInternalGeneric();
 463   *aIndex = Intl()->LinkIndexOf(accLink);
 464   return NS_OK;
 465 }
 466
 467 NS_IMETHODIMP
 468 xpcAccessibleHyperText::GetLinkIndexAtOffset(int32_t aOffset,
 469                                              int32_t* aLinkIndex) {
 470   NS_ENSURE_ARG_POINTER(aLinkIndex);
 471   *aLinkIndex = -1;  // API says this magic value means 'not found'
 472
 473   if (!mIntl) return NS_ERROR_FAILURE;
 474
 475   *aLinkIndex = Intl()->LinkIndexAtOffset(aOffset);
 476   return NS_OK;
 477 }