editor/txtsvc/nsTextServicesDocument.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include <stddef.h>                     // for nullptr
   7
   8 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
   9 #include "mozilla/mozalloc.h"           // for operator new, etc
  10 #include "nsAString.h"                  // for nsAString_internal::Length, etc
  11 #include "nsAutoPtr.h"                  // for nsRefPtr
  12 #include "nsContentUtils.h"             // for nsContentUtils
  13 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
  14 #include "nsDependentSubstring.h"       // for Substring
  15 #include "nsError.h"                    // for NS_OK, NS_ERROR_FAILURE, etc
  16 #include "nsFilteredContentIterator.h"  // for nsFilteredContentIterator
  17 #include "nsIContent.h"                 // for nsIContent, etc
  18 #include "nsIContentIterator.h"         // for nsIContentIterator
  19 #include "nsID.h"                       // for NS_GET_IID
  20 #include "nsIDOMDocument.h"             // for nsIDOMDocument
  21 #include "nsIDOMElement.h"              // for nsIDOMElement
  22 #include "nsIDOMHTMLDocument.h"         // for nsIDOMHTMLDocument
  23 #include "nsIDOMHTMLElement.h"          // for nsIDOMHTMLElement
  24 #include "nsIDOMNode.h"                 // for nsIDOMNode, etc
  25 #include "nsIDOMRange.h"                // for nsIDOMRange, etc
  26 #include "nsIEditor.h"                  // for nsIEditor, etc
  27 #include "nsINode.h"                    // for nsINode
  28 #include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor
  29 #include "nsISelection.h"               // for nsISelection
  30 #include "nsISelectionController.h"     // for nsISelectionController, etc
  31 #include "nsISupportsBase.h"            // for nsISupports
  32 #include "nsISupportsUtils.h"           // for NS_IF_ADDREF, NS_ADDREF, etc
  33 #include "nsITextServicesFilter.h"      // for nsITextServicesFilter
  34 #include "nsIWordBreaker.h"             // for nsWordRange, nsIWordBreaker
  35 #include "nsRange.h"                    // for nsRange
  36 #include "nsStaticAtom.h"               // for NS_STATIC_ATOM, etc
  37 #include "nsString.h"                   // for nsString, nsAutoString
  38 #include "nsTextServicesDocument.h"
  39 #include "nscore.h"                     // for nsresult, NS_IMETHODIMP, etc
  40
  41 #define LOCK_DOC(doc)
  42 #define UNLOCK_DOC(doc)
  43
  44 using namespace mozilla;
  45
  46 class OffsetEntry
  47 {
  48 public:
  49   OffsetEntry(nsIDOMNode *aNode, int32_t aOffset, int32_t aLength)
  50     : mNode(aNode), mNodeOffset(0), mStrOffset(aOffset), mLength(aLength),
  51       mIsInsertedText(false), mIsValid(true)
  52   {
  53     if (mStrOffset < 1)
  54       mStrOffset = 0;
  55
  56     if (mLength < 1)
  57       mLength = 0;
  58   }
  59
  60   virtual ~OffsetEntry()
  61   {
  62     mNode       = 0;
  63     mNodeOffset = 0;
  64     mStrOffset  = 0;
  65     mLength     = 0;
  66     mIsValid    = false;
  67   }
  68
  69   nsIDOMNode *mNode;
  70   int32_t mNodeOffset;
  71   int32_t mStrOffset;
  72   int32_t mLength;
  73   bool    mIsInsertedText;
  74   bool    mIsValid;
  75 };
  76
  77 #define TS_ATOM(name_, value_) nsIAtom* nsTextServicesDocument::name_ = 0;
  78 #include "nsTSAtomList.h" // IWYU pragma: keep
  79 #undef TS_ATOM
  80
  81 nsTextServicesDocument::nsTextServicesDocument()
  82 {
  83   mSelStartIndex  = -1;
  84   mSelStartOffset = -1;
  85   mSelEndIndex    = -1;
  86   mSelEndOffset   = -1;
  87
  88   mIteratorStatus = eIsDone;
  89 }
  90
  91 nsTextServicesDocument::~nsTextServicesDocument()
  92 {
  93   ClearOffsetTable(&mOffsetTable);
  94 }
  95
  96 #define TS_ATOM(name_, value_) NS_STATIC_ATOM_BUFFER(name_##_buffer, value_)
  97 #include "nsTSAtomList.h" // IWYU pragma: keep
  98 #undef TS_ATOM
  99
 100 /* static */
 101 void
 102 nsTextServicesDocument::RegisterAtoms()
 103 {
 104   static const nsStaticAtom ts_atoms[] = {
 105 #define TS_ATOM(name_, value_) NS_STATIC_ATOM(name_##_buffer, &name_),
 106 #include "nsTSAtomList.h" // IWYU pragma: keep
 107 #undef TS_ATOM
 108   };
 109
 110   NS_RegisterStaticAtoms(ts_atoms);
 111 }
 112
 113 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTextServicesDocument)
 114 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTextServicesDocument)
 115
 116 NS_INTERFACE_MAP_BEGIN(nsTextServicesDocument)
 117   NS_INTERFACE_MAP_ENTRY(nsITextServicesDocument)
 118   NS_INTERFACE_MAP_ENTRY(nsIEditActionListener)
 119   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITextServicesDocument)
 120   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsTextServicesDocument)
 121 NS_INTERFACE_MAP_END
 122
 123 NS_IMPL_CYCLE_COLLECTION(nsTextServicesDocument,
 124                          mDOMDocument,
 125                          mSelCon,
 126                          mIterator,
 127                          mPrevTextBlock,
 128                          mNextTextBlock,
 129                          mExtent,
 130                          mTxtSvcFilter)
 131
 132 NS_IMETHODIMP
 133 nsTextServicesDocument::InitWithEditor(nsIEditor *aEditor)
 134 {
 135   nsresult result = NS_OK;
 136   nsCOMPtr<nsISelectionController> selCon;
 137   nsCOMPtr<nsIDOMDocument> doc;
 138
 139   NS_ENSURE_TRUE(aEditor, NS_ERROR_NULL_POINTER);
 140
 141   LOCK_DOC(this);
 142
 143   // Check to see if we already have an mSelCon. If we do, it
 144   // better be the same one the editor uses!
 145
 146   result = aEditor->GetSelectionController(getter_AddRefs(selCon));
 147
 148   if (NS_FAILED(result))
 149   {
 150     UNLOCK_DOC(this);
 151     return result;
 152   }
 153
 154   if (!selCon || (mSelCon && selCon != mSelCon))
 155   {
 156     UNLOCK_DOC(this);
 157     return NS_ERROR_FAILURE;
 158   }
 159
 160   if (!mSelCon)
 161     mSelCon = selCon;
 162
 163   // Check to see if we already have an mDOMDocument. If we do, it
 164   // better be the same one the editor uses!
 165
 166   result = aEditor->GetDocument(getter_AddRefs(doc));
 167
 168   if (NS_FAILED(result))
 169   {
 170     UNLOCK_DOC(this);
 171     return result;
 172   }
 173
 174   if (!doc || (mDOMDocument && doc != mDOMDocument))
 175   {
 176     UNLOCK_DOC(this);
 177     return NS_ERROR_FAILURE;
 178   }
 179
 180   if (!mDOMDocument)
 181   {
 182     mDOMDocument = doc;
 183
 184     result = CreateDocumentContentIterator(getter_AddRefs(mIterator));
 185
 186     if (NS_FAILED(result))
 187     {
 188       UNLOCK_DOC(this);
 189       return result;
 190     }
 191
 192     mIteratorStatus = nsTextServicesDocument::eIsDone;
 193
 194     result = FirstBlock();
 195
 196     if (NS_FAILED(result))
 197     {
 198       UNLOCK_DOC(this);
 199       return result;
 200     }
 201   }
 202
 203   mEditor = do_GetWeakReference(aEditor);
 204
 205   result = aEditor->AddEditActionListener(this);
 206
 207   UNLOCK_DOC(this);
 208
 209   return result;
 210 }
 211
 212 NS_IMETHODIMP
 213 nsTextServicesDocument::GetDocument(nsIDOMDocument **aDoc)
 214 {
 215   NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);
 216
 217   *aDoc = nullptr; // init out param
 218   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_NOT_INITIALIZED);
 219
 220   *aDoc = mDOMDocument;
 221   NS_ADDREF(*aDoc);
 222
 223   return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 nsTextServicesDocument::SetExtent(nsIDOMRange* aDOMRange)
 228 {
 229   NS_ENSURE_ARG_POINTER(aDOMRange);
 230   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_FAILURE);
 231
 232   LOCK_DOC(this);
 233
 234   // We need to store a copy of aDOMRange since we don't
 235   // know where it came from.
 236
 237   nsresult result = aDOMRange->CloneRange(getter_AddRefs(mExtent));
 238
 239   if (NS_FAILED(result))
 240   {
 241     UNLOCK_DOC(this);
 242     return result;
 243   }
 244
 245   // Create a new iterator based on our new extent range.
 246
 247   result = CreateContentIterator(mExtent, getter_AddRefs(mIterator));
 248
 249   if (NS_FAILED(result))
 250   {
 251     UNLOCK_DOC(this);
 252     return result;
 253   }
 254
 255   // Now position the iterator at the start of the first block
 256   // in the range.
 257
 258   mIteratorStatus = nsTextServicesDocument::eIsDone;
 259
 260   result = FirstBlock();
 261
 262   UNLOCK_DOC(this);
 263
 264   return result;
 265 }
 266
 267 NS_IMETHODIMP
 268 nsTextServicesDocument::ExpandRangeToWordBoundaries(nsIDOMRange *aRange)
 269 {
 270   NS_ENSURE_ARG_POINTER(aRange);
 271
 272   // Get the end points of the range.
 273
 274   nsCOMPtr<nsIDOMNode> rngStartNode, rngEndNode;
 275   int32_t rngStartOffset, rngEndOffset;
 276
 277   nsresult result =  GetRangeEndPoints(aRange,
 278                                        getter_AddRefs(rngStartNode),
 279                                        &rngStartOffset,
 280                                        getter_AddRefs(rngEndNode),
 281                                        &rngEndOffset);
 282
 283   NS_ENSURE_SUCCESS(result, result);
 284
 285   // Create a content iterator based on the range.
 286
 287   nsCOMPtr<nsIContentIterator> iter;
 288   result = CreateContentIterator(aRange, getter_AddRefs(iter));
 289
 290   NS_ENSURE_SUCCESS(result, result);
 291
 292   // Find the first text node in the range.
 293
 294   TSDIteratorStatus iterStatus;
 295
 296   result = FirstTextNode(iter, &iterStatus);
 297   NS_ENSURE_SUCCESS(result, result);
 298
 299   if (iterStatus == nsTextServicesDocument::eIsDone)
 300   {
 301     // No text was found so there's no adjustment necessary!
 302     return NS_OK;
 303   }
 304
 305   nsINode *firstText = iter->GetCurrentNode();
 306   NS_ENSURE_TRUE(firstText, NS_ERROR_FAILURE);
 307
 308   // Find the last text node in the range.
 309
 310   result = LastTextNode(iter, &iterStatus);
 311   NS_ENSURE_SUCCESS(result, result);
 312
 313   if (iterStatus == nsTextServicesDocument::eIsDone)
 314   {
 315     // We should never get here because a first text block
 316     // was found above.
 317     NS_ASSERTION(false, "Found a first without a last!");
 318     return NS_ERROR_FAILURE;
 319   }
 320
 321   nsINode *lastText = iter->GetCurrentNode();
 322   NS_ENSURE_TRUE(lastText, NS_ERROR_FAILURE);
 323
 324   // Now make sure our end points are in terms of text nodes in the range!
 325
 326   nsCOMPtr<nsIDOMNode> firstTextNode = do_QueryInterface(firstText);
 327   NS_ENSURE_TRUE(firstTextNode, NS_ERROR_FAILURE);
 328
 329   if (rngStartNode != firstTextNode)
 330   {
 331     // The range includes the start of the first text node!
 332     rngStartNode = firstTextNode;
 333     rngStartOffset = 0;
 334   }
 335
 336   nsCOMPtr<nsIDOMNode> lastTextNode = do_QueryInterface(lastText);
 337   NS_ENSURE_TRUE(lastTextNode, NS_ERROR_FAILURE);
 338
 339   if (rngEndNode != lastTextNode)
 340   {
 341     // The range includes the end of the last text node!
 342     rngEndNode = lastTextNode;
 343     nsAutoString str;
 344     result = lastTextNode->GetNodeValue(str);
 345     rngEndOffset = str.Length();
 346   }
 347
 348   // Create a doc iterator so that we can scan beyond
 349   // the bounds of the extent range.
 350
 351   nsCOMPtr<nsIContentIterator> docIter;
 352   result = CreateDocumentContentIterator(getter_AddRefs(docIter));
 353   NS_ENSURE_SUCCESS(result, result);
 354
 355   // Grab all the text in the block containing our
 356   // first text node.
 357
 358   result = docIter->PositionAt(firstText);
 359   NS_ENSURE_SUCCESS(result, result);
 360
 361   iterStatus = nsTextServicesDocument::eValid;
 362
 363   nsTArray<OffsetEntry*> offsetTable;
 364   nsAutoString blockStr;
 365
 366   result = CreateOffsetTable(&offsetTable, docIter, &iterStatus,
 367                              nullptr, &blockStr);
 368   if (NS_FAILED(result))
 369   {
 370     ClearOffsetTable(&offsetTable);
 371     return result;
 372   }
 373
 374   nsCOMPtr<nsIDOMNode> wordStartNode, wordEndNode;
 375   int32_t wordStartOffset, wordEndOffset;
 376
 377   result = FindWordBounds(&offsetTable, &blockStr,
 378                           rngStartNode, rngStartOffset,
 379                           getter_AddRefs(wordStartNode), &wordStartOffset,
 380                           getter_AddRefs(wordEndNode), &wordEndOffset);
 381
 382   ClearOffsetTable(&offsetTable);
 383
 384   NS_ENSURE_SUCCESS(result, result);
 385
 386   rngStartNode = wordStartNode;
 387   rngStartOffset = wordStartOffset;
 388
 389   // Grab all the text in the block containing our
 390   // last text node.
 391
 392   result = docIter->PositionAt(lastText);
 393   NS_ENSURE_SUCCESS(result, result);
 394
 395   iterStatus = nsTextServicesDocument::eValid;
 396
 397   result = CreateOffsetTable(&offsetTable, docIter, &iterStatus,
 398                              nullptr, &blockStr);
 399   if (NS_FAILED(result))
 400   {
 401     ClearOffsetTable(&offsetTable);
 402     return result;
 403   }
 404
 405   result = FindWordBounds(&offsetTable, &blockStr,
 406                           rngEndNode, rngEndOffset,
 407                           getter_AddRefs(wordStartNode), &wordStartOffset,
 408                           getter_AddRefs(wordEndNode), &wordEndOffset);
 409
 410   ClearOffsetTable(&offsetTable);
 411
 412   NS_ENSURE_SUCCESS(result, result);
 413
 414   // To prevent expanding the range too much, we only change
 415   // rngEndNode and rngEndOffset if it isn't already at the start of the
 416   // word and isn't equivalent to rngStartNode and rngStartOffset.
 417
 418   if (rngEndNode != wordStartNode || rngEndOffset != wordStartOffset ||
 419      (rngEndNode == rngStartNode  && rngEndOffset == rngStartOffset))
 420   {
 421     rngEndNode = wordEndNode;
 422     rngEndOffset = wordEndOffset;
 423   }
 424
 425   // Now adjust the range so that it uses our new
 426   // end points.
 427
 428   result = aRange->SetEnd(rngEndNode, rngEndOffset);
 429   NS_ENSURE_SUCCESS(result, result);
 430
 431   return aRange->SetStart(rngStartNode, rngStartOffset);
 432 }
 433
 434 NS_IMETHODIMP
 435 nsTextServicesDocument::SetFilter(nsITextServicesFilter *aFilter)
 436 {
 437   // Hang on to the filter so we can set it into the filtered iterator.
 438   mTxtSvcFilter = aFilter;
 439
 440   return NS_OK;
 441 }
 442
 443 NS_IMETHODIMP
 444 nsTextServicesDocument::GetCurrentTextBlock(nsString *aStr)
 445 {
 446   nsresult result;
 447
 448   NS_ENSURE_TRUE(aStr, NS_ERROR_NULL_POINTER);
 449
 450   aStr->Truncate();
 451
 452   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
 453
 454   LOCK_DOC(this);
 455
 456   result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,
 457                              mExtent, aStr);
 458
 459   UNLOCK_DOC(this);
 460
 461   return result;
 462 }
 463
 464 NS_IMETHODIMP
 465 nsTextServicesDocument::FirstBlock()
 466 {
 467   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
 468
 469   LOCK_DOC(this);
 470
 471   nsresult result = FirstTextNode(mIterator, &mIteratorStatus);
 472
 473   if (NS_FAILED(result))
 474   {
 475     UNLOCK_DOC(this);
 476     return result;
 477   }
 478
 479   // Keep track of prev and next blocks, just in case
 480   // the text service blows away the current block.
 481
 482   if (mIteratorStatus == nsTextServicesDocument::eValid)
 483   {
 484     mPrevTextBlock  = nullptr;
 485     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));
 486   }
 487   else
 488   {
 489     // There's no text block in the document!
 490
 491     mPrevTextBlock  = nullptr;
 492     mNextTextBlock  = nullptr;
 493   }
 494
 495   UNLOCK_DOC(this);
 496
 497   return result;
 498 }
 499
 500 NS_IMETHODIMP
 501 nsTextServicesDocument::LastSelectedBlock(TSDBlockSelectionStatus *aSelStatus,
 502                                           int32_t *aSelOffset,
 503                                           int32_t *aSelLength)
 504 {
 505   nsresult result = NS_OK;
 506
 507   NS_ENSURE_TRUE(aSelStatus && aSelOffset && aSelLength, NS_ERROR_NULL_POINTER);
 508
 509   LOCK_DOC(this);
 510
 511   mIteratorStatus = nsTextServicesDocument::eIsDone;
 512
 513   *aSelStatus = nsITextServicesDocument::eBlockNotFound;
 514   *aSelOffset = *aSelLength = -1;
 515
 516   if (!mSelCon || !mIterator)
 517   {
 518     UNLOCK_DOC(this);
 519     return NS_ERROR_FAILURE;
 520   }
 521
 522   nsCOMPtr<nsISelection> selection;
 523   bool isCollapsed = false;
 524
 525   result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
 526
 527   if (NS_FAILED(result))
 528   {
 529     UNLOCK_DOC(this);
 530     return result;
 531   }
 532
 533   result = selection->GetIsCollapsed(&isCollapsed);
 534
 535   if (NS_FAILED(result))
 536   {
 537     UNLOCK_DOC(this);
 538     return result;
 539   }
 540
 541   nsCOMPtr<nsIContentIterator> iter;
 542   nsCOMPtr<nsIDOMRange>        range;
 543   nsCOMPtr<nsIDOMNode>         parent;
 544   int32_t                      i, rangeCount, offset;
 545
 546   if (isCollapsed)
 547   {
 548     // We have a caret. Check if the caret is in a text node.
 549     // If it is, make the text node's block the current block.
 550     // If the caret isn't in a text node, search forwards in
 551     // the document, till we find a text node.
 552
 553     result = selection->GetRangeAt(0, getter_AddRefs(range));
 554
 555     if (NS_FAILED(result))
 556     {
 557       UNLOCK_DOC(this);
 558       return result;
 559     }
 560
 561     if (!range)
 562     {
 563       UNLOCK_DOC(this);
 564       return NS_ERROR_FAILURE;
 565     }
 566
 567     result = range->GetStartContainer(getter_AddRefs(parent));
 568
 569     if (NS_FAILED(result))
 570     {
 571       UNLOCK_DOC(this);
 572       return result;
 573     }
 574
 575     if (!parent)
 576     {
 577       UNLOCK_DOC(this);
 578       return NS_ERROR_FAILURE;
 579     }
 580
 581     result = range->GetStartOffset(&offset);
 582
 583     if (NS_FAILED(result))
 584     {
 585       UNLOCK_DOC(this);
 586       return result;
 587     }
 588
 589     if (IsTextNode(parent))
 590     {
 591       // The caret is in a text node. Find the beginning
 592       // of the text block containing this text node and
 593       // return.
 594
 595       nsCOMPtr<nsIContent> content(do_QueryInterface(parent));
 596
 597       if (!content)
 598       {
 599         UNLOCK_DOC(this);
 600         return NS_ERROR_FAILURE;
 601       }
 602
 603       result = mIterator->PositionAt(content);
 604
 605       if (NS_FAILED(result))
 606       {
 607         UNLOCK_DOC(this);
 608         return result;
 609       }
 610
 611       result = FirstTextNodeInCurrentBlock(mIterator);
 612
 613       if (NS_FAILED(result))
 614       {
 615         UNLOCK_DOC(this);
 616         return result;
 617       }
 618
 619       mIteratorStatus = nsTextServicesDocument::eValid;
 620
 621       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,
 622                                  mExtent, nullptr);
 623
 624       if (NS_FAILED(result))
 625       {
 626         UNLOCK_DOC(this);
 627         return result;
 628       }
 629
 630       result = GetSelection(aSelStatus, aSelOffset, aSelLength);
 631
 632       if (NS_FAILED(result))
 633       {
 634         UNLOCK_DOC(this);
 635         return result;
 636       }
 637
 638       if (*aSelStatus == nsITextServicesDocument::eBlockContains)
 639         result = SetSelectionInternal(*aSelOffset, *aSelLength, false);
 640     }
 641     else
 642     {
 643       // The caret isn't in a text node. Create an iterator
 644       // based on a range that extends from the current caret
 645       // position to the end of the document, then walk forwards
 646       // till you find a text node, then find the beginning of it's block.
 647
 648       result = CreateDocumentContentRootToNodeOffsetRange(parent, offset, false, getter_AddRefs(range));
 649
 650       if (NS_FAILED(result))
 651       {
 652         UNLOCK_DOC(this);
 653         return result;
 654       }
 655
 656       result = range->GetCollapsed(&isCollapsed);
 657
 658       if (NS_FAILED(result))
 659       {
 660         UNLOCK_DOC(this);
 661         return result;
 662       }
 663
 664       if (isCollapsed)
 665       {
 666         // If we get here, the range is collapsed because there is nothing after
 667         // the caret! Just return NS_OK;
 668
 669         UNLOCK_DOC(this);
 670         return NS_OK;
 671       }
 672
 673       result = CreateContentIterator(range, getter_AddRefs(iter));
 674
 675       if (NS_FAILED(result))
 676       {
 677         UNLOCK_DOC(this);
 678         return result;
 679       }
 680
 681       iter->First();
 682
 683       nsCOMPtr<nsIContent> content;
 684       while (!iter->IsDone())
 685       {
 686         content = do_QueryInterface(iter->GetCurrentNode());
 687
 688         if (IsTextNode(content))
 689           break;
 690
 691         content = nullptr;
 692
 693         iter->Next();
 694       }
 695
 696       if (!content)
 697       {
 698         UNLOCK_DOC(this);
 699         return NS_OK;
 700       }
 701
 702       result = mIterator->PositionAt(content);
 703
 704       if (NS_FAILED(result))
 705       {
 706         UNLOCK_DOC(this);
 707         return result;
 708       }
 709
 710       result = FirstTextNodeInCurrentBlock(mIterator);
 711
 712       if (NS_FAILED(result))
 713       {
 714         UNLOCK_DOC(this);
 715         return result;
 716       }
 717
 718       mIteratorStatus = nsTextServicesDocument::eValid;
 719
 720       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,
 721                                  mExtent, nullptr);
 722
 723       if (NS_FAILED(result))
 724       {
 725         UNLOCK_DOC(this);
 726         return result;
 727       }
 728
 729       result = GetSelection(aSelStatus, aSelOffset, aSelLength);
 730
 731       if (NS_FAILED(result))
 732       {
 733         UNLOCK_DOC(this);
 734         return result;
 735       }
 736     }
 737
 738     UNLOCK_DOC(this);
 739
 740     return result;
 741   }
 742
 743   // If we get here, we have an uncollapsed selection!
 744   // Look backwards through each range in the selection till you
 745   // find the first text node. If you find one, find the
 746   // beginning of its text block, and make it the current
 747   // block.
 748
 749   result = selection->GetRangeCount(&rangeCount);
 750
 751   if (NS_FAILED(result))
 752   {
 753     UNLOCK_DOC(this);
 754     return result;
 755   }
 756
 757   NS_ASSERTION(rangeCount > 0, "Unexpected range count!");
 758
 759   if (rangeCount <= 0)
 760   {
 761     UNLOCK_DOC(this);
 762     return NS_OK;
 763   }
 764
 765   // XXX: We may need to add some code here to make sure
 766   //      the ranges are sorted in document appearance order!
 767
 768   for (i = rangeCount - 1; i >= 0; i--)
 769   {
 770     // Get the i'th range from the selection.
 771
 772     result = selection->GetRangeAt(i, getter_AddRefs(range));
 773
 774     if (NS_FAILED(result))
 775     {
 776       UNLOCK_DOC(this);
 777       return result;
 778     }
 779
 780     // Create an iterator for the range.
 781
 782     result = CreateContentIterator(range, getter_AddRefs(iter));
 783
 784     if (NS_FAILED(result))
 785     {
 786       UNLOCK_DOC(this);
 787       return result;
 788     }
 789
 790     iter->Last();
 791
 792     // Now walk through the range till we find a text node.
 793
 794     while (!iter->IsDone())
 795     {
 796       if (iter->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {
 797         // We found a text node, so position the document's
 798         // iterator at the beginning of the block, then get
 799         // the selection in terms of the string offset.
 800         nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();
 801
 802         result = mIterator->PositionAt(content);
 803
 804         if (NS_FAILED(result))
 805         {
 806           UNLOCK_DOC(this);
 807           return result;
 808         }
 809
 810         result = FirstTextNodeInCurrentBlock(mIterator);
 811
 812         if (NS_FAILED(result))
 813         {
 814           UNLOCK_DOC(this);
 815           return result;
 816         }
 817
 818         mIteratorStatus = nsTextServicesDocument::eValid;
 819
 820         result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,
 821                                    mExtent, nullptr);
 822
 823         if (NS_FAILED(result))
 824         {
 825           UNLOCK_DOC(this);
 826           return result;
 827         }
 828
 829         result = GetSelection(aSelStatus, aSelOffset, aSelLength);
 830
 831         UNLOCK_DOC(this);
 832
 833         return result;
 834
 835       }
 836
 837       iter->Prev();
 838     }
 839   }
 840
 841   // If we get here, we didn't find any text node in the selection!
 842   // Create a range that extends from the end of the selection,
 843   // to the end of the document, then iterate forwards through
 844   // it till you find a text node!
 845
 846   result = selection->GetRangeAt(rangeCount - 1, getter_AddRefs(range));
 847
 848   if (NS_FAILED(result))
 849   {
 850     UNLOCK_DOC(this);
 851     return result;
 852   }
 853
 854   if (!range)
 855   {
 856     UNLOCK_DOC(this);
 857     return NS_ERROR_FAILURE;
 858   }
 859
 860   result = range->GetEndContainer(getter_AddRefs(parent));
 861
 862   if (NS_FAILED(result))
 863   {
 864     UNLOCK_DOC(this);
 865     return result;
 866   }
 867
 868   if (!parent)
 869   {
 870     UNLOCK_DOC(this);
 871     return NS_ERROR_FAILURE;
 872   }
 873
 874   result = range->GetEndOffset(&offset);
 875
 876   if (NS_FAILED(result))
 877   {
 878     UNLOCK_DOC(this);
 879     return result;
 880   }
 881
 882   result = CreateDocumentContentRootToNodeOffsetRange(parent, offset, false, getter_AddRefs(range));
 883
 884   if (NS_FAILED(result))
 885   {
 886     UNLOCK_DOC(this);
 887     return result;
 888   }
 889
 890   result = range->GetCollapsed(&isCollapsed);
 891
 892   if (NS_FAILED(result))
 893   {
 894     UNLOCK_DOC(this);
 895     return result;
 896   }
 897
 898   if (isCollapsed)
 899   {
 900     // If we get here, the range is collapsed because there is nothing after
 901     // the current selection! Just return NS_OK;
 902
 903     UNLOCK_DOC(this);
 904     return NS_OK;
 905   }
 906
 907   result = CreateContentIterator(range, getter_AddRefs(iter));
 908
 909   if (NS_FAILED(result))
 910   {
 911     UNLOCK_DOC(this);
 912     return result;
 913   }
 914
 915   iter->First();
 916
 917   while (!iter->IsDone())
 918   {
 919     if (iter->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {
 920       // We found a text node! Adjust the document's iterator to point
 921       // to the beginning of its text block, then get the current selection.
 922       nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();
 923
 924       result = mIterator->PositionAt(content);
 925
 926       if (NS_FAILED(result))
 927       {
 928         UNLOCK_DOC(this);
 929         return result;
 930       }
 931
 932       result = FirstTextNodeInCurrentBlock(mIterator);
 933
 934       if (NS_FAILED(result))
 935       {
 936         UNLOCK_DOC(this);
 937         return result;
 938       }
 939
 940
 941       mIteratorStatus = nsTextServicesDocument::eValid;
 942
 943       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,
 944                                  mExtent, nullptr);
 945
 946       if (NS_FAILED(result))
 947       {
 948         UNLOCK_DOC(this);
 949         return result;
 950       }
 951
 952       result = GetSelection(aSelStatus, aSelOffset, aSelLength);
 953
 954       UNLOCK_DOC(this);
 955
 956       return result;
 957     }
 958
 959     iter->Next();
 960   }
 961
 962   // If we get here, we didn't find any block before or inside
 963   // the selection! Just return OK.
 964
 965   UNLOCK_DOC(this);
 966
 967   return NS_OK;
 968 }
 969
 970 NS_IMETHODIMP
 971 nsTextServicesDocument::PrevBlock()
 972 {
 973   nsresult result = NS_OK;
 974
 975   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
 976
 977   LOCK_DOC(this);
 978
 979   if (mIteratorStatus == nsTextServicesDocument::eIsDone)
 980     return NS_OK;
 981
 982   switch (mIteratorStatus)
 983   {
 984     case nsTextServicesDocument::eValid:
 985     case nsTextServicesDocument::eNext:
 986
 987       result = FirstTextNodeInPrevBlock(mIterator);
 988
 989       if (NS_FAILED(result))
 990       {
 991         mIteratorStatus = nsTextServicesDocument::eIsDone;
 992         UNLOCK_DOC(this);
 993         return result;
 994       }
 995
 996       if (mIterator->IsDone())
 997       {
 998         mIteratorStatus = nsTextServicesDocument::eIsDone;
 999         UNLOCK_DOC(this);
1000         return NS_OK;
1001       }
1002
1003       mIteratorStatus = nsTextServicesDocument::eValid;
1004       break;
1005
1006     case nsTextServicesDocument::ePrev:
1007
1008       // The iterator already points to the previous
1009       // block, so don't do anything.
1010
1011       mIteratorStatus = nsTextServicesDocument::eValid;
1012       break;
1013
1014     default:
1015
1016       mIteratorStatus = nsTextServicesDocument::eIsDone;
1017       break;
1018   }
1019
1020   // Keep track of prev and next blocks, just in case
1021   // the text service blows away the current block.
1022
1023   if (mIteratorStatus == nsTextServicesDocument::eValid)
1024   {
1025     result = GetFirstTextNodeInPrevBlock(getter_AddRefs(mPrevTextBlock));
1026     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));
1027   }
1028   else
1029   {
1030     // We must be done!
1031
1032     mPrevTextBlock = nullptr;
1033     mNextTextBlock = nullptr;
1034   }
1035
1036   UNLOCK_DOC(this);
1037
1038   return result;
1039 }
1040
1041 NS_IMETHODIMP
1042 nsTextServicesDocument::NextBlock()
1043 {
1044   nsresult result = NS_OK;
1045
1046   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
1047
1048   LOCK_DOC(this);
1049
1050   if (mIteratorStatus == nsTextServicesDocument::eIsDone)
1051     return NS_OK;
1052
1053   switch (mIteratorStatus)
1054   {
1055     case nsTextServicesDocument::eValid:
1056
1057       // Advance the iterator to the next text block.
1058
1059       result = FirstTextNodeInNextBlock(mIterator);
1060
1061       if (NS_FAILED(result))
1062       {
1063         mIteratorStatus = nsTextServicesDocument::eIsDone;
1064         UNLOCK_DOC(this);
1065         return result;
1066       }
1067
1068       if (mIterator->IsDone())
1069       {
1070         mIteratorStatus = nsTextServicesDocument::eIsDone;
1071         UNLOCK_DOC(this);
1072         return NS_OK;
1073       }
1074
1075       mIteratorStatus = nsTextServicesDocument::eValid;
1076       break;
1077
1078     case nsTextServicesDocument::eNext:
1079
1080       // The iterator already points to the next block,
1081       // so don't do anything to it!
1082
1083       mIteratorStatus = nsTextServicesDocument::eValid;
1084       break;
1085
1086     case nsTextServicesDocument::ePrev:
1087
1088       // If the iterator is pointing to the previous block,
1089       // we know that there is no next text block! Just
1090       // fall through to the default case!
1091
1092     default:
1093
1094       mIteratorStatus = nsTextServicesDocument::eIsDone;
1095       break;
1096   }
1097
1098   // Keep track of prev and next blocks, just in case
1099   // the text service blows away the current block.
1100
1101   if (mIteratorStatus == nsTextServicesDocument::eValid)
1102   {
1103     result = GetFirstTextNodeInPrevBlock(getter_AddRefs(mPrevTextBlock));
1104     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));
1105   }
1106   else
1107   {
1108     // We must be done.
1109
1110     mPrevTextBlock = nullptr;
1111     mNextTextBlock = nullptr;
1112   }
1113
1114
1115   UNLOCK_DOC(this);
1116
1117   return result;
1118 }
1119
1120 NS_IMETHODIMP
1121 nsTextServicesDocument::IsDone(bool *aIsDone)
1122 {
1123   NS_ENSURE_TRUE(aIsDone, NS_ERROR_NULL_POINTER);
1124
1125   *aIsDone = false;
1126
1127   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
1128
1129   LOCK_DOC(this);
1130
1131   *aIsDone = (mIteratorStatus == nsTextServicesDocument::eIsDone) ? true : false;
1132
1133   UNLOCK_DOC(this);
1134
1135   return NS_OK;
1136 }
1137
1138 NS_IMETHODIMP
1139 nsTextServicesDocument::SetSelection(int32_t aOffset, int32_t aLength)
1140 {
1141   nsresult result;
1142
1143   NS_ENSURE_TRUE(mSelCon && aOffset >= 0 && aLength >= 0, NS_ERROR_FAILURE);
1144
1145   LOCK_DOC(this);
1146
1147   result = SetSelectionInternal(aOffset, aLength, true);
1148
1149   UNLOCK_DOC(this);
1150
1151   //**** KDEBUG ****
1152   // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1153   //**** KDEBUG ****
1154
1155   return result;
1156 }
1157
1158 NS_IMETHODIMP
1159 nsTextServicesDocument::ScrollSelectionIntoView()
1160 {
1161   nsresult result;
1162
1163   NS_ENSURE_TRUE(mSelCon, NS_ERROR_FAILURE);
1164
1165   LOCK_DOC(this);
1166
1167   // After ScrollSelectionIntoView(), the pending notifications might be flushed
1168   // and PresShell/PresContext/Frames may be dead. See bug 418470.
1169   result = mSelCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION,
1170                                             nsISelectionController::SCROLL_SYNCHRONOUS);
1171
1172   UNLOCK_DOC(this);
1173
1174   return result;
1175 }
1176
1177 NS_IMETHODIMP
1178 nsTextServicesDocument::DeleteSelection()
1179 {
1180   nsresult result = NS_OK;
1181
1182   // We don't allow deletion during a collapsed selection!
1183   nsCOMPtr<nsIEditor> editor (do_QueryReferent(mEditor));
1184   NS_ASSERTION(editor, "DeleteSelection called without an editor present!");
1185   NS_ASSERTION(SelectionIsValid(), "DeleteSelection called without a valid selection!");
1186
1187   if (!editor || !SelectionIsValid())
1188     return NS_ERROR_FAILURE;
1189
1190   if (SelectionIsCollapsed())
1191     return NS_OK;
1192
1193   LOCK_DOC(this);
1194
1195   //**** KDEBUG ****
1196   // printf("\n---- Before Delete\n");
1197   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1198   // PrintOffsetTable();
1199   //**** KDEBUG ****
1200
1201   // If we have an mExtent, save off its current set of
1202   // end points so we can compare them against mExtent's
1203   // set after the deletion of the content.
1204
1205   nsCOMPtr<nsIDOMNode> origStartNode, origEndNode;
1206   int32_t origStartOffset = 0, origEndOffset = 0;
1207
1208   if (mExtent)
1209   {
1210     result = GetRangeEndPoints(mExtent,
1211                                getter_AddRefs(origStartNode), &origStartOffset,
1212                                getter_AddRefs(origEndNode), &origEndOffset);
1213
1214     if (NS_FAILED(result))
1215     {
1216       UNLOCK_DOC(this);
1217       return result;
1218     }
1219   }
1220
1221   int32_t i, selLength;
1222   OffsetEntry *entry, *newEntry;
1223
1224   for (i = mSelStartIndex; i <= mSelEndIndex; i++)
1225   {
1226     entry = mOffsetTable[i];
1227
1228     if (i == mSelStartIndex)
1229     {
1230       // Calculate the length of the selection. Note that the
1231       // selection length can be zero if the start of the selection
1232       // is at the very end of a text node entry.
1233
1234       if (entry->mIsInsertedText)
1235       {
1236         // Inserted text offset entries have no width when
1237         // talking in terms of string offsets! If the beginning
1238         // of the selection is in an inserted text offset entry,
1239         // the caret is always at the end of the entry!
1240
1241         selLength = 0;
1242       }
1243       else
1244         selLength = entry->mLength - (mSelStartOffset - entry->mStrOffset);
1245
1246       if (selLength > 0 && mSelStartOffset > entry->mStrOffset)
1247       {
1248         // Selection doesn't start at the beginning of the
1249         // text node entry. We need to split this entry into
1250         // two pieces, the piece before the selection, and
1251         // the piece inside the selection.
1252
1253         result = SplitOffsetEntry(i, selLength);
1254
1255         if (NS_FAILED(result))
1256         {
1257           UNLOCK_DOC(this);
1258           return result;
1259         }
1260
1261         // Adjust selection indexes to account for new entry:
1262
1263         ++mSelStartIndex;
1264         ++mSelEndIndex;
1265         ++i;
1266
1267         entry = mOffsetTable[i];
1268       }
1269
1270
1271       if (selLength > 0 && mSelStartIndex < mSelEndIndex)
1272       {
1273         // The entire entry is contained in the selection. Mark the
1274         // entry invalid.
1275
1276         entry->mIsValid = false;
1277       }
1278     }
1279
1280   //**** KDEBUG ****
1281   // printf("\n---- Middle Delete\n");
1282   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1283   // PrintOffsetTable();
1284   //**** KDEBUG ****
1285
1286     if (i == mSelEndIndex)
1287     {
1288       if (entry->mIsInsertedText)
1289       {
1290         // Inserted text offset entries have no width when
1291         // talking in terms of string offsets! If the end
1292         // of the selection is in an inserted text offset entry,
1293         // the selection includes the entire entry!
1294
1295         entry->mIsValid = false;
1296       }
1297       else
1298       {
1299         // Calculate the length of the selection. Note that the
1300         // selection length can be zero if the end of the selection
1301         // is at the very beginning of a text node entry.
1302
1303         selLength = mSelEndOffset - entry->mStrOffset;
1304
1305         if (selLength > 0 && mSelEndOffset < entry->mStrOffset + entry->mLength)
1306         {
1307           // mStrOffset is guaranteed to be inside the selection, even
1308           // when mSelStartIndex == mSelEndIndex.
1309
1310           result = SplitOffsetEntry(i, entry->mLength - selLength);
1311
1312           if (NS_FAILED(result))
1313           {
1314             UNLOCK_DOC(this);
1315             return result;
1316           }
1317
1318           // Update the entry fields:
1319
1320           newEntry = mOffsetTable[i+1];
1321           newEntry->mNodeOffset = entry->mNodeOffset;
1322         }
1323
1324
1325         if (selLength > 0 && mSelEndOffset == entry->mStrOffset + entry->mLength)
1326         {
1327           // The entire entry is contained in the selection. Mark the
1328           // entry invalid.
1329
1330           entry->mIsValid = false;
1331         }
1332       }
1333     }
1334
1335     if (i != mSelStartIndex && i != mSelEndIndex)
1336     {
1337       // The entire entry is contained in the selection. Mark the
1338       // entry invalid.
1339
1340       entry->mIsValid = false;
1341     }
1342   }
1343
1344   // Make sure mIterator always points to something valid!
1345
1346   AdjustContentIterator();
1347
1348   // Now delete the actual content!
1349
1350   result = editor->DeleteSelection(nsIEditor::ePrevious, nsIEditor::eStrip);
1351
1352   if (NS_FAILED(result))
1353   {
1354     UNLOCK_DOC(this);
1355     return result;
1356   }
1357
1358   // Now that we've actually deleted the selected content,
1359   // check to see if our mExtent has changed, if so, then
1360   // we have to create a new content iterator!
1361
1362   if (origStartNode && origEndNode)
1363   {
1364     nsCOMPtr<nsIDOMNode> curStartNode, curEndNode;
1365     int32_t curStartOffset = 0, curEndOffset = 0;
1366
1367     result = GetRangeEndPoints(mExtent,
1368                                getter_AddRefs(curStartNode), &curStartOffset,
1369                                getter_AddRefs(curEndNode), &curEndOffset);
1370
1371     if (NS_FAILED(result))
1372     {
1373       UNLOCK_DOC(this);
1374       return result;
1375     }
1376
1377     if (origStartNode != curStartNode || origEndNode != curEndNode)
1378     {
1379       // The range has changed, so we need to create a new content
1380       // iterator based on the new range.
1381
1382       nsCOMPtr<nsIContent> curContent;
1383
1384       if (mIteratorStatus != nsTextServicesDocument::eIsDone) {
1385         // The old iterator is still pointing to something valid,
1386         // so get its current node so we can restore it after we
1387         // create the new iterator!
1388
1389         curContent = mIterator->GetCurrentNode()
1390                      ? mIterator->GetCurrentNode()->AsContent()
1391                      : nullptr;
1392       }
1393
1394       // Create the new iterator.
1395
1396       result = CreateContentIterator(mExtent, getter_AddRefs(mIterator));
1397
1398       if (NS_FAILED(result))
1399       {
1400         UNLOCK_DOC(this);
1401         return result;
1402       }
1403
1404       // Now make the new iterator point to the content node
1405       // the old one was pointing at.
1406
1407       if (curContent)
1408       {
1409         result = mIterator->PositionAt(curContent);
1410
1411         if (NS_FAILED(result))
1412           mIteratorStatus = eIsDone;
1413         else
1414           mIteratorStatus = eValid;
1415       }
1416     }
1417   }
1418
1419   entry = 0;
1420
1421   // Move the caret to the end of the first valid entry.
1422   // Start with mSelStartIndex since it may still be valid.
1423
1424   for (i = mSelStartIndex; !entry && i >= 0; i--)
1425   {
1426     entry = mOffsetTable[i];
1427
1428     if (!entry->mIsValid)
1429       entry = 0;
1430     else
1431     {
1432       mSelStartIndex  = mSelEndIndex  = i;
1433       mSelStartOffset = mSelEndOffset = entry->mStrOffset + entry->mLength;
1434     }
1435   }
1436
1437   // If we still don't have a valid entry, move the caret
1438   // to the next valid entry after the selection:
1439
1440   for (i = mSelEndIndex; !entry && i < int32_t(mOffsetTable.Length()); i++)
1441   {
1442     entry = mOffsetTable[i];
1443
1444     if (!entry->mIsValid)
1445       entry = 0;
1446     else
1447     {
1448       mSelStartIndex = mSelEndIndex = i;
1449       mSelStartOffset = mSelEndOffset = entry->mStrOffset;
1450     }
1451   }
1452
1453   if (entry)
1454     result = SetSelection(mSelStartOffset, 0);
1455   else
1456   {
1457     // Uuughh we have no valid offset entry to place our
1458     // caret ... just mark the selection invalid.
1459
1460     mSelStartIndex  = mSelEndIndex  = -1;
1461     mSelStartOffset = mSelEndOffset = -1;
1462   }
1463
1464   // Now remove any invalid entries from the offset table.
1465
1466   result = RemoveInvalidOffsetEntries();
1467
1468   //**** KDEBUG ****
1469   // printf("\n---- After Delete\n");
1470   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1471   // PrintOffsetTable();
1472   //**** KDEBUG ****
1473
1474   UNLOCK_DOC(this);
1475
1476   return result;
1477 }
1478
1479 NS_IMETHODIMP
1480 nsTextServicesDocument::InsertText(const nsString *aText)
1481 {
1482   nsresult result = NS_OK;
1483
1484   nsCOMPtr<nsIEditor> editor (do_QueryReferent(mEditor));
1485   NS_ASSERTION(editor, "InsertText called without an editor present!");
1486
1487   if (!editor || !SelectionIsValid())
1488     return NS_ERROR_FAILURE;
1489
1490   NS_ENSURE_TRUE(aText, NS_ERROR_NULL_POINTER);
1491
1492   // If the selection is not collapsed, we need to save
1493   // off the selection offsets so we can restore the
1494   // selection and delete the selected content after we've
1495   // inserted the new text. This is necessary to try and
1496   // retain as much of the original style of the content
1497   // being deleted.
1498
1499   bool collapsedSelection = SelectionIsCollapsed();
1500   int32_t savedSelOffset = mSelStartOffset;
1501   int32_t savedSelLength = mSelEndOffset - mSelStartOffset;
1502
1503   if (!collapsedSelection)
1504   {
1505     // Collapse to the start of the current selection
1506     // for the insert!
1507
1508     result = SetSelection(mSelStartOffset, 0);
1509
1510     NS_ENSURE_SUCCESS(result, result);
1511   }
1512
1513
1514   LOCK_DOC(this);
1515
1516   result = editor->BeginTransaction();
1517
1518   if (NS_FAILED(result))
1519   {
1520     UNLOCK_DOC(this);
1521     return result;
1522   }
1523
1524   nsCOMPtr<nsIPlaintextEditor> textEditor (do_QueryInterface(editor, &result));
1525   if (textEditor)
1526     result = textEditor->InsertText(*aText);
1527
1528   if (NS_FAILED(result))
1529   {
1530     editor->EndTransaction();
1531     UNLOCK_DOC(this);
1532     return result;
1533   }
1534
1535   //**** KDEBUG ****
1536   // printf("\n---- Before Insert\n");
1537   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1538   // PrintOffsetTable();
1539   //**** KDEBUG ****
1540
1541   int32_t strLength = aText->Length();
1542   uint32_t i;
1543
1544   nsCOMPtr<nsISelection> selection;
1545   OffsetEntry *itEntry;
1546   OffsetEntry *entry = mOffsetTable[mSelStartIndex];
1547   void *node         = entry->mNode;
1548
1549   NS_ASSERTION((entry->mIsValid), "Invalid insertion point!");
1550
1551   if (entry->mStrOffset == mSelStartOffset)
1552   {
1553     if (entry->mIsInsertedText)
1554     {
1555       // If the caret is in an inserted text offset entry,
1556       // we simply insert the text at the end of the entry.
1557
1558       entry->mLength += strLength;
1559     }
1560     else
1561     {
1562       // Insert an inserted text offset entry before the current
1563       // entry!
1564
1565       itEntry = new OffsetEntry(entry->mNode, entry->mStrOffset, strLength);
1566
1567       if (!itEntry)
1568       {
1569         editor->EndTransaction();
1570         UNLOCK_DOC(this);
1571         return NS_ERROR_OUT_OF_MEMORY;
1572       }
1573
1574       itEntry->mIsInsertedText = true;
1575       itEntry->mNodeOffset = entry->mNodeOffset;
1576
1577       if (!mOffsetTable.InsertElementAt(mSelStartIndex, itEntry))
1578       {
1579         editor->EndTransaction();
1580         UNLOCK_DOC(this);
1581         return NS_ERROR_FAILURE;
1582       }
1583     }
1584   }
1585   else if ((entry->mStrOffset + entry->mLength) == mSelStartOffset)
1586   {
1587     // We are inserting text at the end of the current offset entry.
1588     // Look at the next valid entry in the table. If it's an inserted
1589     // text entry, add to its length and adjust its node offset. If
1590     // it isn't, add a new inserted text entry.
1591
1592     i       = mSelStartIndex + 1;
1593     itEntry = 0;
1594
1595     if (mOffsetTable.Length() > i)
1596     {
1597       itEntry = mOffsetTable[i];
1598
1599       if (!itEntry)
1600       {
1601         editor->EndTransaction();
1602         UNLOCK_DOC(this);
1603         return NS_ERROR_FAILURE;
1604       }
1605
1606       // Check if the entry is a match. If it isn't, set
1607       // iEntry to zero.
1608
1609       if (!itEntry->mIsInsertedText || itEntry->mStrOffset != mSelStartOffset)
1610         itEntry = 0;
1611     }
1612
1613     if (!itEntry)
1614     {
1615       // We didn't find an inserted text offset entry, so
1616       // create one.
1617
1618       itEntry = new OffsetEntry(entry->mNode, mSelStartOffset, 0);
1619
1620       if (!itEntry)
1621       {
1622         editor->EndTransaction();
1623         UNLOCK_DOC(this);
1624         return NS_ERROR_OUT_OF_MEMORY;
1625       }
1626
1627       itEntry->mNodeOffset = entry->mNodeOffset + entry->mLength;
1628       itEntry->mIsInsertedText = true;
1629
1630       if (!mOffsetTable.InsertElementAt(i, itEntry))
1631       {
1632         delete itEntry;
1633         return NS_ERROR_FAILURE;
1634       }
1635     }
1636
1637     // We have a valid inserted text offset entry. Update its
1638     // length, adjust the selection indexes, and make sure the
1639     // caret is properly placed!
1640
1641     itEntry->mLength += strLength;
1642
1643     mSelStartIndex = mSelEndIndex = i;
1644
1645     result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
1646
1647     if (NS_FAILED(result))
1648     {
1649       editor->EndTransaction();
1650       UNLOCK_DOC(this);
1651       return result;
1652     }
1653
1654     result = selection->Collapse(itEntry->mNode, itEntry->mNodeOffset + itEntry->mLength);
1655
1656     if (NS_FAILED(result))
1657     {
1658       editor->EndTransaction();
1659       UNLOCK_DOC(this);
1660       return result;
1661     }
1662   }
1663   else if ((entry->mStrOffset + entry->mLength) > mSelStartOffset)
1664   {
1665     // We are inserting text into the middle of the current offset entry.
1666     // split the current entry into two parts, then insert an inserted text
1667     // entry between them!
1668
1669     i = entry->mLength - (mSelStartOffset - entry->mStrOffset);
1670
1671     result = SplitOffsetEntry(mSelStartIndex, i);
1672
1673     if (NS_FAILED(result))
1674     {
1675       editor->EndTransaction();
1676       UNLOCK_DOC(this);
1677       return result;
1678     }
1679
1680     itEntry = new OffsetEntry(entry->mNode, mSelStartOffset, strLength);
1681
1682     if (!itEntry)
1683     {
1684       editor->EndTransaction();
1685       UNLOCK_DOC(this);
1686       return NS_ERROR_OUT_OF_MEMORY;
1687     }
1688
1689     itEntry->mIsInsertedText = true;
1690     itEntry->mNodeOffset     = entry->mNodeOffset + entry->mLength;
1691
1692     if (!mOffsetTable.InsertElementAt(mSelStartIndex + 1, itEntry))
1693     {
1694       editor->EndTransaction();
1695       UNLOCK_DOC(this);
1696       return NS_ERROR_FAILURE;
1697     }
1698
1699     mSelEndIndex = ++mSelStartIndex;
1700   }
1701
1702   // We've just finished inserting an inserted text offset entry.
1703   // update all entries with the same mNode pointer that follow
1704   // it in the table!
1705
1706   for (i = mSelStartIndex + 1; i < mOffsetTable.Length(); i++)
1707   {
1708     entry = mOffsetTable[i];
1709
1710     if (entry->mNode == node)
1711     {
1712       if (entry->mIsValid)
1713         entry->mNodeOffset += strLength;
1714     }
1715     else
1716       break;
1717   }
1718
1719   //**** KDEBUG ****
1720   // printf("\n---- After Insert\n");
1721   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
1722   // PrintOffsetTable();
1723   //**** KDEBUG ****
1724
1725   if (!collapsedSelection)
1726   {
1727     result = SetSelection(savedSelOffset, savedSelLength);
1728
1729     if (NS_FAILED(result))
1730     {
1731       editor->EndTransaction();
1732       UNLOCK_DOC(this);
1733       return result;
1734     }
1735
1736     result = DeleteSelection();
1737
1738     if (NS_FAILED(result))
1739     {
1740       editor->EndTransaction();
1741       UNLOCK_DOC(this);
1742       return result;
1743     }
1744   }
1745
1746   result = editor->EndTransaction();
1747
1748   UNLOCK_DOC(this);
1749
1750   return result;
1751 }
1752
1753 NS_IMETHODIMP
1754 nsTextServicesDocument::DidInsertNode(nsIDOMNode *aNode,
1755                                       nsIDOMNode *aParent,
1756                                       int32_t     aPosition,
1757                                       nsresult    aResult)
1758 {
1759   return NS_OK;
1760 }
1761
1762 NS_IMETHODIMP
1763 nsTextServicesDocument::DidDeleteNode(nsIDOMNode *aChild, nsresult aResult)
1764 {
1765   NS_ENSURE_SUCCESS(aResult, NS_OK);
1766
1767   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
1768
1769   //**** KDEBUG ****
1770   // printf("** DeleteNode: 0x%.8x\n", aChild);
1771   // fflush(stdout);
1772   //**** KDEBUG ****
1773
1774   LOCK_DOC(this);
1775
1776   int32_t nodeIndex = 0;
1777   bool hasEntry = false;
1778   OffsetEntry *entry;
1779
1780   nsresult result = NodeHasOffsetEntry(&mOffsetTable, aChild, &hasEntry, &nodeIndex);
1781
1782   if (NS_FAILED(result))
1783   {
1784     UNLOCK_DOC(this);
1785     return result;
1786   }
1787
1788   if (!hasEntry)
1789   {
1790     // It's okay if the node isn't in the offset table, the
1791     // editor could be cleaning house.
1792
1793     UNLOCK_DOC(this);
1794     return NS_OK;
1795   }
1796
1797   nsCOMPtr<nsIDOMNode> node = do_QueryInterface(mIterator->GetCurrentNode());
1798
1799   if (node && node == aChild &&
1800       mIteratorStatus != nsTextServicesDocument::eIsDone)
1801   {
1802     // XXX: This should never really happen because
1803     // AdjustContentIterator() should have been called prior
1804     // to the delete to try and position the iterator on the
1805     // next valid text node in the offset table, and if there
1806     // wasn't a next, it would've set mIteratorStatus to eIsDone.
1807
1808     NS_ERROR("DeleteNode called for current iterator node.");
1809   }
1810
1811   int32_t tcount = mOffsetTable.Length();
1812
1813   while (nodeIndex < tcount)
1814   {
1815     entry = mOffsetTable[nodeIndex];
1816
1817     if (!entry)
1818     {
1819       UNLOCK_DOC(this);
1820       return NS_ERROR_FAILURE;
1821     }
1822
1823     if (entry->mNode == aChild)
1824     {
1825       entry->mIsValid = false;
1826     }
1827
1828     nodeIndex++;
1829   }
1830
1831   UNLOCK_DOC(this);
1832
1833   return NS_OK;
1834 }
1835
1836 NS_IMETHODIMP
1837 nsTextServicesDocument::DidSplitNode(nsIDOMNode *aExistingRightNode,
1838                                      int32_t     aOffset,
1839                                      nsIDOMNode *aNewLeftNode,
1840                                      nsresult    aResult)
1841 {
1842   //**** KDEBUG ****
1843   // printf("** SplitNode: 0x%.8x  %d  0x%.8x\n", aExistingRightNode, aOffset, aNewLeftNode);
1844   // fflush(stdout);
1845   //**** KDEBUG ****
1846   return NS_OK;
1847 }
1848
1849 NS_IMETHODIMP
1850 nsTextServicesDocument::DidJoinNodes(nsIDOMNode  *aLeftNode,
1851                                      nsIDOMNode  *aRightNode,
1852                                      nsIDOMNode  *aParent,
1853                                      nsresult     aResult)
1854 {
1855   NS_ENSURE_SUCCESS(aResult, NS_OK);
1856
1857   int32_t i;
1858   uint16_t type;
1859   nsresult result;
1860
1861   //**** KDEBUG ****
1862   // printf("** JoinNodes: 0x%.8x  0x%.8x  0x%.8x\n", aLeftNode, aRightNode, aParent);
1863   // fflush(stdout);
1864   //**** KDEBUG ****
1865
1866   // Make sure that both nodes are text nodes -- otherwise we don't care.
1867
1868   result = aLeftNode->GetNodeType(&type);
1869   NS_ENSURE_SUCCESS(result, NS_OK);
1870   if (nsIDOMNode::TEXT_NODE != type) {
1871     return NS_OK;
1872   }
1873
1874   result = aRightNode->GetNodeType(&type);
1875   NS_ENSURE_SUCCESS(result, NS_OK);
1876   if (nsIDOMNode::TEXT_NODE != type) {
1877     return NS_OK;
1878   }
1879
1880   // Note: The editor merges the contents of the left node into the
1881   //       contents of the right.
1882
1883   int32_t leftIndex = 0;
1884   int32_t rightIndex = 0;
1885   bool leftHasEntry = false;
1886   bool rightHasEntry = false;
1887
1888   result = NodeHasOffsetEntry(&mOffsetTable, aLeftNode, &leftHasEntry, &leftIndex);
1889
1890   NS_ENSURE_SUCCESS(result, result);
1891
1892   if (!leftHasEntry)
1893   {
1894     // It's okay if the node isn't in the offset table, the
1895     // editor could be cleaning house.
1896     return NS_OK;
1897   }
1898
1899   result = NodeHasOffsetEntry(&mOffsetTable, aRightNode, &rightHasEntry, &rightIndex);
1900
1901   NS_ENSURE_SUCCESS(result, result);
1902
1903   if (!rightHasEntry)
1904   {
1905     // It's okay if the node isn't in the offset table, the
1906     // editor could be cleaning house.
1907     return NS_OK;
1908   }
1909
1910   NS_ASSERTION(leftIndex < rightIndex, "Indexes out of order.");
1911
1912   if (leftIndex > rightIndex)
1913   {
1914     // Don't know how to handle this situation.
1915     return NS_ERROR_FAILURE;
1916   }
1917
1918   LOCK_DOC(this);
1919
1920   OffsetEntry *entry = mOffsetTable[rightIndex];
1921   NS_ASSERTION(entry->mNodeOffset == 0, "Unexpected offset value for rightIndex.");
1922
1923   // Run through the table and change all entries referring to
1924   // the left node so that they now refer to the right node:
1925
1926   nsAutoString str;
1927   result = aLeftNode->GetNodeValue(str);
1928   int32_t nodeLength = str.Length();
1929
1930   for (i = leftIndex; i < rightIndex; i++)
1931   {
1932     entry = mOffsetTable[i];
1933
1934     if (entry->mNode == aLeftNode)
1935     {
1936       if (entry->mIsValid)
1937         entry->mNode = aRightNode;
1938     }
1939     else
1940       break;
1941   }
1942
1943   // Run through the table and adjust the node offsets
1944   // for all entries referring to the right node.
1945
1946   for (i = rightIndex; i < int32_t(mOffsetTable.Length()); i++)
1947   {
1948     entry = mOffsetTable[i];
1949
1950     if (entry->mNode == aRightNode)
1951     {
1952       if (entry->mIsValid)
1953         entry->mNodeOffset += nodeLength;
1954     }
1955     else
1956       break;
1957   }
1958
1959   // Now check to see if the iterator is pointing to the
1960   // left node. If it is, make it point to the right node!
1961
1962   nsCOMPtr<nsIContent> leftContent = do_QueryInterface(aLeftNode);
1963   nsCOMPtr<nsIContent> rightContent = do_QueryInterface(aRightNode);
1964
1965   if (!leftContent || !rightContent)
1966   {
1967     UNLOCK_DOC(this);
1968     return NS_ERROR_FAILURE;
1969   }
1970
1971   if (mIterator->GetCurrentNode() == leftContent)
1972     result = mIterator->PositionAt(rightContent);
1973
1974   UNLOCK_DOC(this);
1975
1976   return NS_OK;
1977 }
1978
1979 nsresult
1980 nsTextServicesDocument::CreateContentIterator(nsIDOMRange *aRange, nsIContentIterator **aIterator)
1981 {
1982   NS_ENSURE_TRUE(aRange && aIterator, NS_ERROR_NULL_POINTER);
1983
1984   *aIterator = nullptr;
1985
1986   // Create a nsFilteredContentIterator
1987   // This class wraps the ContentIterator in order to give itself a chance
1988   // to filter out certain content nodes
1989   nsRefPtr<nsFilteredContentIterator> filter = new nsFilteredContentIterator(mTxtSvcFilter);
1990
1991   nsresult result = filter->Init(aRange);
1992   if (NS_FAILED(result)) {
1993     return result;
1994   }
1995
1996   filter.forget(aIterator);
1997   return NS_OK;
1998 }
1999
2000 nsresult
2001 nsTextServicesDocument::GetDocumentContentRootNode(nsIDOMNode **aNode)
2002 {
2003   nsresult result;
2004
2005   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
2006
2007   *aNode = 0;
2008
2009   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_FAILURE);
2010
2011   nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(mDOMDocument);
2012
2013   if (htmlDoc)
2014   {
2015     // For HTML documents, the content root node is the body.
2016
2017     nsCOMPtr<nsIDOMHTMLElement> bodyElement;
2018
2019     result = htmlDoc->GetBody(getter_AddRefs(bodyElement));
2020
2021     NS_ENSURE_SUCCESS(result, result);
2022
2023     NS_ENSURE_TRUE(bodyElement, NS_ERROR_FAILURE);
2024
2025     result = bodyElement->QueryInterface(NS_GET_IID(nsIDOMNode), (void **)aNode);
2026   }
2027   else
2028   {
2029     // For non-HTML documents, the content root node will be the document element.
2030
2031     nsCOMPtr<nsIDOMElement> docElement;
2032
2033     result = mDOMDocument->GetDocumentElement(getter_AddRefs(docElement));
2034
2035     NS_ENSURE_SUCCESS(result, result);
2036
2037     NS_ENSURE_TRUE(docElement, NS_ERROR_FAILURE);
2038
2039     result = docElement->QueryInterface(NS_GET_IID(nsIDOMNode), (void **)aNode);
2040   }
2041
2042   return result;
2043 }
2044
2045 nsresult
2046 nsTextServicesDocument::CreateDocumentContentRange(nsIDOMRange **aRange)
2047 {
2048   *aRange = nullptr;
2049
2050   nsCOMPtr<nsIDOMNode> node;
2051   nsresult rv = GetDocumentContentRootNode(getter_AddRefs(node));
2052   NS_ENSURE_SUCCESS(rv, rv);
2053   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
2054
2055   nsCOMPtr<nsINode> nativeNode = do_QueryInterface(node);
2056   NS_ENSURE_STATE(nativeNode);
2057
2058   nsRefPtr<nsRange> range = new nsRange(nativeNode);
2059
2060   rv = range->SelectNodeContents(node);
2061   NS_ENSURE_SUCCESS(rv, rv);
2062
2063   range.forget(aRange);
2064   return NS_OK;
2065 }
2066
2067 nsresult
2068 nsTextServicesDocument::CreateDocumentContentRootToNodeOffsetRange(nsIDOMNode *aParent, int32_t aOffset, bool aToStart, nsIDOMRange **aRange)
2069 {
2070   NS_ENSURE_TRUE(aParent && aRange, NS_ERROR_NULL_POINTER);
2071
2072   *aRange = 0;
2073
2074   NS_ASSERTION(aOffset >= 0, "Invalid offset!");
2075
2076   if (aOffset < 0)
2077     return NS_ERROR_FAILURE;
2078
2079   nsCOMPtr<nsIDOMNode> bodyNode;
2080   nsresult rv = GetDocumentContentRootNode(getter_AddRefs(bodyNode));
2081   NS_ENSURE_SUCCESS(rv, rv);
2082   NS_ENSURE_TRUE(bodyNode, NS_ERROR_NULL_POINTER);
2083
2084   nsCOMPtr<nsIDOMNode> startNode;
2085   nsCOMPtr<nsIDOMNode> endNode;
2086   int32_t startOffset, endOffset;
2087
2088   if (aToStart) {
2089     // The range should begin at the start of the document
2090     // and extend up until (aParent, aOffset).
2091
2092     startNode   = bodyNode;
2093     startOffset = 0;
2094     endNode     = aParent;
2095     endOffset   = aOffset;
2096   } else {
2097     // The range should begin at (aParent, aOffset) and
2098     // extend to the end of the document.
2099
2100     startNode   = aParent;
2101     startOffset = aOffset;
2102     endNode     = bodyNode;
2103
2104     nsCOMPtr<nsINode> body = do_QueryInterface(bodyNode);
2105     endOffset = body ? int32_t(body->GetChildCount()) : 0;
2106   }
2107
2108   return nsRange::CreateRange(startNode, startOffset, endNode, endOffset,
2109                               aRange);
2110 }
2111
2112 nsresult
2113 nsTextServicesDocument::CreateDocumentContentIterator(nsIContentIterator **aIterator)
2114 {
2115   nsresult result;
2116
2117   NS_ENSURE_TRUE(aIterator, NS_ERROR_NULL_POINTER);
2118
2119   nsCOMPtr<nsIDOMRange> range;
2120
2121   result = CreateDocumentContentRange(getter_AddRefs(range));
2122
2123   NS_ENSURE_SUCCESS(result, result);
2124
2125   result = CreateContentIterator(range, aIterator);
2126
2127   return result;
2128 }
2129
2130 nsresult
2131 nsTextServicesDocument::AdjustContentIterator()
2132 {
2133   nsresult result = NS_OK;
2134
2135   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);
2136
2137   nsCOMPtr<nsIDOMNode> node(do_QueryInterface(mIterator->GetCurrentNode()));
2138
2139   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
2140
2141   nsIDOMNode *nodePtr = node.get();
2142   int32_t tcount      = mOffsetTable.Length();
2143
2144   nsIDOMNode *prevValidNode = 0;
2145   nsIDOMNode *nextValidNode = 0;
2146   bool foundEntry = false;
2147   OffsetEntry *entry;
2148
2149   for (int32_t i = 0; i < tcount && !nextValidNode; i++)
2150   {
2151     entry = mOffsetTable[i];
2152
2153     NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
2154
2155     if (entry->mNode == nodePtr)
2156     {
2157       if (entry->mIsValid)
2158       {
2159         // The iterator is still pointing to something valid!
2160         // Do nothing!
2161
2162         return NS_OK;
2163       }
2164       else
2165       {
2166         // We found an invalid entry that points to
2167         // the current iterator node. Stop looking for
2168         // a previous valid node!
2169
2170         foundEntry = true;
2171       }
2172     }
2173
2174     if (entry->mIsValid)
2175     {
2176       if (!foundEntry)
2177         prevValidNode = entry->mNode;
2178       else
2179         nextValidNode = entry->mNode;
2180     }
2181   }
2182
2183   nsCOMPtr<nsIContent> content;
2184
2185   if (prevValidNode)
2186     content = do_QueryInterface(prevValidNode);
2187   else if (nextValidNode)
2188     content = do_QueryInterface(nextValidNode);
2189
2190   if (content)
2191   {
2192     result = mIterator->PositionAt(content);
2193
2194     if (NS_FAILED(result))
2195       mIteratorStatus = eIsDone;
2196     else
2197       mIteratorStatus = eValid;
2198
2199     return result;
2200   }
2201
2202   // If we get here, there aren't any valid entries
2203   // in the offset table! Try to position the iterator
2204   // on the next text block first, then previous if
2205   // one doesn't exist!
2206
2207   if (mNextTextBlock)
2208   {
2209     result = mIterator->PositionAt(mNextTextBlock);
2210
2211     if (NS_FAILED(result))
2212     {
2213       mIteratorStatus = eIsDone;
2214       return result;
2215     }
2216
2217     mIteratorStatus = eNext;
2218   }
2219   else if (mPrevTextBlock)
2220   {
2221     result = mIterator->PositionAt(mPrevTextBlock);
2222
2223     if (NS_FAILED(result))
2224     {
2225       mIteratorStatus = eIsDone;
2226       return result;
2227     }
2228
2229     mIteratorStatus = ePrev;
2230   }
2231   else
2232     mIteratorStatus = eIsDone;
2233
2234   return NS_OK;
2235 }
2236
2237 bool
2238 nsTextServicesDocument::DidSkip(nsIContentIterator* aFilteredIter)
2239 {
2240   // We can assume here that the Iterator is a nsFilteredContentIterator because
2241   // all the iterator are created in CreateContentIterator which create a
2242   // nsFilteredContentIterator
2243   // So if the iterator bailed on one of the "filtered" content nodes then we
2244   // consider that to be a block and bail with true
2245   if (aFilteredIter) {
2246     nsFilteredContentIterator* filter = static_cast<nsFilteredContentIterator *>(aFilteredIter);
2247     if (filter && filter->DidSkip()) {
2248       return true;
2249     }
2250   }
2251   return false;
2252 }
2253
2254 void
2255 nsTextServicesDocument::ClearDidSkip(nsIContentIterator* aFilteredIter)
2256 {
2257   // Clear filter's skip flag
2258   if (aFilteredIter) {
2259     nsFilteredContentIterator* filter = static_cast<nsFilteredContentIterator *>(aFilteredIter);
2260     filter->ClearDidSkip();
2261   }
2262 }
2263
2264 bool
2265 nsTextServicesDocument::IsBlockNode(nsIContent *aContent)
2266 {
2267   if (!aContent) {
2268     NS_ERROR("How did a null pointer get passed to IsBlockNode?");
2269     return false;
2270   }
2271
2272   nsIAtom *atom = aContent->Tag();
2273
2274   return (sAAtom       != atom &&
2275           sAddressAtom != atom &&
2276           sBigAtom     != atom &&
2277           sBAtom       != atom &&
2278           sCiteAtom    != atom &&
2279           sCodeAtom    != atom &&
2280           sDfnAtom     != atom &&
2281           sEmAtom      != atom &&
2282           sFontAtom    != atom &&
2283           sIAtom       != atom &&
2284           sKbdAtom     != atom &&
2285           sKeygenAtom  != atom &&
2286           sNobrAtom    != atom &&
2287           sSAtom       != atom &&
2288           sSampAtom    != atom &&
2289           sSmallAtom   != atom &&
2290           sSpacerAtom  != atom &&
2291           sSpanAtom    != atom &&
2292           sStrikeAtom  != atom &&
2293           sStrongAtom  != atom &&
2294           sSubAtom     != atom &&
2295           sSupAtom     != atom &&
2296           sTtAtom      != atom &&
2297           sUAtom       != atom &&
2298           sVarAtom     != atom &&
2299           sWbrAtom     != atom);
2300 }
2301
2302 bool
2303 nsTextServicesDocument::HasSameBlockNodeParent(nsIContent *aContent1, nsIContent *aContent2)
2304 {
2305   nsIContent* p1 = aContent1->GetParent();
2306   nsIContent* p2 = aContent2->GetParent();
2307
2308   // Quick test:
2309
2310   if (p1 == p2)
2311     return true;
2312
2313   // Walk up the parent hierarchy looking for closest block boundary node:
2314
2315   while (p1 && !IsBlockNode(p1))
2316   {
2317     p1 = p1->GetParent();
2318   }
2319
2320   while (p2 && !IsBlockNode(p2))
2321   {
2322     p2 = p2->GetParent();
2323   }
2324
2325   return p1 == p2;
2326 }
2327
2328 bool
2329 nsTextServicesDocument::IsTextNode(nsIContent *aContent)
2330 {
2331   NS_ENSURE_TRUE(aContent, false);
2332   return nsIDOMNode::TEXT_NODE == aContent->NodeType();
2333 }
2334
2335 bool
2336 nsTextServicesDocument::IsTextNode(nsIDOMNode *aNode)
2337 {
2338   NS_ENSURE_TRUE(aNode, false);
2339
2340   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
2341   return IsTextNode(content);
2342 }
2343
2344 nsresult
2345 nsTextServicesDocument::SetSelectionInternal(int32_t aOffset, int32_t aLength, bool aDoUpdate)
2346 {
2347   nsresult result = NS_OK;
2348
2349   NS_ENSURE_TRUE(mSelCon && aOffset >= 0 && aLength >= 0, NS_ERROR_FAILURE);
2350
2351   nsIDOMNode *sNode = 0, *eNode = 0;
2352   int32_t i, sOffset = 0, eOffset = 0;
2353   OffsetEntry *entry;
2354
2355   // Find start of selection in node offset terms:
2356
2357   for (i = 0; !sNode && i < int32_t(mOffsetTable.Length()); i++)
2358   {
2359     entry = mOffsetTable[i];
2360     if (entry->mIsValid)
2361     {
2362       if (entry->mIsInsertedText)
2363       {
2364         // Caret can only be placed at the end of an
2365         // inserted text offset entry, if the offsets
2366         // match exactly!
2367
2368         if (entry->mStrOffset == aOffset)
2369         {
2370           sNode   = entry->mNode;
2371           sOffset = entry->mNodeOffset + entry->mLength;
2372         }
2373       }
2374       else if (aOffset >= entry->mStrOffset)
2375       {
2376         bool foundEntry = false;
2377         int32_t strEndOffset = entry->mStrOffset + entry->mLength;
2378
2379         if (aOffset < strEndOffset)
2380           foundEntry = true;
2381         else if (aOffset == strEndOffset)
2382         {
2383           // Peek after this entry to see if we have any
2384           // inserted text entries belonging to the same
2385           // entry->mNode. If so, we have to place the selection
2386           // after it!
2387
2388           if ((i+1) < int32_t(mOffsetTable.Length()))
2389           {
2390             OffsetEntry *nextEntry = mOffsetTable[i+1];
2391
2392             if (!nextEntry->mIsValid || nextEntry->mStrOffset != aOffset)
2393             {
2394               // Next offset entry isn't an exact match, so we'll
2395               // just use the current entry.
2396               foundEntry = true;
2397             }
2398           }
2399         }
2400
2401         if (foundEntry)
2402         {
2403           sNode   = entry->mNode;
2404           sOffset = entry->mNodeOffset + aOffset - entry->mStrOffset;
2405         }
2406       }
2407
2408       if (sNode)
2409       {
2410         mSelStartIndex  = i;
2411         mSelStartOffset = aOffset;
2412       }
2413     }
2414   }
2415
2416   NS_ENSURE_TRUE(sNode, NS_ERROR_FAILURE);
2417
2418   // XXX: If we ever get a SetSelection() method in nsIEditor, we should
2419   //      use it.
2420
2421   nsCOMPtr<nsISelection> selection;
2422
2423   if (aDoUpdate)
2424   {
2425     result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
2426
2427     NS_ENSURE_SUCCESS(result, result);
2428
2429     result = selection->Collapse(sNode, sOffset);
2430
2431     NS_ENSURE_SUCCESS(result, result);
2432    }
2433
2434   if (aLength <= 0)
2435   {
2436     // We have a collapsed selection. (Caret)
2437
2438     mSelEndIndex  = mSelStartIndex;
2439     mSelEndOffset = mSelStartOffset;
2440
2441    //**** KDEBUG ****
2442    // printf("\n* Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
2443    //**** KDEBUG ****
2444
2445     return NS_OK;
2446   }
2447
2448   // Find the end of the selection in node offset terms:
2449
2450   int32_t endOffset = aOffset + aLength;
2451
2452   for (i = mOffsetTable.Length() - 1; !eNode && i >= 0; i--)
2453   {
2454     entry = mOffsetTable[i];
2455
2456     if (entry->mIsValid)
2457     {
2458       if (entry->mIsInsertedText)
2459       {
2460         if (entry->mStrOffset == eOffset)
2461         {
2462           // If the selection ends on an inserted text offset entry,
2463           // the selection includes the entire entry!
2464
2465           eNode   = entry->mNode;
2466           eOffset = entry->mNodeOffset + entry->mLength;
2467         }
2468       }
2469       else if (endOffset >= entry->mStrOffset && endOffset <= entry->mStrOffset + entry->mLength)
2470       {
2471         eNode   = entry->mNode;
2472         eOffset = entry->mNodeOffset + endOffset - entry->mStrOffset;
2473       }
2474
2475       if (eNode)
2476       {
2477         mSelEndIndex  = i;
2478         mSelEndOffset = endOffset;
2479       }
2480     }
2481   }
2482
2483   if (aDoUpdate && eNode)
2484   {
2485     result = selection->Extend(eNode, eOffset);
2486
2487     NS_ENSURE_SUCCESS(result, result);
2488   }
2489
2490   //**** KDEBUG ****
2491   // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
2492   //**** KDEBUG ****
2493
2494   return result;
2495 }
2496
2497 nsresult
2498 nsTextServicesDocument::GetSelection(nsITextServicesDocument::TSDBlockSelectionStatus *aSelStatus, int32_t *aSelOffset, int32_t *aSelLength)
2499 {
2500   nsresult result;
2501
2502   NS_ENSURE_TRUE(aSelStatus && aSelOffset && aSelLength, NS_ERROR_NULL_POINTER);
2503
2504   *aSelStatus = nsITextServicesDocument::eBlockNotFound;
2505   *aSelOffset = -1;
2506   *aSelLength = -1;
2507
2508   NS_ENSURE_TRUE(mDOMDocument && mSelCon, NS_ERROR_FAILURE);
2509
2510   if (mIteratorStatus == nsTextServicesDocument::eIsDone)
2511     return NS_OK;
2512
2513   nsCOMPtr<nsISelection> selection;
2514   bool isCollapsed;
2515
2516   result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
2517
2518   NS_ENSURE_SUCCESS(result, result);
2519
2520   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
2521
2522   result = selection->GetIsCollapsed(&isCollapsed);
2523
2524   NS_ENSURE_SUCCESS(result, result);
2525
2526   // XXX: If we expose this method publicly, we need to
2527   //      add LOCK_DOC/UNLOCK_DOC calls!
2528
2529   // LOCK_DOC(this);
2530
2531   if (isCollapsed)
2532     result = GetCollapsedSelection(aSelStatus, aSelOffset, aSelLength);
2533   else
2534     result = GetUncollapsedSelection(aSelStatus, aSelOffset, aSelLength);
2535
2536   // UNLOCK_DOC(this);
2537
2538   return result;
2539 }
2540
2541 nsresult
2542 nsTextServicesDocument::GetCollapsedSelection(nsITextServicesDocument::TSDBlockSelectionStatus *aSelStatus, int32_t *aSelOffset, int32_t *aSelLength)
2543 {
2544   nsCOMPtr<nsISelection> selection;
2545   nsresult result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
2546   NS_ENSURE_SUCCESS(result, result);
2547   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
2548
2549   // The calling function should have done the GetIsCollapsed()
2550   // check already. Just assume it's collapsed!
2551   *aSelStatus = nsITextServicesDocument::eBlockOutside;
2552   *aSelOffset = *aSelLength = -1;
2553
2554   int32_t tableCount = mOffsetTable.Length();
2555
2556   if (tableCount == 0)
2557     return NS_OK;
2558
2559   // Get pointers to the first and last offset entries
2560   // in the table.
2561
2562   OffsetEntry* eStart = mOffsetTable[0];
2563   OffsetEntry* eEnd;
2564   if (tableCount > 1)
2565     eEnd = mOffsetTable[tableCount - 1];
2566   else
2567     eEnd = eStart;
2568
2569   int32_t eStartOffset = eStart->mNodeOffset;
2570   int32_t eEndOffset   = eEnd->mNodeOffset + eEnd->mLength;
2571
2572   nsCOMPtr<nsIDOMRange> range;
2573   result = selection->GetRangeAt(0, getter_AddRefs(range));
2574   NS_ENSURE_SUCCESS(result, result);
2575
2576   nsCOMPtr<nsIDOMNode> domParent;
2577   result = range->GetStartContainer(getter_AddRefs(domParent));
2578   NS_ENSURE_SUCCESS(result, result);
2579
2580   nsCOMPtr<nsINode> parent = do_QueryInterface(domParent);
2581   MOZ_ASSERT(parent);
2582
2583   int32_t offset;
2584   result = range->GetStartOffset(&offset);
2585   NS_ENSURE_SUCCESS(result, result);
2586
2587   int32_t e1s1 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
2588                                                domParent, offset);
2589   int32_t e2s1 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
2590                                                domParent, offset);
2591
2592   if (e1s1 > 0 || e2s1 < 0) {
2593     // We're done if the caret is outside the current text block.
2594     return NS_OK;
2595   }
2596
2597   if (parent->NodeType() == nsIDOMNode::TEXT_NODE) {
2598     // Good news, the caret is in a text node. Look
2599     // through the offset table for the entry that
2600     // matches its parent and offset.
2601
2602     for (int32_t i = 0; i < tableCount; i++) {
2603       OffsetEntry* entry = mOffsetTable[i];
2604       NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
2605
2606       if (entry->mNode == domParent.get() &&
2607           entry->mNodeOffset <= offset && offset <= (entry->mNodeOffset + entry->mLength))
2608       {
2609         *aSelStatus = nsITextServicesDocument::eBlockContains;
2610         *aSelOffset = entry->mStrOffset + (offset - entry->mNodeOffset);
2611         *aSelLength = 0;
2612
2613         return NS_OK;
2614       }
2615     }
2616
2617     // If we get here, we didn't find a text node entry
2618     // in our offset table that matched.
2619
2620     return NS_ERROR_FAILURE;
2621   }
2622
2623   // The caret is in our text block, but it's positioned in some
2624   // non-text node (ex. <b>). Create a range based on the start
2625   // and end of the text block, then create an iterator based on
2626   // this range, with its initial position set to the closest
2627   // child of this non-text node. Then look for the closest text
2628   // node.
2629
2630   result = CreateRange(eStart->mNode, eStartOffset, eEnd->mNode, eEndOffset, getter_AddRefs(range));
2631   NS_ENSURE_SUCCESS(result, result);
2632
2633   nsCOMPtr<nsIContentIterator> iter;
2634   result = CreateContentIterator(range, getter_AddRefs(iter));
2635   NS_ENSURE_SUCCESS(result, result);
2636
2637   nsIContent* saveNode;
2638   if (parent->HasChildren()) {
2639     // XXX: We need to make sure that all of parent's
2640     //      children are in the text block.
2641
2642     // If the parent has children, position the iterator
2643     // on the child that is to the left of the offset.
2644
2645     uint32_t childIndex = (uint32_t)offset;
2646
2647     if (childIndex > 0) {
2648       uint32_t numChildren = parent->GetChildCount();
2649       NS_ASSERTION(childIndex <= numChildren, "Invalid selection offset!");
2650
2651       if (childIndex > numChildren) {
2652         childIndex = numChildren;
2653       }
2654
2655       childIndex -= 1;
2656     }
2657
2658     nsIContent* content = parent->GetChildAt(childIndex);
2659     NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
2660
2661     result = iter->PositionAt(content);
2662     NS_ENSURE_SUCCESS(result, result);
2663
2664     saveNode = content;
2665   } else {
2666     // The parent has no children, so position the iterator
2667     // on the parent.
2668     NS_ENSURE_TRUE(parent->IsContent(), NS_ERROR_FAILURE);
2669     nsCOMPtr<nsIContent> content = parent->AsContent();
2670
2671     result = iter->PositionAt(content);
2672     NS_ENSURE_SUCCESS(result, result);
2673
2674     saveNode = content;
2675   }
2676
2677   // Now iterate to the left, towards the beginning of
2678   // the text block, to find the first text node you
2679   // come across.
2680
2681   nsIContent* node = nullptr;
2682   while (!iter->IsDone()) {
2683     nsINode* current = iter->GetCurrentNode();
2684     if (current->NodeType() == nsIDOMNode::TEXT_NODE) {
2685       node = static_cast<nsIContent*>(current);
2686       break;
2687     }
2688
2689     iter->Prev();
2690   }
2691
2692   if (node) {
2693     // We found a node, now set the offset to the end
2694     // of the text node.
2695     offset = node->TextLength();
2696   } else {
2697     // We should never really get here, but I'm paranoid.
2698
2699     // We didn't find a text node above, so iterate to
2700     // the right, towards the end of the text block, looking
2701     // for a text node.
2702
2703     result = iter->PositionAt(saveNode);
2704     NS_ENSURE_SUCCESS(result, result);
2705
2706     node = nullptr;
2707     while (!iter->IsDone()) {
2708       nsINode* current = iter->GetCurrentNode();
2709
2710       if (current->NodeType() == nsIDOMNode::TEXT_NODE) {
2711         node = static_cast<nsIContent*>(current);
2712         break;
2713       }
2714
2715       iter->Next();
2716     }
2717
2718     NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
2719
2720     // We found a text node, so set the offset to
2721     // the beginning of the node.
2722
2723     offset = 0;
2724   }
2725
2726   for (int32_t i = 0; i < tableCount; i++) {
2727     OffsetEntry* entry = mOffsetTable[i];
2728     NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
2729
2730     if (entry->mNode == node->AsDOMNode() &&
2731         entry->mNodeOffset <= offset && offset <= (entry->mNodeOffset + entry->mLength))
2732     {
2733       *aSelStatus = nsITextServicesDocument::eBlockContains;
2734       *aSelOffset = entry->mStrOffset + (offset - entry->mNodeOffset);
2735       *aSelLength = 0;
2736
2737       // Now move the caret so that it is actually in the text node.
2738       // We do this to keep things in sync.
2739       //
2740       // In most cases, the user shouldn't see any movement in the caret
2741       // on screen.
2742
2743       result = SetSelectionInternal(*aSelOffset, *aSelLength, true);
2744
2745       return result;
2746     }
2747   }
2748
2749   return NS_ERROR_FAILURE;
2750 }
2751
2752 nsresult
2753 nsTextServicesDocument::GetUncollapsedSelection(nsITextServicesDocument::TSDBlockSelectionStatus *aSelStatus, int32_t *aSelOffset, int32_t *aSelLength)
2754 {
2755   nsresult result;
2756
2757   nsCOMPtr<nsISelection> selection;
2758   nsCOMPtr<nsIDOMRange> range;
2759   OffsetEntry *entry;
2760
2761   result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
2762
2763   NS_ENSURE_SUCCESS(result, result);
2764
2765   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
2766
2767   // It is assumed that the calling function has made sure that the
2768   // selection is not collapsed, and that the input params to this
2769   // method are initialized to some defaults.
2770
2771   nsCOMPtr<nsIDOMNode> startParent, endParent;
2772   int32_t startOffset, endOffset;
2773   int32_t rangeCount, tableCount, i;
2774   int32_t e1s1, e1s2, e2s1, e2s2;
2775
2776   OffsetEntry *eStart, *eEnd;
2777   int32_t eStartOffset, eEndOffset;
2778
2779   tableCount = mOffsetTable.Length();
2780
2781   // Get pointers to the first and last offset entries
2782   // in the table.
2783
2784   eStart = mOffsetTable[0];
2785
2786   if (tableCount > 1)
2787     eEnd = mOffsetTable[tableCount - 1];
2788   else
2789     eEnd = eStart;
2790
2791   eStartOffset = eStart->mNodeOffset;
2792   eEndOffset   = eEnd->mNodeOffset + eEnd->mLength;
2793
2794   result = selection->GetRangeCount(&rangeCount);
2795
2796   NS_ENSURE_SUCCESS(result, result);
2797
2798   // Find the first range in the selection that intersects
2799   // the current text block.
2800
2801   for (i = 0; i < rangeCount; i++)
2802   {
2803     result = selection->GetRangeAt(i, getter_AddRefs(range));
2804
2805     NS_ENSURE_SUCCESS(result, result);
2806
2807     result = GetRangeEndPoints(range,
2808                                getter_AddRefs(startParent), &startOffset,
2809                                getter_AddRefs(endParent), &endOffset);
2810
2811     NS_ENSURE_SUCCESS(result, result);
2812
2813     e1s2 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
2814                                          endParent, endOffset);
2815     e2s1 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
2816                                          startParent, startOffset);
2817
2818     // Break out of the loop if the text block intersects the current range.
2819
2820     if (e1s2 <= 0 && e2s1 >= 0)
2821       break;
2822   }
2823
2824   // We're done if we didn't find an intersecting range.
2825
2826   if (rangeCount < 1 || e1s2 > 0 || e2s1 < 0)
2827   {
2828     *aSelStatus = nsITextServicesDocument::eBlockOutside;
2829     *aSelOffset = *aSelLength = -1;
2830     return NS_OK;
2831   }
2832
2833   // Now that we have an intersecting range, find out more info:
2834
2835   e1s1 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
2836                                        startParent, startOffset);
2837   e2s2 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
2838                                        endParent, endOffset);
2839
2840   if (rangeCount > 1)
2841   {
2842     // There are multiple selection ranges, we only deal
2843     // with the first one that intersects the current,
2844     // text block, so mark this a as a partial.
2845
2846     *aSelStatus = nsITextServicesDocument::eBlockPartial;
2847   }
2848   else if (e1s1 > 0 && e2s2 < 0)
2849   {
2850     // The range extends beyond the start and
2851     // end of the current text block.
2852
2853     *aSelStatus = nsITextServicesDocument::eBlockInside;
2854   }
2855   else if (e1s1 <= 0 && e2s2 >= 0)
2856   {
2857     // The current text block contains the entire
2858     // range.
2859
2860     *aSelStatus = nsITextServicesDocument::eBlockContains;
2861   }
2862   else
2863   {
2864     // The range partially intersects the block.
2865
2866     *aSelStatus = nsITextServicesDocument::eBlockPartial;
2867   }
2868
2869   // Now create a range based on the intersection of the
2870   // text block and range:
2871
2872   nsCOMPtr<nsIDOMNode> p1, p2;
2873   int32_t     o1,  o2;
2874
2875   // The start of the range will be the rightmost
2876   // start node.
2877
2878   if (e1s1 >= 0)
2879   {
2880     p1 = do_QueryInterface(eStart->mNode);
2881     o1 = eStartOffset;
2882   }
2883   else
2884   {
2885     p1 = startParent;
2886     o1 = startOffset;
2887   }
2888
2889   // The end of the range will be the leftmost
2890   // end node.
2891
2892   if (e2s2 <= 0)
2893   {
2894     p2 = do_QueryInterface(eEnd->mNode);
2895     o2 = eEndOffset;
2896   }
2897   else
2898   {
2899     p2 = endParent;
2900     o2 = endOffset;
2901   }
2902
2903   result = CreateRange(p1, o1, p2, o2, getter_AddRefs(range));
2904
2905   NS_ENSURE_SUCCESS(result, result);
2906
2907   // Now iterate over this range to figure out the selection's
2908   // block offset and length.
2909
2910   nsCOMPtr<nsIContentIterator> iter;
2911
2912   result = CreateContentIterator(range, getter_AddRefs(iter));
2913
2914   NS_ENSURE_SUCCESS(result, result);
2915
2916   // Find the first text node in the range.
2917
2918   bool found;
2919   nsCOMPtr<nsIContent> content;
2920
2921   iter->First();
2922
2923   if (!IsTextNode(p1))
2924   {
2925     found = false;
2926
2927     while (!iter->IsDone())
2928     {
2929       content = do_QueryInterface(iter->GetCurrentNode());
2930
2931       if (IsTextNode(content))
2932       {
2933         p1 = do_QueryInterface(content);
2934
2935         NS_ENSURE_TRUE(p1, NS_ERROR_FAILURE);
2936
2937         o1 = 0;
2938         found = true;
2939
2940         break;
2941       }
2942
2943       iter->Next();
2944     }
2945
2946     NS_ENSURE_TRUE(found, NS_ERROR_FAILURE);
2947   }
2948
2949   // Find the last text node in the range.
2950
2951   iter->Last();
2952
2953   if (! IsTextNode(p2))
2954   {
2955     found = false;
2956
2957     while (!iter->IsDone())
2958     {
2959       content = do_QueryInterface(iter->GetCurrentNode());
2960
2961       if (IsTextNode(content))
2962       {
2963         p2 = do_QueryInterface(content);
2964
2965         NS_ENSURE_TRUE(p2, NS_ERROR_FAILURE);
2966
2967         nsString str;
2968
2969         result = p2->GetNodeValue(str);
2970
2971         NS_ENSURE_SUCCESS(result, result);
2972
2973         o2 = str.Length();
2974         found = true;
2975
2976         break;
2977       }
2978
2979       iter->Prev();
2980     }
2981
2982     NS_ENSURE_TRUE(found, NS_ERROR_FAILURE);
2983   }
2984
2985   found    = false;
2986   *aSelLength = 0;
2987
2988   for (i = 0; i < tableCount; i++)
2989   {
2990     entry = mOffsetTable[i];
2991
2992     NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
2993
2994     if (!found)
2995     {
2996       if (entry->mNode == p1.get() &&
2997           entry->mNodeOffset <= o1 && o1 <= (entry->mNodeOffset + entry->mLength))
2998       {
2999         *aSelOffset = entry->mStrOffset + (o1 - entry->mNodeOffset);
3000
3001         if (p1 == p2 &&
3002             entry->mNodeOffset <= o2 && o2 <= (entry->mNodeOffset + entry->mLength))
3003         {
3004           // The start and end of the range are in the same offset
3005           // entry. Calculate the length of the range then we're done.
3006
3007           *aSelLength = o2 - o1;
3008           break;
3009         }
3010         else
3011         {
3012           // Add the length of the sub string in this offset entry
3013           // that follows the start of the range.
3014
3015           *aSelLength = entry->mLength - (o1 - entry->mNodeOffset);
3016         }
3017
3018         found = true;
3019       }
3020     }
3021     else // found
3022     {
3023       if (entry->mNode == p2.get() &&
3024           entry->mNodeOffset <= o2 && o2 <= (entry->mNodeOffset + entry->mLength))
3025       {
3026         // We found the end of the range. Calculate the length of the
3027         // sub string that is before the end of the range, then we're done.
3028
3029         *aSelLength += o2 - entry->mNodeOffset;
3030         break;
3031       }
3032       else
3033       {
3034         // The entire entry must be in the range.
3035
3036         *aSelLength += entry->mLength;
3037       }
3038     }
3039   }
3040
3041   return result;
3042 }
3043
3044 bool
3045 nsTextServicesDocument::SelectionIsCollapsed()
3046 {
3047   return(mSelStartIndex == mSelEndIndex && mSelStartOffset == mSelEndOffset);
3048 }
3049
3050 bool
3051 nsTextServicesDocument::SelectionIsValid()
3052 {
3053   return(mSelStartIndex >= 0);
3054 }
3055
3056 nsresult
3057 nsTextServicesDocument::GetRangeEndPoints(nsIDOMRange *aRange,
3058                                           nsIDOMNode **aStartParent, int32_t *aStartOffset,
3059                                           nsIDOMNode **aEndParent, int32_t *aEndOffset)
3060 {
3061   nsresult result;
3062
3063   NS_ENSURE_TRUE(aRange && aStartParent && aStartOffset && aEndParent && aEndOffset, NS_ERROR_NULL_POINTER);
3064
3065   result = aRange->GetStartContainer(aStartParent);
3066
3067   NS_ENSURE_SUCCESS(result, result);
3068
3069   NS_ENSURE_TRUE(aStartParent, NS_ERROR_FAILURE);
3070
3071   result = aRange->GetStartOffset(aStartOffset);
3072
3073   NS_ENSURE_SUCCESS(result, result);
3074
3075   result = aRange->GetEndContainer(aEndParent);
3076
3077   NS_ENSURE_SUCCESS(result, result);
3078
3079   NS_ENSURE_TRUE(aEndParent, NS_ERROR_FAILURE);
3080
3081   result = aRange->GetEndOffset(aEndOffset);
3082
3083   return result;
3084 }
3085
3086
3087 nsresult
3088 nsTextServicesDocument::CreateRange(nsIDOMNode *aStartParent, int32_t aStartOffset,
3089                                     nsIDOMNode *aEndParent, int32_t aEndOffset,
3090                                     nsIDOMRange **aRange)
3091 {
3092   return nsRange::CreateRange(aStartParent, aStartOffset, aEndParent,
3093                               aEndOffset, aRange);
3094 }
3095
3096 nsresult
3097 nsTextServicesDocument::FirstTextNode(nsIContentIterator *aIterator,
3098                                       TSDIteratorStatus *aIteratorStatus)
3099 {
3100   if (aIteratorStatus)
3101     *aIteratorStatus = nsTextServicesDocument::eIsDone;
3102
3103   aIterator->First();
3104
3105   while (!aIterator->IsDone()) {
3106     if (aIterator->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {
3107       if (aIteratorStatus)
3108         *aIteratorStatus = nsTextServicesDocument::eValid;
3109       break;
3110     }
3111
3112     aIterator->Next();
3113   }
3114
3115   return NS_OK;
3116 }
3117
3118 nsresult
3119 nsTextServicesDocument::LastTextNode(nsIContentIterator *aIterator,
3120                                      TSDIteratorStatus *aIteratorStatus)
3121 {
3122   if (aIteratorStatus)
3123     *aIteratorStatus = nsTextServicesDocument::eIsDone;
3124
3125   aIterator->Last();
3126
3127   while (!aIterator->IsDone()) {
3128     if (aIterator->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {
3129       if (aIteratorStatus)
3130         *aIteratorStatus = nsTextServicesDocument::eValid;
3131       break;
3132     }
3133
3134     aIterator->Prev();
3135   }
3136
3137   return NS_OK;
3138 }
3139
3140 nsresult
3141 nsTextServicesDocument::FirstTextNodeInCurrentBlock(nsIContentIterator *iter)
3142 {
3143   NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
3144
3145   ClearDidSkip(iter);
3146
3147   nsCOMPtr<nsIContent> last;
3148
3149   // Walk backwards over adjacent text nodes until
3150   // we hit a block boundary:
3151
3152   while (!iter->IsDone())
3153   {
3154     nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->IsContent()
3155                                    ? iter->GetCurrentNode()->AsContent()
3156                                    : nullptr;
3157
3158     if (IsTextNode(content))
3159     {
3160       if (!last || HasSameBlockNodeParent(content, last))
3161         last = content;
3162       else
3163       {
3164         // We're done, the current text node is in a
3165         // different block.
3166         break;
3167       }
3168     }
3169     else if (last && IsBlockNode(content))
3170       break;
3171
3172     iter->Prev();
3173
3174     if (DidSkip(iter))
3175       break;
3176   }
3177
3178   if (last)
3179     iter->PositionAt(last);
3180
3181   // XXX: What should we return if last is null?
3182
3183   return NS_OK;
3184 }
3185
3186 nsresult
3187 nsTextServicesDocument::FirstTextNodeInPrevBlock(nsIContentIterator *aIterator)
3188 {
3189   nsCOMPtr<nsIContent> content;
3190   nsresult result;
3191
3192   NS_ENSURE_TRUE(aIterator, NS_ERROR_NULL_POINTER);
3193
3194   // XXX: What if mIterator is not currently on a text node?
3195
3196   // Make sure mIterator is pointing to the first text node in the
3197   // current block:
3198
3199   result = FirstTextNodeInCurrentBlock(aIterator);
3200
3201   NS_ENSURE_SUCCESS(result, NS_ERROR_FAILURE);
3202
3203   // Point mIterator to the first node before the first text node:
3204
3205   aIterator->Prev();
3206
3207   if (aIterator->IsDone())
3208     return NS_ERROR_FAILURE;
3209
3210   // Now find the first text node of the next block:
3211
3212   return FirstTextNodeInCurrentBlock(aIterator);
3213 }
3214
3215 nsresult
3216 nsTextServicesDocument::FirstTextNodeInNextBlock(nsIContentIterator *aIterator)
3217 {
3218   nsCOMPtr<nsIContent> prev;
3219   bool crossedBlockBoundary = false;
3220
3221   NS_ENSURE_TRUE(aIterator, NS_ERROR_NULL_POINTER);
3222
3223   ClearDidSkip(aIterator);
3224
3225   while (!aIterator->IsDone())
3226   {
3227     nsCOMPtr<nsIContent> content = aIterator->GetCurrentNode()->IsContent()
3228                                    ? aIterator->GetCurrentNode()->AsContent()
3229                                    : nullptr;
3230
3231     if (IsTextNode(content))
3232     {
3233       if (!crossedBlockBoundary && (!prev || HasSameBlockNodeParent(prev, content)))
3234         prev = content;
3235       else
3236         break;
3237     }
3238     else if (!crossedBlockBoundary && IsBlockNode(content))
3239       crossedBlockBoundary = true;
3240
3241     aIterator->Next();
3242
3243     if (!crossedBlockBoundary && DidSkip(aIterator))
3244       crossedBlockBoundary = true;
3245   }
3246
3247   return NS_OK;
3248 }
3249
3250 nsresult
3251 nsTextServicesDocument::GetFirstTextNodeInPrevBlock(nsIContent **aContent)
3252 {
3253   nsresult result;
3254
3255   NS_ENSURE_TRUE(aContent, NS_ERROR_NULL_POINTER);
3256
3257   *aContent = 0;
3258
3259   // Save the iterator's current content node so we can restore
3260   // it when we are done:
3261
3262   nsINode* node = mIterator->GetCurrentNode();
3263
3264   result = FirstTextNodeInPrevBlock(mIterator);
3265
3266   if (NS_FAILED(result))
3267   {
3268     // Try to restore the iterator before returning.
3269     mIterator->PositionAt(node);
3270     return result;
3271   }
3272
3273   if (!mIterator->IsDone())
3274   {
3275     nsCOMPtr<nsIContent> current = mIterator->GetCurrentNode()->IsContent()
3276                                    ? mIterator->GetCurrentNode()->AsContent()
3277                                    : nullptr;
3278     current.forget(aContent);
3279   }
3280
3281   // Restore the iterator:
3282
3283   return mIterator->PositionAt(node);
3284 }
3285
3286 nsresult
3287 nsTextServicesDocument::GetFirstTextNodeInNextBlock(nsIContent **aContent)
3288 {
3289   nsresult result;
3290
3291   NS_ENSURE_TRUE(aContent, NS_ERROR_NULL_POINTER);
3292
3293   *aContent = 0;
3294
3295   // Save the iterator's current content node so we can restore
3296   // it when we are done:
3297
3298   nsINode* node = mIterator->GetCurrentNode();
3299
3300   result = FirstTextNodeInNextBlock(mIterator);
3301
3302   if (NS_FAILED(result))
3303   {
3304     // Try to restore the iterator before returning.
3305     mIterator->PositionAt(node);
3306     return result;
3307   }
3308
3309   if (!mIterator->IsDone())
3310   {
3311     nsCOMPtr<nsIContent> current = mIterator->GetCurrentNode()->IsContent()
3312                                    ? mIterator->GetCurrentNode()->AsContent()
3313                                    : nullptr;
3314     current.forget(aContent);
3315   }
3316
3317   // Restore the iterator:
3318   return mIterator->PositionAt(node);
3319 }
3320
3321 nsresult
3322 nsTextServicesDocument::CreateOffsetTable(nsTArray<OffsetEntry*> *aOffsetTable,
3323                                           nsIContentIterator *aIterator,
3324                                           TSDIteratorStatus *aIteratorStatus,
3325                                           nsIDOMRange *aIterRange,
3326                                           nsString *aStr)
3327 {
3328   nsresult result = NS_OK;
3329
3330   nsCOMPtr<nsIContent> first;
3331   nsCOMPtr<nsIContent> prev;
3332
3333   NS_ENSURE_TRUE(aIterator, NS_ERROR_NULL_POINTER);
3334
3335   ClearOffsetTable(aOffsetTable);
3336
3337   if (aStr)
3338     aStr->Truncate();
3339
3340   if (*aIteratorStatus == nsTextServicesDocument::eIsDone)
3341     return NS_OK;
3342
3343   // If we have an aIterRange, retrieve the endpoints so
3344   // they can be used in the while loop below to trim entries
3345   // for text nodes that are partially selected by aIterRange.
3346
3347   nsCOMPtr<nsIDOMNode> rngStartNode, rngEndNode;
3348   int32_t rngStartOffset = 0, rngEndOffset = 0;
3349
3350   if (aIterRange)
3351   {
3352     result = GetRangeEndPoints(aIterRange,
3353                                getter_AddRefs(rngStartNode), &rngStartOffset,
3354                                getter_AddRefs(rngEndNode), &rngEndOffset);
3355
3356     NS_ENSURE_SUCCESS(result, result);
3357   }
3358
3359   // The text service could have added text nodes to the beginning
3360   // of the current block and called this method again. Make sure
3361   // we really are at the beginning of the current block:
3362
3363   result = FirstTextNodeInCurrentBlock(aIterator);
3364
3365   NS_ENSURE_SUCCESS(result, result);
3366
3367   int32_t offset = 0;
3368
3369   ClearDidSkip(aIterator);
3370
3371   while (!aIterator->IsDone())
3372   {
3373     nsCOMPtr<nsIContent> content = aIterator->GetCurrentNode()->IsContent()
3374                                    ? aIterator->GetCurrentNode()->AsContent()
3375                                    : nullptr;
3376
3377     if (IsTextNode(content))
3378     {
3379       if (!prev || HasSameBlockNodeParent(prev, content))
3380       {
3381         nsCOMPtr<nsIDOMNode> node = do_QueryInterface(content);
3382
3383         if (node)
3384         {
3385           nsString str;
3386
3387           result = node->GetNodeValue(str);
3388
3389           NS_ENSURE_SUCCESS(result, result);
3390
3391           // Add an entry for this text node into the offset table:
3392
3393           OffsetEntry *entry = new OffsetEntry(node, offset, str.Length());
3394           aOffsetTable->AppendElement(entry);
3395
3396           // If one or both of the endpoints of the iteration range
3397           // are in the text node for this entry, make sure the entry
3398           // only accounts for the portion of the text node that is
3399           // in the range.
3400
3401           int32_t startOffset = 0;
3402           int32_t endOffset   = str.Length();
3403           bool adjustStr    = false;
3404
3405           if (entry->mNode == rngStartNode)
3406           {
3407             entry->mNodeOffset = startOffset = rngStartOffset;
3408             adjustStr = true;
3409           }
3410
3411           if (entry->mNode == rngEndNode)
3412           {
3413             endOffset = rngEndOffset;
3414             adjustStr = true;
3415           }
3416
3417           if (adjustStr)
3418           {
3419             entry->mLength = endOffset - startOffset;
3420             str = Substring(str, startOffset, entry->mLength);
3421           }
3422
3423           offset += str.Length();
3424
3425           if (aStr)
3426           {
3427             // Append the text node's string to the output string:
3428
3429             if (!first)
3430               *aStr = str;
3431             else
3432               *aStr += str;
3433           }
3434         }
3435
3436         prev = content;
3437
3438         if (!first)
3439           first = content;
3440       }
3441       else
3442         break;
3443
3444     }
3445     else if (IsBlockNode(content))
3446       break;
3447
3448     aIterator->Next();
3449
3450     if (DidSkip(aIterator))
3451       break;
3452   }
3453
3454   if (first)
3455   {
3456     // Always leave the iterator pointing at the first
3457     // text node of the current block!
3458
3459     aIterator->PositionAt(first);
3460   }
3461   else
3462   {
3463     // If we never ran across a text node, the iterator
3464     // might have been pointing to something invalid to
3465     // begin with.
3466
3467     *aIteratorStatus = nsTextServicesDocument::eIsDone;
3468   }
3469
3470   return result;
3471 }
3472
3473 nsresult
3474 nsTextServicesDocument::RemoveInvalidOffsetEntries()
3475 {
3476   OffsetEntry *entry;
3477   int32_t i = 0;
3478
3479   while (uint32_t(i) < mOffsetTable.Length())
3480   {
3481     entry = mOffsetTable[i];
3482
3483     if (!entry->mIsValid)
3484     {
3485       mOffsetTable.RemoveElementAt(i);
3486
3487       if (mSelStartIndex >= 0 && mSelStartIndex >= i)
3488       {
3489         // We are deleting an entry that comes before
3490         // mSelStartIndex, decrement mSelStartIndex so
3491         // that it points to the correct entry!
3492
3493         NS_ASSERTION(i != mSelStartIndex, "Invalid selection index.");
3494
3495         --mSelStartIndex;
3496         --mSelEndIndex;
3497       }
3498     }
3499     else
3500       i++;
3501   }
3502
3503   return NS_OK;
3504 }
3505
3506 nsresult
3507 nsTextServicesDocument::ClearOffsetTable(nsTArray<OffsetEntry*> *aOffsetTable)
3508 {
3509   uint32_t i;
3510
3511   for (i = 0; i < aOffsetTable->Length(); i++)
3512   {
3513     delete aOffsetTable->ElementAt(i);
3514   }
3515
3516   aOffsetTable->Clear();
3517
3518   return NS_OK;
3519 }
3520
3521 nsresult
3522 nsTextServicesDocument::SplitOffsetEntry(int32_t aTableIndex, int32_t aNewEntryLength)
3523 {
3524   OffsetEntry *entry = mOffsetTable[aTableIndex];
3525
3526   NS_ASSERTION((aNewEntryLength > 0), "aNewEntryLength <= 0");
3527   NS_ASSERTION((aNewEntryLength < entry->mLength), "aNewEntryLength >= mLength");
3528
3529   if (aNewEntryLength < 1 || aNewEntryLength >= entry->mLength)
3530     return NS_ERROR_FAILURE;
3531
3532   int32_t oldLength = entry->mLength - aNewEntryLength;
3533
3534   OffsetEntry *newEntry = new OffsetEntry(entry->mNode,
3535                                           entry->mStrOffset + oldLength,
3536                                           aNewEntryLength);
3537
3538   if (!mOffsetTable.InsertElementAt(aTableIndex + 1, newEntry))
3539   {
3540     delete newEntry;
3541     return NS_ERROR_FAILURE;
3542   }
3543
3544    // Adjust entry fields:
3545
3546    entry->mLength        = oldLength;
3547    newEntry->mNodeOffset = entry->mNodeOffset + oldLength;
3548
3549   return NS_OK;
3550 }
3551
3552 nsresult
3553 nsTextServicesDocument::NodeHasOffsetEntry(nsTArray<OffsetEntry*> *aOffsetTable, nsIDOMNode *aNode, bool *aHasEntry, int32_t *aEntryIndex)
3554 {
3555   OffsetEntry *entry;
3556   uint32_t i;
3557
3558   NS_ENSURE_TRUE(aNode && aHasEntry && aEntryIndex, NS_ERROR_NULL_POINTER);
3559
3560   for (i = 0; i < aOffsetTable->Length(); i++)
3561   {
3562     entry = (*aOffsetTable)[i];
3563
3564     NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);
3565
3566     if (entry->mNode == aNode)
3567     {
3568       *aHasEntry   = true;
3569       *aEntryIndex = i;
3570
3571       return NS_OK;
3572     }
3573   }
3574
3575   *aHasEntry   = false;
3576   *aEntryIndex = -1;
3577
3578   return NS_OK;
3579 }
3580
3581 // Spellchecker code has this. See bug 211343
3582 #define IS_NBSP_CHAR(c) (((unsigned char)0xa0)==(c))
3583
3584 nsresult
3585 nsTextServicesDocument::FindWordBounds(nsTArray<OffsetEntry*> *aOffsetTable,
3586                                        nsString *aBlockStr,
3587                                        nsIDOMNode *aNode,
3588                                        int32_t aNodeOffset,
3589                                        nsIDOMNode **aWordStartNode,
3590                                        int32_t *aWordStartOffset,
3591                                        nsIDOMNode **aWordEndNode,
3592                                        int32_t *aWordEndOffset)
3593 {
3594   // Initialize return values.
3595
3596   if (aWordStartNode)
3597     *aWordStartNode = nullptr;
3598   if (aWordStartOffset)
3599     *aWordStartOffset = 0;
3600   if (aWordEndNode)
3601     *aWordEndNode = nullptr;
3602   if (aWordEndOffset)
3603     *aWordEndOffset = 0;
3604
3605   int32_t entryIndex = 0;
3606   bool hasEntry = false;
3607
3608   // It's assumed that aNode is a text node. The first thing
3609   // we do is get its index in the offset table so we can
3610   // calculate the dom point's string offset.
3611
3612   nsresult result = NodeHasOffsetEntry(aOffsetTable, aNode, &hasEntry, &entryIndex);
3613   NS_ENSURE_SUCCESS(result, result);
3614   NS_ENSURE_TRUE(hasEntry, NS_ERROR_FAILURE);
3615
3616   // Next we map aNodeOffset into a string offset.
3617
3618   OffsetEntry *entry = (*aOffsetTable)[entryIndex];
3619   uint32_t strOffset = entry->mStrOffset + aNodeOffset - entry->mNodeOffset;
3620
3621   // Now we use the word breaker to find the beginning and end
3622   // of the word from our calculated string offset.
3623
3624   const char16_t *str = aBlockStr->get();
3625   uint32_t strLen = aBlockStr->Length();
3626
3627   nsIWordBreaker* wordBreaker = nsContentUtils::WordBreaker();
3628   nsWordRange res = wordBreaker->FindWord(str, strLen, strOffset);
3629   if (res.mBegin > strLen) {
3630     return str ? NS_ERROR_ILLEGAL_VALUE : NS_ERROR_NULL_POINTER;
3631   }
3632
3633   // Strip out the NBSPs at the ends
3634   while ((res.mBegin <= res.mEnd) && (IS_NBSP_CHAR(str[res.mBegin])))
3635     res.mBegin++;
3636   if (str[res.mEnd] == (unsigned char)0x20)
3637   {
3638     uint32_t realEndWord = res.mEnd - 1;
3639     while ((realEndWord > res.mBegin) && (IS_NBSP_CHAR(str[realEndWord])))
3640       realEndWord--;
3641     if (realEndWord < res.mEnd - 1)
3642       res.mEnd = realEndWord + 1;
3643   }
3644
3645   // Now that we have the string offsets for the beginning
3646   // and end of the word, run through the offset table and
3647   // convert them back into dom points.
3648
3649   int32_t i, lastIndex = aOffsetTable->Length() - 1;
3650
3651   for (i=0; i <= lastIndex; i++)
3652   {
3653     entry = (*aOffsetTable)[i];
3654
3655     int32_t strEndOffset = entry->mStrOffset + entry->mLength;
3656
3657     // Check to see if res.mBegin is within the range covered
3658     // by this entry. Note that if res.mBegin is after the last
3659     // character covered by this entry, we will use the next
3660     // entry if there is one.
3661
3662     if (uint32_t(entry->mStrOffset) <= res.mBegin &&
3663         (res.mBegin < uint32_t(strEndOffset) ||
3664         (res.mBegin == uint32_t(strEndOffset) && i == lastIndex)))
3665     {
3666       if (aWordStartNode)
3667       {
3668         *aWordStartNode = entry->mNode;
3669         NS_IF_ADDREF(*aWordStartNode);
3670       }
3671
3672       if (aWordStartOffset)
3673         *aWordStartOffset = entry->mNodeOffset + res.mBegin - entry->mStrOffset;
3674
3675       if (!aWordEndNode && !aWordEndOffset)
3676       {
3677         // We've found our start entry, but if we're not looking
3678         // for end entries, we're done.
3679
3680         break;
3681       }
3682     }
3683
3684     // Check to see if res.mEnd is within the range covered
3685     // by this entry.
3686
3687     if (uint32_t(entry->mStrOffset) <= res.mEnd && res.mEnd <= uint32_t(strEndOffset))
3688     {
3689       if (res.mBegin == res.mEnd && res.mEnd == uint32_t(strEndOffset) && i != lastIndex)
3690       {
3691         // Wait for the next round so that we use the same entry
3692         // we did for aWordStartNode.
3693
3694         continue;
3695       }
3696
3697       if (aWordEndNode)
3698       {
3699         *aWordEndNode = entry->mNode;
3700         NS_IF_ADDREF(*aWordEndNode);
3701       }
3702
3703       if (aWordEndOffset)
3704         *aWordEndOffset = entry->mNodeOffset + res.mEnd - entry->mStrOffset;
3705
3706       break;
3707     }
3708   }
3709
3710
3711   return NS_OK;
3712 }
3713
3714 NS_IMETHODIMP
3715 nsTextServicesDocument::WillInsertNode(nsIDOMNode *aNode,
3716                               nsIDOMNode *aParent,
3717                               int32_t     aPosition)
3718 {
3719   return NS_OK;
3720 }
3721
3722 NS_IMETHODIMP
3723 nsTextServicesDocument::WillDeleteNode(nsIDOMNode *aChild)
3724 {
3725   return NS_OK;
3726 }
3727
3728 NS_IMETHODIMP
3729 nsTextServicesDocument::WillSplitNode(nsIDOMNode *aExistingRightNode,
3730                              int32_t     aOffset)
3731 {
3732   return NS_OK;
3733 }
3734
3735 NS_IMETHODIMP
3736 nsTextServicesDocument::WillJoinNodes(nsIDOMNode  *aLeftNode,
3737                              nsIDOMNode  *aRightNode,
3738                              nsIDOMNode  *aParent)
3739 {
3740   return NS_OK;
3741 }
3742
3743
3744 // -------------------------------
3745 // stubs for unused listen methods
3746 // -------------------------------
3747
3748 NS_IMETHODIMP
3749 nsTextServicesDocument::WillCreateNode(const nsAString& aTag, nsIDOMNode *aParent, int32_t aPosition)
3750 {
3751   return NS_OK;
3752 }
3753
3754 NS_IMETHODIMP
3755 nsTextServicesDocument::DidCreateNode(const nsAString& aTag, nsIDOMNode *aNode, nsIDOMNode *aParent, int32_t aPosition, nsresult aResult)
3756 {
3757   return NS_OK;
3758 }
3759
3760 NS_IMETHODIMP
3761 nsTextServicesDocument::WillInsertText(nsIDOMCharacterData *aTextNode, int32_t aOffset, const nsAString &aString)
3762 {
3763   return NS_OK;
3764 }
3765
3766 NS_IMETHODIMP
3767 nsTextServicesDocument::DidInsertText(nsIDOMCharacterData *aTextNode, int32_t aOffset, const nsAString &aString, nsresult aResult)
3768 {
3769   return NS_OK;
3770 }
3771
3772 NS_IMETHODIMP
3773 nsTextServicesDocument::WillDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength)
3774 {
3775   return NS_OK;
3776 }
3777
3778 NS_IMETHODIMP
3779 nsTextServicesDocument::DidDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength, nsresult aResult)
3780 {
3781   return NS_OK;
3782 }
3783
3784 NS_IMETHODIMP
3785 nsTextServicesDocument::WillDeleteSelection(nsISelection *aSelection)
3786 {
3787   return NS_OK;
3788 }
3789
3790 NS_IMETHODIMP
3791 nsTextServicesDocument::DidDeleteSelection(nsISelection *aSelection)
3792 {
3793   return NS_OK;
3794 }
3795