The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set ts=2 sw=2 et tw=78: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * Implementation of selection: nsISelection,nsISelectionPrivate and nsFrameSelection

  */

 #include "mozilla/dom/Selection.h"

 #include "mozilla/Attributes.h"

 #include "mozilla/EventStates.h"

 #include "nsCOMPtr.h"

 #include "nsString.h"

 #include "nsFrameSelection.h"

 #include "nsISelectionListener.h"

 #include "nsContentCID.h"

 #include "nsIContent.h"

 #include "nsIDOMNode.h"

 #include "nsRange.h"

 #include "nsCOMArray.h"

 #include "nsIDOMKeyEvent.h"

 #include "nsITableCellLayout.h"

 #include "nsTArray.h"

 #include "nsTableOuterFrame.h"

 #include "nsTableCellFrame.h"

 #include "nsIScrollableFrame.h"

 #include "nsCCUncollectableMarker.h"

 #include "nsIContentIterator.h"

 #include "nsIDocumentEncoder.h"

 #include "nsTextFragment.h"

 #include <algorithm>

 #include "nsGkAtoms.h"

 #include "nsIFrameTraversal.h"

 #include "nsLayoutUtils.h"

 #include "nsLayoutCID.h"

 #include "nsBidiPresUtils.h"

 static NS_DEFINE_CID(kFrameTraversalCID, NS_FRAMETRAVERSAL_CID);

 #include "nsTextFrame.h"

 #include "nsIDOMText.h"

 #include "nsContentUtils.h"

 #include "nsThreadUtils.h"

 #include "mozilla/Preferences.h"

 #include "nsDOMClassInfoID.h"

 //included for desired x position;

 #include "nsPresContext.h"

 #include "nsIPresShell.h"

 #include "nsCaret.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/TextEvents.h"

 #include "nsITimer.h"

 #include "nsFrameManager.h"

 // notifications

 #include "nsIDOMDocument.h"

 #include "nsIDocument.h"

 #include "nsISelectionController.h"//for the enums

 #include "nsAutoCopyListener.h"

 #include "nsCopySupport.h"

 #include "nsIClipboard.h"

 #include "nsIFrameInlines.h"

 #include "nsIBidiKeyboard.h"

 #include "nsError.h"

 #include "mozilla/dom/Element.h"

 #include "mozilla/dom/ShadowRoot.h"

 #include "mozilla/ErrorResult.h"

 #include "mozilla/dom/SelectionBinding.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 //#define DEBUG_TABLE 1

 static bool IsValidSelectionPoint(nsFrameSelection *aFrameSel, nsINode *aNode);

 static nsIAtom *GetTag(nsINode *aNode);

 // returns the parent

 static nsINode* ParentOffset(nsINode *aNode, int32_t *aChildOffset);

 static nsINode* GetCellParent(nsINode *aDomNode);

 #ifdef PRINT_RANGE

 static void printRange(nsRange *aDomRange);

 #define DEBUG_OUT_RANGE(x)  printRange(x)

 #else

 #define DEBUG_OUT_RANGE(x)  

 #endif // PRINT_RANGE

 //#define DEBUG_SELECTION // uncomment for printf describing every collapse and extend.

 //#define DEBUG_NAVIGATION

 //#define DEBUG_TABLE_SELECTION 1

 struct CachedOffsetForFrame {

   CachedOffsetForFrame()

   : mCachedFrameOffset(0, 0) // nsPoint ctor

   , mLastCaretFrame(nullptr)

   , mLastContentOffset(0)

   , mCanCacheFrameOffset(false)

   {}

   nsPoint      mCachedFrameOffset;      // cached frame offset

   nsIFrame*    mLastCaretFrame;         // store the frame the caret was last drawn in.

   int32_t      mLastContentOffset;      // store last content offset

   bool mCanCacheFrameOffset;    // cached frame offset is valid?

 };

 // Stack-class to turn on/off selection batching for table selection

 class MOZ_STACK_CLASS nsSelectionBatcher MOZ_FINAL

 {

 private:

   nsCOMPtr<nsISelectionPrivate> mSelection;

 public:

   nsSelectionBatcher(nsISelectionPrivate *aSelection) : mSelection(aSelection)

   {

     if (mSelection) mSelection->StartBatchChanges();

   }

   ~nsSelectionBatcher() 

   { 

     if (mSelection) mSelection->EndBatchChanges();

   }

 };

 class nsAutoScrollTimer : public nsITimerCallback

 {

 public:

   NS_DECL_ISUPPORTS

   nsAutoScrollTimer()

   : mFrameSelection(0), mSelection(0), mPresContext(0), mPoint(0,0), mDelay(30)

   {

   }

   virtual ~nsAutoScrollTimer()

   {

    if (mTimer)

        mTimer->Cancel();

   }

   // aPoint is relative to aPresContext's root frame

   nsresult Start(nsPresContext *aPresContext, nsPoint &aPoint)

   {

     mPoint = aPoint;

     // Store the presentation context. The timer will be

     // stopped by the selection if the prescontext is destroyed.

     mPresContext = aPresContext;

     mContent = nsIPresShell::GetCapturingContent();

     if (!mTimer)

     {

       nsresult result;

       mTimer = do_CreateInstance("@mozilla.org/timer;1", &result);

       if (NS_FAILED(result))

         return result;

     }

     return mTimer->InitWithCallback(this, mDelay, nsITimer::TYPE_ONE_SHOT);

   }

   nsresult Stop()

   {

     if (mTimer)

     {

       mTimer->Cancel();

       mTimer = 0;

     }

     mContent = nullptr;

     return NS_OK;

   }

   nsresult Init(nsFrameSelection* aFrameSelection, Selection* aSelection)

   {

     mFrameSelection = aFrameSelection;

     mSelection = aSelection;

     return NS_OK;

   }

   nsresult SetDelay(uint32_t aDelay)

   {

     mDelay = aDelay;

     return NS_OK;

   }

   NS_IMETHOD Notify(nsITimer *timer) MOZ_OVERRIDE

   {

     if (mSelection && mPresContext)

     {

       nsWeakFrame frame =

         mContent ? mPresContext->GetPrimaryFrameFor(mContent) : nullptr;

       if (!frame)

         return NS_OK;

       mContent = nullptr;

       nsPoint pt = mPoint -

         frame->GetOffsetTo(mPresContext->PresShell()->FrameManager()->GetRootFrame());

       mFrameSelection->HandleDrag(frame, pt);

       if (!frame.IsAlive())

         return NS_OK;

       NS_ASSERTION(frame->PresContext() == mPresContext, "document mismatch?");

       mSelection->DoAutoScroll(frame, pt);

     }

     return NS_OK;

   }

 private:

   nsFrameSelection *mFrameSelection;

   Selection* mSelection;

   nsPresContext *mPresContext;

   // relative to mPresContext's root frame

   nsPoint mPoint;

   nsCOMPtr<nsITimer> mTimer;

   nsCOMPtr<nsIContent> mContent;

   uint32_t mDelay;

 };

 NS_IMPL_ISUPPORTS(nsAutoScrollTimer, nsITimerCallback)

 nsresult NS_NewDomSelection(nsISelection **aDomSelection)

 {

   Selection* rlist = new Selection;

   *aDomSelection = (nsISelection *)rlist;

   NS_ADDREF(rlist);

   return NS_OK;

 }

 static int8_t

 GetIndexFromSelectionType(SelectionType aType)

 {

     switch (aType)

     {

     case nsISelectionController::SELECTION_NORMAL: return 0; break;

     case nsISelectionController::SELECTION_SPELLCHECK: return 1; break;

     case nsISelectionController::SELECTION_IME_RAWINPUT: return 2; break;

     case nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT: return 3; break;

     case nsISelectionController::SELECTION_IME_CONVERTEDTEXT: return 4; break;

     case nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT: return 5; break;

     case nsISelectionController::SELECTION_ACCESSIBILITY: return 6; break;

     case nsISelectionController::SELECTION_FIND: return 7; break;

     case nsISelectionController::SELECTION_URLSECONDARY: return 8; break;

     default:

       return -1; break;

     }

     /* NOTREACHED */

     return 0;

 }

 static SelectionType 

 GetSelectionTypeFromIndex(int8_t aIndex)

 {

   switch (aIndex)

   {

     case 0: return nsISelectionController::SELECTION_NORMAL; break;

     case 1: return nsISelectionController::SELECTION_SPELLCHECK; break;

     case 2: return nsISelectionController::SELECTION_IME_RAWINPUT; break;

     case 3: return nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT; break;

     case 4: return nsISelectionController::SELECTION_IME_CONVERTEDTEXT; break;

     case 5: return nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT; break;

     case 6: return nsISelectionController::SELECTION_ACCESSIBILITY; break;

     case 7: return nsISelectionController::SELECTION_FIND; break;

     case 8: return nsISelectionController::SELECTION_URLSECONDARY; break;

     default:

       return nsISelectionController::SELECTION_NORMAL; break;

   }

   /* NOTREACHED */

   return 0;

 }

 /*

 The limiter is used specifically for the text areas and textfields

 In that case it is the DIV tag that is anonymously created for the text

 areas/fields.  Text nodes and BR nodes fall beneath it.  In the case of a 

 BR node the limiter will be the parent and the offset will point before or

 after the BR node.  In the case of the text node the parent content is 

 the text node itself and the offset will be the exact character position.

 The offset is not important to check for validity.  Simply look at the 

 passed in content.  If it equals the limiter then the selection point is valid.

 If its parent it the limiter then the point is also valid.  In the case of 

 NO limiter all points are valid since you are in a topmost iframe. (browser

 or composer)

 */

 bool         

 IsValidSelectionPoint(nsFrameSelection *aFrameSel, nsINode *aNode)

 {

   if (!aFrameSel || !aNode)

     return false;

   nsIContent *limiter = aFrameSel->GetLimiter();

   if (limiter && limiter != aNode && limiter != aNode->GetParent()) {

     //if newfocus == the limiter. that's ok. but if not there and not parent bad

     return false; //not in the right content. tLimiter said so

   }

   limiter = aFrameSel->GetAncestorLimiter();

   return !limiter || nsContentUtils::ContentIsDescendantOf(aNode, limiter);

 }

 ////////////BEGIN nsFrameSelection methods

 nsFrameSelection::nsFrameSelection()

 {

   int32_t i;

   for (i = 0;i<nsISelectionController::NUM_SELECTIONTYPES;i++){

     mDomSelections[i] = new Selection(this);

     mDomSelections[i]->SetType(GetSelectionTypeFromIndex(i));

   }

   mBatching = 0;

   mChangesDuringBatching = false;

   mNotifyFrames = true;

   mMouseDoubleDownState = false;

   mHint = HINTLEFT;

   mCaretBidiLevel = BIDI_LEVEL_UNDEFINED;

   mDragSelectingCells = false;

   mSelectingTableCellMode = 0;

   mSelectedCellIndex = 0;

   // Check to see if the autocopy pref is enabled

   //   and add the autocopy listener if it is

   if (Preferences::GetBool("clipboard.autocopy")) {

     nsAutoCopyListener *autoCopy = nsAutoCopyListener::GetInstance();

     if (autoCopy) {

       int8_t index =

         GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

       if (mDomSelections[index]) {

         autoCopy->Listen(mDomSelections[index]);

       }

     }

   }

   mDisplaySelection = nsISelectionController::SELECTION_OFF;

   mSelectionChangeReason = nsISelectionListener::NO_REASON;

   mDelayedMouseEventValid = false;

   // These values are not used since they are only valid when

   // mDelayedMouseEventValid is true, and setting mDelayedMouseEventValid

   //alwaysoverrides these values.

   mDelayedMouseEventIsShift = false;

   mDelayedMouseEventClickCount = 0;

 }

 NS_IMPL_CYCLE_COLLECTION_CLASS(nsFrameSelection)

 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsFrameSelection)

   int32_t i;

   for (i = 0; i < nsISelectionController::NUM_SELECTIONTYPES; ++i) {

     tmp->mDomSelections[i] = nullptr;

   }

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCellParent)

   tmp->mSelectingTableCellMode = 0;

   tmp->mDragSelectingCells = false;

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStartSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mEndSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mAppendStartSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mUnselectCellOnMouseUp)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mMaintainRange)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLimiter)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mAncestorLimiter)

 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsFrameSelection)

   if (tmp->mShell && tmp->mShell->GetDocument() &&

       nsCCUncollectableMarker::InGeneration(cb,

                                             tmp->mShell->GetDocument()->

                                               GetMarkedCCGeneration())) {

     return NS_SUCCESS_INTERRUPTED_TRAVERSE;

   }

   int32_t i;

   for (i = 0; i < nsISelectionController::NUM_SELECTIONTYPES; ++i) {

     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDomSelections[i])

   }

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCellParent)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStartSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAppendStartSelectedCell)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUnselectCellOnMouseUp)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMaintainRange)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLimiter)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAncestorLimiter)

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsFrameSelection, AddRef)

 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsFrameSelection, Release)

 nsresult

 nsFrameSelection::FetchDesiredX(nscoord &aDesiredX) //the x position requested by the Key Handling for up down

 {

   if (!mShell)

   {

     NS_ERROR("fetch desired X failed");

     return NS_ERROR_FAILURE;

   }

   if (mDesiredXSet)

   {

     aDesiredX = mDesiredX;

     return NS_OK;

   }

   nsRefPtr<nsCaret> caret = mShell->GetCaret();

   if (!caret)

     return NS_ERROR_NULL_POINTER;

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   nsresult result = caret->SetCaretDOMSelection(mDomSelections[index]);

   if (NS_FAILED(result))

     return result;

   nsRect coord;

   nsIFrame* caretFrame = caret->GetGeometry(mDomSelections[index], &coord);

   if (!caretFrame)

     return NS_ERROR_FAILURE;

   nsPoint viewOffset(0, 0);

   nsView* view = nullptr;

   caretFrame->GetOffsetFromView(viewOffset, &view);

   if (view)

     coord.x += viewOffset.x;

   aDesiredX = coord.x;

   return NS_OK;

 }

 void

 nsFrameSelection::InvalidateDesiredX() //do not listen to mDesiredX you must get another.

 {

   mDesiredXSet = false;

 }

 void

 nsFrameSelection::SetDesiredX(nscoord aX) //set the mDesiredX

 {

   mDesiredX = aX;

   mDesiredXSet = true;

 }

 nsresult

 nsFrameSelection::ConstrainFrameAndPointToAnchorSubtree(nsIFrame  *aFrame,

                                                         nsPoint&   aPoint,

                                                         nsIFrame **aRetFrame,

                                                         nsPoint&   aRetPoint)

 {

   //

   // The whole point of this method is to return a frame and point that

   // that lie within the same valid subtree as the anchor node's frame,

   // for use with the method GetContentAndOffsetsFromPoint().

   //

   // A valid subtree is defined to be one where all the content nodes in

   // the tree have a valid parent-child relationship.

   //

   // If the anchor frame and aFrame are in the same subtree, aFrame will

   // be returned in aRetFrame. If they are in different subtrees, we

   // return the frame for the root of the subtree.

   //

   if (!aFrame || !aRetFrame)

     return NS_ERROR_NULL_POINTER;

   *aRetFrame = aFrame;

   aRetPoint  = aPoint;

   //

   // Get the frame and content for the selection's anchor point!

   //

   nsresult result;

   nsCOMPtr<nsIDOMNode> anchorNode;

   int32_t anchorOffset = 0;

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   result = mDomSelections[index]->GetAnchorNode(getter_AddRefs(anchorNode));

   if (NS_FAILED(result))

     return result;

   if (!anchorNode)

     return NS_OK;

   result = mDomSelections[index]->GetAnchorOffset(&anchorOffset);

   if (NS_FAILED(result))

     return result;

   nsCOMPtr<nsIContent> anchorContent = do_QueryInterface(anchorNode);

   if (!anchorContent)

     return NS_ERROR_FAILURE;

   //

   // Now find the root of the subtree containing the anchor's content.

   //

   NS_ENSURE_STATE(mShell);

   nsIContent* anchorRoot = anchorContent->GetSelectionRootContent(mShell);

   NS_ENSURE_TRUE(anchorRoot, NS_ERROR_UNEXPECTED);

   //

   // Now find the root of the subtree containing aFrame's content.

   //

   nsIContent* content = aFrame->GetContent();

   if (content)

   {

     nsIContent* contentRoot = content->GetSelectionRootContent(mShell);

     NS_ENSURE_TRUE(contentRoot, NS_ERROR_UNEXPECTED);

     if (anchorRoot == contentRoot)

     {

       // If the aFrame's content isn't the capturing content, it should be

       // a descendant.  At this time, we can return simply.

       nsIContent* capturedContent = nsIPresShell::GetCapturingContent();

       if (capturedContent != content)

       {

         return NS_OK;

       }

       // Find the frame under the mouse cursor with the root frame.

       // At this time, don't use the anchor's frame because it may not have

       // fixed positioned frames.

       nsIFrame* rootFrame = mShell->FrameManager()->GetRootFrame();

       nsPoint ptInRoot = aPoint + aFrame->GetOffsetTo(rootFrame);

       nsIFrame* cursorFrame =

         nsLayoutUtils::GetFrameForPoint(rootFrame, ptInRoot);

       // If the mouse cursor in on a frame which is descendant of same

       // selection root, we can expand the selection to the frame.

       if (cursorFrame && cursorFrame->PresContext()->PresShell() == mShell)

       {

         nsIContent* cursorContent = cursorFrame->GetContent();

         NS_ENSURE_TRUE(cursorContent, NS_ERROR_FAILURE);

         nsIContent* cursorContentRoot =

           cursorContent->GetSelectionRootContent(mShell);

         NS_ENSURE_TRUE(cursorContentRoot, NS_ERROR_UNEXPECTED);

         if (cursorContentRoot == anchorRoot)

         {

           *aRetFrame = cursorFrame;

           aRetPoint = aPoint + aFrame->GetOffsetTo(cursorFrame);

           return NS_OK;

         }

       }

       // Otherwise, e.g., the cursor isn't on any frames (e.g., the mouse

       // cursor is out of the window), we should use the frame of the anchor

       // root.

     }

   }

   //

   // When we can't find a frame which is under the mouse cursor and has a same

   // selection root as the anchor node's, we should return the selection root

   // frame.

   //

   *aRetFrame = anchorRoot->GetPrimaryFrame();

   if (!*aRetFrame)

     return NS_ERROR_FAILURE;

   //

   // Now make sure that aRetPoint is converted to the same coordinate

   // system used by aRetFrame.

   //

   aRetPoint = aPoint + aFrame->GetOffsetTo(*aRetFrame);

   return NS_OK;

 }

 void

 nsFrameSelection::SetCaretBidiLevel(uint8_t aLevel)

 {

   // If the current level is undefined, we have just inserted new text.

   // In this case, we don't want to reset the keyboard language

   mCaretBidiLevel = aLevel;

   return;

 }

 uint8_t

 nsFrameSelection::GetCaretBidiLevel() const

 {

   return mCaretBidiLevel;

 }

 void

 nsFrameSelection::UndefineCaretBidiLevel()

 {

   mCaretBidiLevel |= BIDI_LEVEL_UNDEFINED;

 }

 #ifdef PRINT_RANGE

 void printRange(nsRange *aDomRange)

 {

   if (!aDomRange)

   {

     printf("NULL nsIDOMRange\n");

   }

   nsINode* startNode = aDomRange->GetStartParent();

   nsINode* endNode = aDomRange->GetEndParent();

   int32_t startOffset = aDomRange->StartOffset();

   int32_t endOffset = aDomRange->EndOffset();

   printf("range: 0x%lx\t start: 0x%lx %ld, \t end: 0x%lx,%ld\n",

          (unsigned long)aDomRange,

          (unsigned long)startNode, (long)startOffset,

          (unsigned long)endNode, (long)endOffset);

 }

 #endif /* PRINT_RANGE */

 static

 nsIAtom *GetTag(nsINode *aNode)

 {

   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);

   if (!content) 

   {

     NS_NOTREACHED("bad node passed to GetTag()");

     return nullptr;

   }

   return content->Tag();

 }

 // Returns the parent

 nsINode*

 ParentOffset(nsINode *aNode, int32_t *aChildOffset)

 {

   if (!aNode || !aChildOffset)

     return nullptr;

   nsIContent* parent = aNode->GetParent();

   if (parent)

   {

     *aChildOffset = parent->IndexOf(aNode);

     return parent;

   }

   return nullptr;

 }

 static nsINode*

 GetCellParent(nsINode *aDomNode)

 {

     if (!aDomNode)

       return nullptr;

     nsINode* current = aDomNode;

     // Start with current node and look for a table cell

     while (current)

     {

       nsIAtom* tag = GetTag(current);

       if (tag == nsGkAtoms::td || tag == nsGkAtoms::th)

         return current;

       current = current->GetParent();

     }

     return nullptr;

 }

 void

 nsFrameSelection::Init(nsIPresShell *aShell, nsIContent *aLimiter)

 {

   mShell = aShell;

   mMouseDownState = false;

   mDesiredXSet = false;

   mLimiter = aLimiter;

   mCaretMovementStyle =

     Preferences::GetInt("bidi.edit.caret_movement_style", 2);

 }

 nsresult

 nsFrameSelection::MoveCaret(uint32_t          aKeycode,

                             bool              aContinueSelection,

                             nsSelectionAmount aAmount)

 {

   bool visualMovement =

       (aKeycode == nsIDOMKeyEvent::DOM_VK_BACK_SPACE ||

        aKeycode == nsIDOMKeyEvent::DOM_VK_DELETE ||

        aKeycode == nsIDOMKeyEvent::DOM_VK_HOME ||

        aKeycode == nsIDOMKeyEvent::DOM_VK_END) ?

       false : // Delete operations and home/end are always logical

       mCaretMovementStyle == 1 ||

         (mCaretMovementStyle == 2 && !aContinueSelection);

   return MoveCaret(aKeycode, aContinueSelection, aAmount, visualMovement);

 }

 nsresult

 nsFrameSelection::MoveCaret(uint32_t          aKeycode,

                             bool              aContinueSelection,

                             nsSelectionAmount aAmount,

                             bool              aVisualMovement)

 {

   NS_ENSURE_STATE(mShell);

   // Flush out layout, since we need it to be up to date to do caret

   // positioning.

   mShell->FlushPendingNotifications(Flush_Layout);

   if (!mShell) {

     return NS_OK;

   }

   nsPresContext *context = mShell->GetPresContext();

   if (!context)

     return NS_ERROR_FAILURE;

   bool isCollapsed;

   nscoord desiredX = 0; //we must keep this around and revalidate it when its just UP/DOWN

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   nsRefPtr<Selection> sel = mDomSelections[index];

   if (!sel)

     return NS_ERROR_NULL_POINTER;

   int32_t scrollFlags = 0;

   nsINode* focusNode = sel->GetFocusNode();

   if (focusNode &&

       (focusNode->IsEditable() ||

        (focusNode->IsElement() &&

         focusNode->AsElement()->State().

           HasState(NS_EVENT_STATE_MOZ_READWRITE)))) {

     // If caret moves in editor, it should cause scrolling even if it's in

     // overflow: hidden;.

     scrollFlags |= Selection::SCROLL_OVERFLOW_HIDDEN;

   }

   nsresult result = sel->GetIsCollapsed(&isCollapsed);

   if (NS_FAILED(result))

     return result;

   if (aKeycode == nsIDOMKeyEvent::DOM_VK_UP ||

       aKeycode == nsIDOMKeyEvent::DOM_VK_DOWN)

   {

     result = FetchDesiredX(desiredX);

     if (NS_FAILED(result))

       return result;

     SetDesiredX(desiredX);

   }

   int32_t caretStyle = Preferences::GetInt("layout.selection.caret_style", 0);

   if (caretStyle == 0

 #ifdef XP_WIN

       && aKeycode != nsIDOMKeyEvent::DOM_VK_UP

       && aKeycode != nsIDOMKeyEvent::DOM_VK_DOWN

 #endif

      ) {

     // Put caret at the selection edge in the |aKeycode| direction.

     caretStyle = 2;

   }

   if (!isCollapsed && !aContinueSelection && caretStyle == 2) {

     switch (aKeycode){

       case nsIDOMKeyEvent::DOM_VK_LEFT  :

       case nsIDOMKeyEvent::DOM_VK_UP    :

         {

           const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();

           if (anchorFocusRange) {

             PostReason(nsISelectionListener::COLLAPSETOSTART_REASON);

             sel->Collapse(anchorFocusRange->GetStartParent(),

                           anchorFocusRange->StartOffset());

           }

           mHint = HINTRIGHT;

           sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,

                               nsIPresShell::ScrollAxis(),

                               nsIPresShell::ScrollAxis(), scrollFlags);

           return NS_OK;

         }

       case nsIDOMKeyEvent::DOM_VK_RIGHT :

       case nsIDOMKeyEvent::DOM_VK_DOWN  :

         {

           const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();

           if (anchorFocusRange) {

             PostReason(nsISelectionListener::COLLAPSETOEND_REASON);

             sel->Collapse(anchorFocusRange->GetEndParent(),

                           anchorFocusRange->EndOffset());

           }

           mHint = HINTLEFT;

           sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,

                               nsIPresShell::ScrollAxis(),

                               nsIPresShell::ScrollAxis(), scrollFlags);

           return NS_OK;

         }

     }

   }

   nsIFrame *frame;

   int32_t offsetused = 0;

   result = sel->GetPrimaryFrameForFocusNode(&frame, &offsetused,

                                             aVisualMovement);

   if (NS_FAILED(result) || !frame)

     return NS_FAILED(result) ? result : NS_ERROR_FAILURE;

   //set data using mLimiter to stop on scroll views.  If we have a limiter then we stop peeking

   //when we hit scrollable views.  If no limiter then just let it go ahead

   nsPeekOffsetStruct pos(aAmount, eDirPrevious, offsetused, desiredX,

                          true, mLimiter != nullptr, true, aVisualMovement);

   nsBidiLevel baseLevel = nsBidiPresUtils::GetFrameBaseLevel(frame);

   HINT tHint(mHint); //temporary variable so we dont set mHint until it is necessary

   switch (aKeycode){

     case nsIDOMKeyEvent::DOM_VK_RIGHT : 

         InvalidateDesiredX();

         pos.mDirection = (baseLevel & 1) ? eDirPrevious : eDirNext;

       break;

     case nsIDOMKeyEvent::DOM_VK_LEFT :

         InvalidateDesiredX();

         pos.mDirection = (baseLevel & 1) ? eDirNext : eDirPrevious;

       break;

     case nsIDOMKeyEvent::DOM_VK_DELETE :

         InvalidateDesiredX();

         pos.mDirection = eDirNext;

       break;

     case nsIDOMKeyEvent::DOM_VK_BACK_SPACE : 

         InvalidateDesiredX();

         pos.mDirection = eDirPrevious;

       break;

     case nsIDOMKeyEvent::DOM_VK_DOWN : 

         pos.mAmount = eSelectLine;

         pos.mDirection = eDirNext;

       break;

     case nsIDOMKeyEvent::DOM_VK_UP : 

         pos.mAmount = eSelectLine;

         pos.mDirection = eDirPrevious;

       break;

     case nsIDOMKeyEvent::DOM_VK_HOME :

         InvalidateDesiredX();

         pos.mAmount = eSelectBeginLine;

       break;

     case nsIDOMKeyEvent::DOM_VK_END :

         InvalidateDesiredX();

         pos.mAmount = eSelectEndLine;

       break;

   default :return NS_ERROR_FAILURE;

   }

   PostReason(nsISelectionListener::KEYPRESS_REASON);

   if (NS_SUCCEEDED(result = frame->PeekOffset(&pos)) && pos.mResultContent)

   {

     nsIFrame *theFrame;

     int32_t currentOffset, frameStart, frameEnd;

     if (aAmount >= eSelectCharacter && aAmount <= eSelectWord)

     {

       // For left/right, PeekOffset() sets pos.mResultFrame correctly, but does not set pos.mAttachForward,

       // so determine the hint here based on the result frame and offset:

       // If we're at the end of a text frame, set the hint to HINTLEFT to indicate that we

       // want the caret displayed at the end of this frame, not at the beginning of the next one.

       theFrame = pos.mResultFrame;

       theFrame->GetOffsets(frameStart, frameEnd);

       currentOffset = pos.mContentOffset;

       if (frameEnd == currentOffset && !(frameStart == 0 && frameEnd == 0))

         tHint = HINTLEFT;

       else

         tHint = HINTRIGHT;

     } else {

       // For up/down and home/end, pos.mResultFrame might not be set correctly, or not at all.

       // In these cases, get the frame based on the content and hint returned by PeekOffset().

       tHint = (HINT)pos.mAttachForward;

       theFrame = GetFrameForNodeOffset(pos.mResultContent, pos.mContentOffset,

                                        tHint, &currentOffset);

       if (!theFrame)

         return NS_ERROR_FAILURE;

       theFrame->GetOffsets(frameStart, frameEnd);

     }

     if (context->BidiEnabled())

     {

       switch (aKeycode) {

         case nsIDOMKeyEvent::DOM_VK_HOME:

         case nsIDOMKeyEvent::DOM_VK_END:

           // set the caret Bidi level to the paragraph embedding level

           SetCaretBidiLevel(NS_GET_BASE_LEVEL(theFrame));

           break;

         default:

           // If the current position is not a frame boundary, it's enough just to take the Bidi level of the current frame

           if ((pos.mContentOffset != frameStart && pos.mContentOffset != frameEnd)

               || (eSelectLine == aAmount))

           {

             SetCaretBidiLevel(NS_GET_EMBEDDING_LEVEL(theFrame));

           }

           else

             BidiLevelFromMove(mShell, pos.mResultContent, pos.mContentOffset, aKeycode, tHint);

       }

     }

     result = TakeFocus(pos.mResultContent, pos.mContentOffset, pos.mContentOffset,

                        tHint, aContinueSelection, false);

   } else if (aKeycode == nsIDOMKeyEvent::DOM_VK_RIGHT && !aContinueSelection) {

     // Collapse selection if PeekOffset failed, we either

     //  1. bumped into the BRFrame, bug 207623

     //  2. had select-all in a text input (DIV range), bug 352759.

     bool isBRFrame = frame->GetType() == nsGkAtoms::brFrame;

     sel->Collapse(sel->GetFocusNode(), sel->FocusOffset());

     // Note: 'frame' might be dead here.

     if (!isBRFrame) {

       mHint = HINTLEFT; // We're now at the end of the frame to the left.

     }

     result = NS_OK;

   }

   if (NS_SUCCEEDED(result))

   {

     result = mDomSelections[index]->

       ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,

                      nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis(),

                      scrollFlags);

   }

   return result;

 }

 //END nsFrameSelection methods

 //BEGIN nsFrameSelection methods

 NS_IMETHODIMP

 Selection::ToString(nsAString& aReturn)

 {

   // We need Flush_Style here to make sure frames have been created for

   // the selected content.  Use mFrameSelection->GetShell() which returns

   // null if the Selection has been disconnected (the shell is Destroyed).

   nsCOMPtr<nsIPresShell> shell =

     mFrameSelection ? mFrameSelection->GetShell() : nullptr;

   if (!shell) {

     aReturn.Truncate();

     return NS_OK;

   }

   shell->FlushPendingNotifications(Flush_Style);

   return ToStringWithFormat("text/plain",

                             nsIDocumentEncoder::SkipInvisibleContent,

                             0, aReturn);

 }

 void

 Selection::Stringify(nsAString& aResult)

 {

   // Eat the error code

   ToString(aResult);

 }

 NS_IMETHODIMP

 Selection::ToStringWithFormat(const char* aFormatType, uint32_t aFlags,

                               int32_t aWrapCol, nsAString& aReturn)

 {

   ErrorResult result;

   NS_ConvertUTF8toUTF16 format(aFormatType);

   ToStringWithFormat(format, aFlags, aWrapCol, aReturn, result);

   if (result.Failed()) {

     return result.ErrorCode();

   }

   return NS_OK;

 }

 void

 Selection::ToStringWithFormat(const nsAString& aFormatType, uint32_t aFlags,

                               int32_t aWrapCol, nsAString& aReturn,

                               ErrorResult& aRv)

 {

   nsresult rv = NS_OK;

   NS_ConvertUTF8toUTF16 formatType( NS_DOC_ENCODER_CONTRACTID_BASE );

   formatType.Append(aFormatType);

   nsCOMPtr<nsIDocumentEncoder> encoder =

            do_CreateInstance(NS_ConvertUTF16toUTF8(formatType).get(), &rv);

   if (NS_FAILED(rv)) {

     aRv.Throw(rv);

     return;

   }

   nsIPresShell* shell = GetPresShell();

   if (!shell) {

     aRv.Throw(NS_ERROR_FAILURE);

     return;

   }

   nsIDocument *doc = shell->GetDocument();

   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(doc);

   NS_ASSERTION(domDoc, "Need a document");

   // Flags should always include OutputSelectionOnly if we're coming from here:

   aFlags |= nsIDocumentEncoder::OutputSelectionOnly;

   nsAutoString readstring;

   readstring.Assign(aFormatType);

   rv = encoder->Init(domDoc, readstring, aFlags);

   if (NS_FAILED(rv)) {

     aRv.Throw(rv);

     return;

   }

   encoder->SetSelection(this);

   if (aWrapCol != 0)

     encoder->SetWrapColumn(aWrapCol);

   rv = encoder->EncodeToString(aReturn);

   if (NS_FAILED(rv)) {

     aRv.Throw(rv);

   }

 }

 NS_IMETHODIMP

 Selection::SetInterlinePosition(bool aHintRight)

 {

   ErrorResult result;

   SetInterlinePosition(aHintRight, result);

   if (result.Failed()) {

     return result.ErrorCode();

   }

   return NS_OK;

 }

 void

 Selection::SetInterlinePosition(bool aHintRight, ErrorResult& aRv)

 {

   if (!mFrameSelection) {

     aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection

     return;

   }

   nsFrameSelection::HINT hint;

   if (aHintRight)

     hint = nsFrameSelection::HINTRIGHT;

   else

     hint = nsFrameSelection::HINTLEFT;

   mFrameSelection->SetHint(hint);

 }

 NS_IMETHODIMP

 Selection::GetInterlinePosition(bool* aHintRight)

 {

   ErrorResult result;

   *aHintRight = GetInterlinePosition(result);

   if (result.Failed()) {

     return result.ErrorCode();

   }

   return NS_OK;

 }

 bool

 Selection::GetInterlinePosition(ErrorResult& aRv)

 {

   if (!mFrameSelection) {

     aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection

     return false;

   }

   return (mFrameSelection->GetHint() == nsFrameSelection::HINTRIGHT);

 }

 nsPrevNextBidiLevels

 nsFrameSelection::GetPrevNextBidiLevels(nsIContent *aNode,

                                         uint32_t    aContentOffset,

                                         bool        aJumpLines) const

 {

   return GetPrevNextBidiLevels(aNode, aContentOffset, mHint, aJumpLines);

 }

 nsPrevNextBidiLevels

 nsFrameSelection::GetPrevNextBidiLevels(nsIContent *aNode,

                                         uint32_t    aContentOffset,

                                         HINT        aHint,

                                         bool        aJumpLines) const

 {

   // Get the level of the frames on each side

   nsIFrame    *currentFrame;

   int32_t     currentOffset;

   int32_t     frameStart, frameEnd;

   nsDirection direction;

   nsPrevNextBidiLevels levels;

   levels.SetData(nullptr, nullptr, 0, 0);

   currentFrame = GetFrameForNodeOffset(aNode, aContentOffset,

                                        aHint, &currentOffset);

   if (!currentFrame)

     return levels;

   currentFrame->GetOffsets(frameStart, frameEnd);

   if (0 == frameStart && 0 == frameEnd)

     direction = eDirPrevious;

   else if (frameStart == currentOffset)

     direction = eDirPrevious;

   else if (frameEnd == currentOffset)

     direction = eDirNext;

   else {

     // we are neither at the beginning nor at the end of the frame, so we have no worries

     levels.SetData(currentFrame, currentFrame,

                    NS_GET_EMBEDDING_LEVEL(currentFrame),

                    NS_GET_EMBEDDING_LEVEL(currentFrame));

     return levels;

   }

   nsIFrame *newFrame;

   int32_t offset;

   bool jumpedLine;

   nsresult rv = currentFrame->GetFrameFromDirection(direction, false,

                                                     aJumpLines, true,

                                                     &newFrame, &offset, &jumpedLine);

   if (NS_FAILED(rv))

     newFrame = nullptr;

   uint8_t baseLevel = NS_GET_BASE_LEVEL(currentFrame);

   uint8_t currentLevel = NS_GET_EMBEDDING_LEVEL(currentFrame);

   uint8_t newLevel = newFrame ? NS_GET_EMBEDDING_LEVEL(newFrame) : baseLevel;

   // If not jumping lines, disregard br frames, since they might be positioned incorrectly.

   // XXX This could be removed once bug 339786 is fixed.

   if (!aJumpLines) {

     if (currentFrame->GetType() == nsGkAtoms::brFrame) {

       currentFrame = nullptr;

       currentLevel = baseLevel;

     }

     if (newFrame && newFrame->GetType() == nsGkAtoms::brFrame) {

       newFrame = nullptr;

       newLevel = baseLevel;

     }

   }

   if (direction == eDirNext)

     levels.SetData(currentFrame, newFrame, currentLevel, newLevel);

   else

     levels.SetData(newFrame, currentFrame, newLevel, currentLevel);

   return levels;

 }

 nsresult

 nsFrameSelection::GetFrameFromLevel(nsIFrame    *aFrameIn,

                                     nsDirection  aDirection,

                                     uint8_t      aBidiLevel,

                                     nsIFrame   **aFrameOut) const

 {

   NS_ENSURE_STATE(mShell);

   uint8_t foundLevel = 0;

   nsIFrame *foundFrame = aFrameIn;

   nsCOMPtr<nsIFrameEnumerator> frameTraversal;

   nsresult result;

   nsCOMPtr<nsIFrameTraversal> trav(do_CreateInstance(kFrameTraversalCID,&result));

   if (NS_FAILED(result))

       return result;

   result = trav->NewFrameTraversal(getter_AddRefs(frameTraversal),

                                    mShell->GetPresContext(), aFrameIn,

                                    eLeaf,

                                    false, // aVisual

                                    false, // aLockInScrollView

                                    false     // aFollowOOFs

                                    );

   if (NS_FAILED(result))

     return result;

   do {

     *aFrameOut = foundFrame;

     if (aDirection == eDirNext)

       frameTraversal->Next();

     else

       frameTraversal->Prev();

     foundFrame = frameTraversal->CurrentItem();

     if (!foundFrame)

       return NS_ERROR_FAILURE;

     foundLevel = NS_GET_EMBEDDING_LEVEL(foundFrame);

   } while (foundLevel > aBidiLevel);

   return NS_OK;

 }

 nsresult

 nsFrameSelection::MaintainSelection(nsSelectionAmount aAmount)

 {

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   mMaintainedAmount = aAmount;

   const nsRange* anchorFocusRange =

     mDomSelections[index]->GetAnchorFocusRange();

   if (anchorFocusRange) {

     mMaintainRange = anchorFocusRange->CloneRange();

     return NS_OK;

   }

   mMaintainRange = nullptr;

   return NS_OK;

 }

 /** After moving the caret, its Bidi level is set according to the following rules:

  *

  *  After moving over a character with left/right arrow, set to the Bidi level of the last moved over character.

  *  After Home and End, set to the paragraph embedding level.

  *  After up/down arrow, PageUp/Down, set to the lower level of the 2 surrounding characters.

  *  After mouse click, set to the level of the current frame.

  *

  *  The following two methods use GetPrevNextBidiLevels to determine the new Bidi level.

  *  BidiLevelFromMove is called when the caret is moved in response to a keyboard event

  *

  * @param aPresShell is the presentation shell

  * @param aNode is the content node

  * @param aContentOffset is the new caret position, as an offset into aNode

  * @param aKeycode is the keyboard event that moved the caret to the new position

  * @param aHint is the hint indicating in what logical direction the caret moved

  */

 void nsFrameSelection::BidiLevelFromMove(nsIPresShell* aPresShell,

                                          nsIContent   *aNode,

                                          uint32_t      aContentOffset,

                                          uint32_t      aKeycode,

                                          HINT          aHint)

 {

   switch (aKeycode) {

     // Right and Left: the new cursor Bidi level is the level of the character moved over

     case nsIDOMKeyEvent::DOM_VK_RIGHT:

     case nsIDOMKeyEvent::DOM_VK_LEFT:

     {

       nsPrevNextBidiLevels levels = GetPrevNextBidiLevels(aNode, aContentOffset,

                                                           aHint, false);

       if (HINTLEFT == aHint)

         SetCaretBidiLevel(levels.mLevelBefore);

       else

         SetCaretBidiLevel(levels.mLevelAfter);

       break;

     }

       /*

     // Up and Down: the new cursor Bidi level is the smaller of the two surrounding characters      

     case nsIDOMKeyEvent::DOM_VK_UP:

     case nsIDOMKeyEvent::DOM_VK_DOWN:

       GetPrevNextBidiLevels(aContext, aNode, aContentOffset, &firstFrame, &secondFrame, &firstLevel, &secondLevel);

       aPresShell->SetCaretBidiLevel(std::min(firstLevel, secondLevel));

       break;

       */

     default:

       UndefineCaretBidiLevel();

   }

 }

 /**

  * BidiLevelFromClick is called when the caret is repositioned by clicking the mouse

  *

  * @param aNode is the content node

  * @param aContentOffset is the new caret position, as an offset into aNode

  */

 void nsFrameSelection::BidiLevelFromClick(nsIContent *aNode,

                                           uint32_t    aContentOffset)

 {

   nsIFrame* clickInFrame=nullptr;

   int32_t OffsetNotUsed;

   clickInFrame = GetFrameForNodeOffset(aNode, aContentOffset, mHint, &OffsetNotUsed);

   if (!clickInFrame)

     return;

   SetCaretBidiLevel(NS_GET_EMBEDDING_LEVEL(clickInFrame));

 }

 bool

 nsFrameSelection::AdjustForMaintainedSelection(nsIContent *aContent,

                                                int32_t     aOffset)

 {

   if (!mMaintainRange)

     return false;

   if (!aContent) {

     return false;

   }

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return false;

   nsINode* rangeStartNode = mMaintainRange->GetStartParent();

   nsINode* rangeEndNode = mMaintainRange->GetEndParent();

   int32_t rangeStartOffset = mMaintainRange->StartOffset();

   int32_t rangeEndOffset = mMaintainRange->EndOffset();

   int32_t relToStart =

     nsContentUtils::ComparePoints(rangeStartNode, rangeStartOffset,

                                   aContent, aOffset);

   int32_t relToEnd =

     nsContentUtils::ComparePoints(rangeEndNode, rangeEndOffset,

                                   aContent, aOffset);

   // If aContent/aOffset is inside the maintained selection, or if it is on the

   // "anchor" side of the maintained selection, we need to do something.

   if ((relToStart < 0 && relToEnd > 0) ||

       (relToStart > 0 &&

        mDomSelections[index]->GetDirection() == eDirNext) ||

       (relToEnd < 0 &&

        mDomSelections[index]->GetDirection() == eDirPrevious)) {

     // Set the current range to the maintained range. 

     mDomSelections[index]->ReplaceAnchorFocusRange(mMaintainRange);

     if (relToStart < 0 && relToEnd > 0) {

       // We're inside the maintained selection, just keep it selected.

       return true;

     }

     // Reverse the direction of the selection so that the anchor will be on the 

     // far side of the maintained selection, relative to aContent/aOffset.

     mDomSelections[index]->SetDirection(relToStart > 0 ? eDirPrevious : eDirNext);

   }

   return false;

 }

 nsresult

 nsFrameSelection::HandleClick(nsIContent *aNewFocus,

                               uint32_t    aContentOffset,

                               uint32_t    aContentEndOffset,

                               bool        aContinueSelection, 

                               bool        aMultipleSelection,

                               bool        aHint) 

 {

   if (!aNewFocus)

     return NS_ERROR_INVALID_ARG;

   InvalidateDesiredX();

   if (!aContinueSelection) {

     mMaintainRange = nullptr;

     if (!IsValidSelectionPoint(this, aNewFocus)) {

       mAncestorLimiter = nullptr;

     }

   }

   // Don't take focus when dragging off of a table

   if (!mDragSelectingCells)

   {

     BidiLevelFromClick(aNewFocus, aContentOffset);

     PostReason(nsISelectionListener::MOUSEDOWN_REASON + nsISelectionListener::DRAG_REASON);

     if (aContinueSelection &&

         AdjustForMaintainedSelection(aNewFocus, aContentOffset))

       return NS_OK; //shift clicked to maintained selection. rejected.

     return TakeFocus(aNewFocus, aContentOffset, aContentEndOffset, HINT(aHint),

                      aContinueSelection, aMultipleSelection);

   }

   return NS_OK;

 }

 void

 nsFrameSelection::HandleDrag(nsIFrame *aFrame, nsPoint aPoint)

 {

   if (!aFrame || !mShell)

     return;

   nsresult result;

   nsIFrame *newFrame = 0;

   nsPoint   newPoint;

   result = ConstrainFrameAndPointToAnchorSubtree(aFrame, aPoint, &newFrame, newPoint);

   if (NS_FAILED(result))

     return;

   if (!newFrame)

     return;

   nsIFrame::ContentOffsets offsets =

       newFrame->GetContentOffsetsFromPoint(newPoint);

   if (!offsets.content)

     return;

   if (newFrame->IsSelected() &&

       AdjustForMaintainedSelection(offsets.content, offsets.offset))

     return;

   // Adjust offsets according to maintained amount

   if (mMaintainRange && 

       mMaintainedAmount != eSelectNoAmount) {    

     nsINode* rangenode = mMaintainRange->GetStartParent();

     int32_t rangeOffset = mMaintainRange->StartOffset();

     int32_t relativePosition =

       nsContentUtils::ComparePoints(rangenode, rangeOffset,

                                     offsets.content, offsets.offset);

     nsDirection direction = relativePosition > 0 ? eDirPrevious : eDirNext;

     nsSelectionAmount amount = mMaintainedAmount;

     if (amount == eSelectBeginLine && direction == eDirNext)

       amount = eSelectEndLine;

     int32_t offset;

     nsIFrame* frame = GetFrameForNodeOffset(offsets.content, offsets.offset, HINTRIGHT, &offset);

     if (frame && amount == eSelectWord && direction == eDirPrevious) {

       // To avoid selecting the previous word when at start of word,

       // first move one character forward.

       nsPeekOffsetStruct charPos(eSelectCharacter, eDirNext, offset, 0,

                                  false, mLimiter != nullptr, false, false);

       if (NS_SUCCEEDED(frame->PeekOffset(&charPos))) {

         frame = charPos.mResultFrame;

         offset = charPos.mContentOffset;

       }

     }

     nsPeekOffsetStruct pos(amount, direction, offset, 0,

                            false, mLimiter != nullptr, false, false);

     if (frame && NS_SUCCEEDED(frame->PeekOffset(&pos)) && pos.mResultContent) {

       offsets.content = pos.mResultContent;

       offsets.offset = pos.mContentOffset;

     }

   }

   HandleClick(offsets.content, offsets.offset, offsets.offset,

               true, false, offsets.associateWithNext);

 }

 nsresult

 nsFrameSelection::StartAutoScrollTimer(nsIFrame *aFrame,

                                        nsPoint   aPoint,

                                        uint32_t  aDelay)

 {

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   return mDomSelections[index]->StartAutoScrollTimer(aFrame, aPoint, aDelay);

 }

 void

 nsFrameSelection::StopAutoScrollTimer()

 {

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return;

   mDomSelections[index]->StopAutoScrollTimer();

 }

 /**

 hard to go from nodes to frames, easy the other way!

  */

 nsresult

 nsFrameSelection::TakeFocus(nsIContent *aNewFocus,

                             uint32_t    aContentOffset,

                             uint32_t    aContentEndOffset,

                             HINT        aHint,

                             bool        aContinueSelection,

                             bool        aMultipleSelection)

 {

   if (!aNewFocus)

     return NS_ERROR_NULL_POINTER;

   NS_ENSURE_STATE(mShell);

   if (!IsValidSelectionPoint(this,aNewFocus))

     return NS_ERROR_FAILURE;

   // Clear all table selection data

   mSelectingTableCellMode = 0;

   mDragSelectingCells = false;

   mStartSelectedCell = nullptr;

   mEndSelectedCell = nullptr;

   mAppendStartSelectedCell = nullptr;

   mHint = aHint;

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   //traverse through document and unselect crap here

   if (!aContinueSelection) {//single click? setting cursor down

     uint32_t batching = mBatching;//hack to use the collapse code.

     bool changes = mChangesDuringBatching;

     mBatching = 1;

     if (aMultipleSelection) {

       // Remove existing collapsed ranges as there's no point in having 

       // non-anchor/focus collapsed ranges.

       mDomSelections[index]->RemoveCollapsedRanges();

       nsRefPtr<nsRange> newRange = new nsRange(aNewFocus);

       newRange->SetStart(aNewFocus, aContentOffset);

       newRange->SetEnd(aNewFocus, aContentOffset);

       mDomSelections[index]->AddRange(newRange);

       mBatching = batching;

       mChangesDuringBatching = changes;

     }

     else

     {

       bool oldDesiredXSet = mDesiredXSet; //need to keep old desired X if it was set.

       mDomSelections[index]->Collapse(aNewFocus, aContentOffset);

       mDesiredXSet = oldDesiredXSet; //now reset desired X back.

       mBatching = batching;

       mChangesDuringBatching = changes;

     }

     if (aContentEndOffset != aContentOffset)

       mDomSelections[index]->Extend(aNewFocus, aContentEndOffset);

     //find out if we are inside a table. if so, find out which one and which cell

     //once we do that, the next time we get a takefocus, check the parent tree. 

     //if we are no longer inside same table ,cell then switch to table selection mode.

     // BUT only do this in an editor

     NS_ENSURE_STATE(mShell);

     int16_t displaySelection = mShell->GetSelectionFlags();

     // Editor has DISPLAY_ALL selection type

     if (displaySelection == nsISelectionDisplay::DISPLAY_ALL)

     {

       mCellParent = GetCellParent(aNewFocus);

 #ifdef DEBUG_TABLE_SELECTION

       if (mCellParent)

         printf(" * TakeFocus - Collapsing into new cell\n");

 #endif

     }

   }

   else {

     // Now update the range list:

     if (aContinueSelection && aNewFocus)

     {

       int32_t offset;

       nsINode *cellparent = GetCellParent(aNewFocus);

       if (mCellParent && cellparent && cellparent != mCellParent) //switch to cell selection mode

       {

 #ifdef DEBUG_TABLE_SELECTION

 printf(" * TakeFocus - moving into new cell\n");

 #endif

         WidgetMouseEvent event(false, 0, nullptr, WidgetMouseEvent::eReal);

         // Start selecting in the cell we were in before

         nsINode* parent = ParentOffset(mCellParent, &offset);

         if (parent)

           HandleTableSelection(parent, offset,

                                nsISelectionPrivate::TABLESELECTION_CELL, &event);

         // Find the parent of this new cell and extend selection to it

         parent = ParentOffset(cellparent, &offset);

         // XXXX We need to REALLY get the current key shift state

         //  (we'd need to add event listener -- let's not bother for now)

         event.modifiers &= ~MODIFIER_SHIFT; //aContinueSelection;

         if (parent)

         {

           mCellParent = cellparent;

           // Continue selection into next cell

           HandleTableSelection(parent, offset,

                                nsISelectionPrivate::TABLESELECTION_CELL, &event);

         }

       }

       else

       {

         // XXXX Problem: Shift+click in browser is appending text selection to selected table!!!

         //   is this the place to erase seleced cells ?????

         if (mDomSelections[index]->GetDirection() == eDirNext && aContentEndOffset > aContentOffset) //didn't go far enough 

         {

           mDomSelections[index]->Extend(aNewFocus, aContentEndOffset);//this will only redraw the diff 

         }

         else

           mDomSelections[index]->Extend(aNewFocus, aContentOffset);

       }

     }

   }

   // Don't notify selection listeners if batching is on:

   if (GetBatching())

     return NS_OK;

   return NotifySelectionListeners(nsISelectionController::SELECTION_NORMAL);

 }

 SelectionDetails*

 nsFrameSelection::LookUpSelection(nsIContent *aContent,

                                   int32_t aContentOffset,

                                   int32_t aContentLength,

                                   bool aSlowCheck) const

 {

   if (!aContent || !mShell)

     return nullptr;

   SelectionDetails* details = nullptr;

   for (int32_t j = 0; j < nsISelectionController::NUM_SELECTIONTYPES; j++) {

     if (mDomSelections[j]) {

       mDomSelections[j]->LookUpSelection(aContent, aContentOffset,

           aContentLength, &details, (SelectionType)(1<<j), aSlowCheck);

     }

   }

   return details;

 }

 void

 nsFrameSelection::SetMouseDownState(bool aState)

 {

   if (mMouseDownState == aState)

     return;

   mMouseDownState = aState;

   if (!mMouseDownState)

   {

     mDragSelectingCells = false;

     PostReason(nsISelectionListener::MOUSEUP_REASON);

     NotifySelectionListeners(nsISelectionController::SELECTION_NORMAL); //notify that reason is mouse up please.

   }

 }

 Selection*

 nsFrameSelection::GetSelection(SelectionType aType) const

 {

   int8_t index = GetIndexFromSelectionType(aType);

   if (index < 0)

     return nullptr;

   return mDomSelections[index];

 }

 nsresult

 nsFrameSelection::ScrollSelectionIntoView(SelectionType   aType,

                                           SelectionRegion aRegion,

                                           int16_t         aFlags) const

 {

   int8_t index = GetIndexFromSelectionType(aType);

   if (index < 0)

     return NS_ERROR_INVALID_ARG;

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   nsIPresShell::ScrollAxis verticalScroll = nsIPresShell::ScrollAxis();

   int32_t flags = Selection::SCROLL_DO_FLUSH;

   if (aFlags & nsISelectionController::SCROLL_SYNCHRONOUS) {

     flags |= Selection::SCROLL_SYNCHRONOUS;

   } else if (aFlags & nsISelectionController::SCROLL_FIRST_ANCESTOR_ONLY) {

     flags |= Selection::SCROLL_FIRST_ANCESTOR_ONLY;

   }

   if (aFlags & nsISelectionController::SCROLL_OVERFLOW_HIDDEN) {

     flags |= Selection::SCROLL_OVERFLOW_HIDDEN;

   }

   if (aFlags & nsISelectionController::SCROLL_CENTER_VERTICALLY) {

     verticalScroll = nsIPresShell::ScrollAxis(

       nsIPresShell::SCROLL_CENTER, nsIPresShell::SCROLL_IF_NOT_FULLY_VISIBLE);

   }

   // After ScrollSelectionIntoView(), the pending notifications might be

   // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.

   return mDomSelections[index]->ScrollIntoView(aRegion,

                                                verticalScroll,

                                                nsIPresShell::ScrollAxis(),

                                                flags);

 }

 nsresult

 nsFrameSelection::RepaintSelection(SelectionType aType) const

 {

   int8_t index = GetIndexFromSelectionType(aType);

   if (index < 0)

     return NS_ERROR_INVALID_ARG;

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   NS_ENSURE_STATE(mShell);

   return mDomSelections[index]->Repaint(mShell->GetPresContext());

 }

 nsIFrame*

 nsFrameSelection::GetFrameForNodeOffset(nsIContent *aNode,

                                         int32_t     aOffset,

                                         HINT        aHint,

                                         int32_t    *aReturnOffset) const

 {

   if (!aNode || !aReturnOffset || !mShell)

     return nullptr;

   if (aOffset < 0)

     return nullptr;

   *aReturnOffset = aOffset;

   nsCOMPtr<nsIContent> theNode = aNode;

   if (aNode->IsElement())

   {

     int32_t childIndex  = 0;

     int32_t numChildren = theNode->GetChildCount();

     if (aHint == HINTLEFT)

     {

       if (aOffset > 0)

         childIndex = aOffset - 1;

       else

         childIndex = aOffset;

     }

     else // HINTRIGHT

     {

       if (aOffset >= numChildren)

       {

         if (numChildren > 0)

           childIndex = numChildren - 1;

         else

           childIndex = 0;

       }

       else

         childIndex = aOffset;

     }

     if (childIndex > 0 || numChildren > 0) {

       nsCOMPtr<nsIContent> childNode = theNode->GetChildAt(childIndex);

       if (!childNode)

         return nullptr;

       theNode = childNode;

     }

 #ifdef DONT_DO_THIS_YET

     // XXX: We can't use this code yet because the hinting

     //      can cause us to attach to the wrong line frame.

     // Now that we have the child node, check if it too

     // can contain children. If so, call this method again!

     if (theNode->IsElement())

     {

       int32_t newOffset = 0;

       if (aOffset > childIndex)

       {

         numChildren = theNode->GetChildCount();

         newOffset = numChildren;

       }

       return GetFrameForNodeOffset(theNode, newOffset, aHint, aReturnOffset);

     }

     else

 #endif // DONT_DO_THIS_YET

     {

       // Check to see if theNode is a text node. If it is, translate

       // aOffset into an offset into the text node.

       nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(theNode);

       if (textNode)

       {

         if (theNode->GetPrimaryFrame())

         {

           if (aOffset > childIndex)

           {

             uint32_t textLength = 0;

             nsresult rv = textNode->GetLength(&textLength);

             if (NS_FAILED(rv))

               return nullptr;

             *aReturnOffset = (int32_t)textLength;

           }

           else

             *aReturnOffset = 0;

         }

         else

         {

           // If we're at a collapsed whitespace content node (which

           // does not have a primary frame), just use the original node

           // to get the frame on which we should put the caret.

           theNode = aNode;

         }

       }

     }

   }

   // If the node is a ShadowRoot, the frame needs to be adjusted,

   // because a ShadowRoot does not get a frame. Its children are rendered

   // as children of the host.

   mozilla::dom::ShadowRoot* shadowRoot =

     mozilla::dom::ShadowRoot::FromNode(theNode);

   if (shadowRoot) {

     theNode = shadowRoot->GetHost();

   }

   nsIFrame* returnFrame = theNode->GetPrimaryFrame();

   if (!returnFrame)

     return nullptr;

   // find the child frame containing the offset we want

   returnFrame->GetChildFrameContainingOffset(*aReturnOffset, aHint == HINTRIGHT,

                                              &aOffset, &returnFrame);

   return returnFrame;

 }

 void

 nsFrameSelection::CommonPageMove(bool aForward,

                                  bool aExtend,

                                  nsIScrollableFrame* aScrollableFrame)

 {

   // expected behavior for PageMove is to scroll AND move the caret

   // and remain relative position of the caret in view. see Bug 4302.

   //get the frame from the scrollable view

   nsIFrame* scrolledFrame = aScrollableFrame->GetScrolledFrame();

   if (!scrolledFrame)

     return;

   // find out where the caret is.

   // we should know mDesiredX value of nsFrameSelection, but I havent seen that behavior in other windows applications yet.

   nsISelection* domSel = GetSelection(nsISelectionController::SELECTION_NORMAL);

   if (!domSel) 

     return;

   nsRefPtr<nsCaret> caret = mShell->GetCaret();

   nsRect caretPos;

   nsIFrame* caretFrame = caret->GetGeometry(domSel, &caretPos);

   if (!caretFrame) 

     return;

   //need to adjust caret jump by percentage scroll

   nsSize scrollDelta = aScrollableFrame->GetPageScrollAmount();

   if (aForward)

     caretPos.y += scrollDelta.height;

   else

     caretPos.y -= scrollDelta.height;

   caretPos += caretFrame->GetOffsetTo(scrolledFrame);

   // get a content at desired location

   nsPoint desiredPoint;

   desiredPoint.x = caretPos.x;

   desiredPoint.y = caretPos.y + caretPos.height/2;

   nsIFrame::ContentOffsets offsets =

       scrolledFrame->GetContentOffsetsFromPoint(desiredPoint);

   if (!offsets.content)

     return;

   // scroll one page

   aScrollableFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),

                              nsIScrollableFrame::PAGES,

                              nsIScrollableFrame::SMOOTH);

   // place the caret

   HandleClick(offsets.content, offsets.offset,

               offsets.offset, aExtend, false, true);

 }

 nsresult

 nsFrameSelection::CharacterMove(bool aForward, bool aExtend)

 {

   if (aForward)

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_RIGHT, aExtend, eSelectCluster);

   else

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_LEFT, aExtend, eSelectCluster);

 }

 nsresult

 nsFrameSelection::CharacterExtendForDelete()

 {

   return MoveCaret(nsIDOMKeyEvent::DOM_VK_DELETE, true, eSelectCluster);

 }

 nsresult

 nsFrameSelection::CharacterExtendForBackspace()

 {

   return MoveCaret(nsIDOMKeyEvent::DOM_VK_BACK_SPACE, true, eSelectCharacter);

 }

 nsresult

 nsFrameSelection::WordMove(bool aForward, bool aExtend)

 {

   if (aForward)

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_RIGHT,aExtend,eSelectWord);

   else

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_LEFT,aExtend,eSelectWord);

 }

 nsresult

 nsFrameSelection::WordExtendForDelete(bool aForward)

 {

   if (aForward)

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_DELETE, true, eSelectWord);

   else

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_BACK_SPACE, true, eSelectWord);

 }

 nsresult

 nsFrameSelection::LineMove(bool aForward, bool aExtend)

 {

   if (aForward)

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_DOWN,aExtend,eSelectLine);

   else

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_UP,aExtend,eSelectLine);

 }

 nsresult

 nsFrameSelection::IntraLineMove(bool aForward, bool aExtend)

 {

   if (aForward)

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_END,aExtend,eSelectLine);

   else

     return MoveCaret(nsIDOMKeyEvent::DOM_VK_HOME,aExtend,eSelectLine);

 }

 nsresult

 nsFrameSelection::SelectAll()

 {

   nsCOMPtr<nsIContent> rootContent;

   if (mLimiter)

   {

     rootContent = mLimiter;//addrefit

   }

   else if (mAncestorLimiter) {

     rootContent = mAncestorLimiter;

   }

   else

   {

     NS_ENSURE_STATE(mShell);

     nsIDocument *doc = mShell->GetDocument();

     if (!doc)

       return NS_ERROR_FAILURE;

     rootContent = doc->GetRootElement();

     if (!rootContent)

       return NS_ERROR_FAILURE;

   }

   int32_t numChildren = rootContent->GetChildCount();

   PostReason(nsISelectionListener::NO_REASON);

   return TakeFocus(rootContent, 0, numChildren, HINTLEFT, false, false);

 }

 //////////END FRAMESELECTION

 void

 nsFrameSelection::StartBatchChanges()

 {

   mBatching++;

 }

 void

 nsFrameSelection::EndBatchChanges()

 {

   mBatching--;

   NS_ASSERTION(mBatching >=0,"Bad mBatching");

   if (mBatching == 0 && mChangesDuringBatching){

     mChangesDuringBatching = false;

     NotifySelectionListeners(nsISelectionController::SELECTION_NORMAL);

   }

 }

 nsresult

 nsFrameSelection::NotifySelectionListeners(SelectionType aType)

 {

   int8_t index = GetIndexFromSelectionType(aType);

   if (index >=0 && mDomSelections[index])

   {

     return mDomSelections[index]->NotifySelectionListeners();

   }

   return NS_ERROR_FAILURE;

 }

 // Start of Table Selection methods

 static bool IsCell(nsIContent *aContent)

 {

   return ((aContent->Tag() == nsGkAtoms::td ||

            aContent->Tag() == nsGkAtoms::th) &&

           aContent->IsHTML());

 }

 nsITableCellLayout* 

 nsFrameSelection::GetCellLayout(nsIContent *aCellContent) const

 {

   NS_ENSURE_TRUE(mShell, nullptr);

   nsITableCellLayout *cellLayoutObject =

     do_QueryFrame(aCellContent->GetPrimaryFrame());

   return cellLayoutObject;

 }

 nsresult

 nsFrameSelection::ClearNormalSelection()

 {

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   return mDomSelections[index]->RemoveAllRanges();

 }

 static nsIContent*

 GetFirstSelectedContent(nsRange* aRange)

 {

   if (!aRange) {

     return nullptr;

   }

   NS_PRECONDITION(aRange->GetStartParent(), "Must have start parent!");

   NS_PRECONDITION(aRange->GetStartParent()->IsElement(),

                   "Unexpected parent");

   return aRange->GetStartParent()->GetChildAt(aRange->StartOffset());

 }

 // Table selection support.

 // TODO: Separate table methods into a separate nsITableSelection interface

 nsresult

 nsFrameSelection::HandleTableSelection(nsINode* aParentContent,

                                        int32_t aContentOffset,

                                        int32_t aTarget,

                                        WidgetMouseEvent* aMouseEvent)

 {

   NS_ENSURE_TRUE(aParentContent, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(aMouseEvent, NS_ERROR_NULL_POINTER);

   if (mMouseDownState && mDragSelectingCells && (aTarget & nsISelectionPrivate::TABLESELECTION_TABLE))

   {

     // We were selecting cells and user drags mouse in table border or inbetween cells,

     //  just do nothing

       return NS_OK;

   }

   nsresult result = NS_OK;

   nsIContent *childContent = aParentContent->GetChildAt(aContentOffset);

   // When doing table selection, always set the direction to next so

   // we can be sure that anchorNode's offset always points to the

   // selected cell

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   mDomSelections[index]->SetDirection(eDirNext);

   // Stack-class to wrap all table selection changes in 

   //  BeginBatchChanges() / EndBatchChanges()

   nsSelectionBatcher selectionBatcher(mDomSelections[index]);

   int32_t startRowIndex, startColIndex, curRowIndex, curColIndex;

   if (mMouseDownState && mDragSelectingCells)

   {

     // We are drag-selecting

     if (aTarget != nsISelectionPrivate::TABLESELECTION_TABLE)

     {

       // If dragging in the same cell as last event, do nothing

       if (mEndSelectedCell == childContent)

         return NS_OK;

 #ifdef DEBUG_TABLE_SELECTION

 printf(" mStartSelectedCell = %x, mEndSelectedCell = %x, childContent = %x \n", mStartSelectedCell, mEndSelectedCell, childContent);

 #endif

       // aTarget can be any "cell mode",

       //  so we can easily drag-select rows and columns 

       // Once we are in row or column mode,

       //  we can drift into any cell to stay in that mode

       //  even if aTarget = TABLESELECTION_CELL

       if (mSelectingTableCellMode == nsISelectionPrivate::TABLESELECTION_ROW ||

           mSelectingTableCellMode == nsISelectionPrivate::TABLESELECTION_COLUMN)

       {

         if (mEndSelectedCell)

         {

           // Also check if cell is in same row/col

           result = GetCellIndexes(mEndSelectedCell, startRowIndex, startColIndex);

           if (NS_FAILED(result)) return result;

           result = GetCellIndexes(childContent, curRowIndex, curColIndex);

           if (NS_FAILED(result)) return result;

 #ifdef DEBUG_TABLE_SELECTION

 printf(" curRowIndex = %d, startRowIndex = %d, curColIndex = %d, startColIndex = %d\n", curRowIndex, startRowIndex, curColIndex, startColIndex);

 #endif

           if ((mSelectingTableCellMode == nsISelectionPrivate::TABLESELECTION_ROW && startRowIndex == curRowIndex) ||

               (mSelectingTableCellMode == nsISelectionPrivate::TABLESELECTION_COLUMN && startColIndex == curColIndex)) 

             return NS_OK;

         }

 #ifdef DEBUG_TABLE_SELECTION

 printf(" Dragged into a new column or row\n");

 #endif

         // Continue dragging row or column selection

         return SelectRowOrColumn(childContent, mSelectingTableCellMode);

       }

       else if (mSelectingTableCellMode == nsISelectionPrivate::TABLESELECTION_CELL)

       {

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Dragged into a new cell\n");

 #endif

         // Trick for quick selection of rows and columns

         // Hold down shift, then start selecting in one direction

         // If next cell dragged into is in same row, select entire row,

         //   if next cell is in same column, select entire column

         if (mStartSelectedCell && aMouseEvent->IsShift())

         {

           result = GetCellIndexes(mStartSelectedCell, startRowIndex, startColIndex);

           if (NS_FAILED(result)) return result;

           result = GetCellIndexes(childContent, curRowIndex, curColIndex);

           if (NS_FAILED(result)) return result;

           if (startRowIndex == curRowIndex || 

               startColIndex == curColIndex)

           {

             // Force new selection block

             mStartSelectedCell = nullptr;

             mDomSelections[index]->RemoveAllRanges();

             if (startRowIndex == curRowIndex)

               mSelectingTableCellMode = nsISelectionPrivate::TABLESELECTION_ROW;

             else

               mSelectingTableCellMode = nsISelectionPrivate::TABLESELECTION_COLUMN;

             return SelectRowOrColumn(childContent, mSelectingTableCellMode);

           }

         }

         // Reselect block of cells to new end location

         return SelectBlockOfCells(mStartSelectedCell, childContent);

       }

     }

     // Do nothing if dragging in table, but outside a cell

     return NS_OK;

   }

   else 

   {

     // Not dragging  -- mouse event is down or up

     if (mMouseDownState)

     {

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Mouse down event\n");

 #endif

       // Clear cell we stored in mouse-down

       mUnselectCellOnMouseUp = nullptr;

       if (aTarget == nsISelectionPrivate::TABLESELECTION_CELL)

       {

         bool isSelected = false;

         // Check if we have other selected cells

         nsIContent* previousCellNode =

           GetFirstSelectedContent(GetFirstCellRange());

         if (previousCellNode)

         {

           // We have at least 1 other selected cell

           // Check if new cell is already selected

           nsIFrame  *cellFrame = childContent->GetPrimaryFrame();

           if (!cellFrame) return NS_ERROR_NULL_POINTER;

           isSelected = cellFrame->IsSelected();

         }

         else

         {

           // No cells selected -- remove non-cell selection

           mDomSelections[index]->RemoveAllRanges();

         }

         mDragSelectingCells = true;    // Signal to start drag-cell-selection

         mSelectingTableCellMode = aTarget;

         // Set start for new drag-selection block (not appended)

         mStartSelectedCell = childContent;

         // The initial block end is same as the start

         mEndSelectedCell = childContent;

         if (isSelected)

         {

           // Remember this cell to (possibly) unselect it on mouseup

           mUnselectCellOnMouseUp = childContent;

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Saving mUnselectCellOnMouseUp\n");

 #endif

         }

         else

         {

           // Select an unselected cell

           // but first remove existing selection if not in same table

           if (previousCellNode &&

               !IsInSameTable(previousCellNode, childContent))

           {

             mDomSelections[index]->RemoveAllRanges();

             // Reset selection mode that is cleared in RemoveAllRanges

             mSelectingTableCellMode = aTarget;

           }

           return SelectCellElement(childContent);

         }

         return NS_OK;

       }

       else if (aTarget == nsISelectionPrivate::TABLESELECTION_TABLE)

       {

         //TODO: We currently select entire table when clicked between cells,

         //  should we restrict to only around border?

         //  *** How do we get location data for cell and click?

         mDragSelectingCells = false;

         mStartSelectedCell = nullptr;

         mEndSelectedCell = nullptr;

         // Remove existing selection and select the table

         mDomSelections[index]->RemoveAllRanges();

         return CreateAndAddRange(aParentContent, aContentOffset);

       }

       else if (aTarget == nsISelectionPrivate::TABLESELECTION_ROW || aTarget == nsISelectionPrivate::TABLESELECTION_COLUMN)

       {

 #ifdef DEBUG_TABLE_SELECTION

 printf("aTarget == %d\n", aTarget);

 #endif

         // Start drag-selecting mode so multiple rows/cols can be selected

         // Note: Currently, nsFrame::GetDataForTableSelection

         //       will never call us for row or column selection on mouse down

         mDragSelectingCells = true;

         // Force new selection block

         mStartSelectedCell = nullptr;

         mDomSelections[index]->RemoveAllRanges();

         // Always do this AFTER RemoveAllRanges

         mSelectingTableCellMode = aTarget;

         return SelectRowOrColumn(childContent, aTarget);

       }

     }

     else

     {

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Mouse UP event. mDragSelectingCells=%d, mStartSelectedCell=%d\n", mDragSelectingCells, mStartSelectedCell);

 #endif

       // First check if we are extending a block selection

       int32_t rangeCount;

       result = mDomSelections[index]->GetRangeCount(&rangeCount);

       if (NS_FAILED(result)) 

         return result;

       if (rangeCount > 0 && aMouseEvent->IsShift() && 

           mAppendStartSelectedCell && mAppendStartSelectedCell != childContent)

       {

         // Shift key is down: append a block selection

         mDragSelectingCells = false;

         return SelectBlockOfCells(mAppendStartSelectedCell, childContent);

       }

       if (mDragSelectingCells)

         mAppendStartSelectedCell = mStartSelectedCell;

       mDragSelectingCells = false;

       mStartSelectedCell = nullptr;

       mEndSelectedCell = nullptr;

       // Any other mouseup actions require that Ctrl or Cmd key is pressed

       //  else stop table selection mode

       bool doMouseUpAction = false;

 #ifdef XP_MACOSX

       doMouseUpAction = aMouseEvent->IsMeta();

 #else

       doMouseUpAction = aMouseEvent->IsControl();

 #endif

       if (!doMouseUpAction)

       {

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Ending cell selection on mouseup: mAppendStartSelectedCell=%d\n", mAppendStartSelectedCell);

 #endif

         return NS_OK;

       }

       // Unselect a cell only if it wasn't

       //  just selected on mousedown

       if( childContent == mUnselectCellOnMouseUp)

       {

         // Scan ranges to find the cell to unselect (the selection range to remove)

         // XXXbz it's really weird that this lives outside the loop, so once we

         // find one we keep looking at it even if we find no more cells...

         nsINode* previousCellParent = nullptr;

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Unselecting mUnselectCellOnMouseUp; rangeCount=%d\n", rangeCount);

 #endif

         for( int32_t i = 0; i < rangeCount; i++)

         {

           // Strong reference, because sometimes we want to remove

           // this range, and then we might be the only owner.

           nsRefPtr<nsRange> range = mDomSelections[index]->GetRangeAt(i);

           if (!range) return NS_ERROR_NULL_POINTER;

           nsINode* parent = range->GetStartParent();

           if (!parent) return NS_ERROR_NULL_POINTER;

           int32_t offset = range->StartOffset();

           // Be sure previous selection is a table cell

           nsIContent* child = parent->GetChildAt(offset);

           if (child && IsCell(child))

             previousCellParent = parent;

           // We're done if we didn't find parent of a previously-selected cell

           if (!previousCellParent) break;

           if (previousCellParent == aParentContent && offset == aContentOffset)

           {

             // Cell is already selected

             if (rangeCount == 1)

             {

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Unselecting single selected cell\n");

 #endif

               // This was the only cell selected.

               // Collapse to "normal" selection inside the cell

               mStartSelectedCell = nullptr;

               mEndSelectedCell = nullptr;

               mAppendStartSelectedCell = nullptr;

               //TODO: We need a "Collapse to just before deepest child" routine

               // Even better, should we collapse to just after the LAST deepest child

               //  (i.e., at the end of the cell's contents)?

               return mDomSelections[index]->Collapse(childContent, 0);

             }

 #ifdef DEBUG_TABLE_SELECTION

 printf("HandleTableSelection: Removing cell from multi-cell selection\n");

 #endif

             // Unselecting the start of previous block 

             // XXX What do we use now!

             if (childContent == mAppendStartSelectedCell)

                mAppendStartSelectedCell = nullptr;

             // Deselect cell by removing its range from selection

             return mDomSelections[index]->RemoveRange(range);

           }

         }

         mUnselectCellOnMouseUp = nullptr;

       }

     }

   }

   return result;

 }

 nsresult

 nsFrameSelection::SelectBlockOfCells(nsIContent *aStartCell, nsIContent *aEndCell)

 {

   NS_ENSURE_TRUE(aStartCell, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(aEndCell, NS_ERROR_NULL_POINTER);

   mEndSelectedCell = aEndCell;

   nsCOMPtr<nsIContent> startCell;

   nsresult result = NS_OK;

   // If new end cell is in a different table, do nothing

   nsIContent* table = IsInSameTable(aStartCell, aEndCell);

   if (!table) {

     return NS_OK;

   }

   // Get starting and ending cells' location in the cellmap

   int32_t startRowIndex, startColIndex, endRowIndex, endColIndex;

   result = GetCellIndexes(aStartCell, startRowIndex, startColIndex);

   if(NS_FAILED(result)) return result;

   result = GetCellIndexes(aEndCell, endRowIndex, endColIndex);

   if(NS_FAILED(result)) return result;

   if (mDragSelectingCells)

   {

     // Drag selecting: remove selected cells outside of new block limits

     UnselectCells(table, startRowIndex, startColIndex, endRowIndex, endColIndex,

                   true);

   }

   // Note that we select block in the direction of user's mouse dragging,

   //  which means start cell may be after the end cell in either row or column

   return AddCellsToSelection(table, startRowIndex, startColIndex,

                              endRowIndex, endColIndex);

 }

 nsresult

 nsFrameSelection::UnselectCells(nsIContent *aTableContent,

                                 int32_t aStartRowIndex,

                                 int32_t aStartColumnIndex,

                                 int32_t aEndRowIndex,

                                 int32_t aEndColumnIndex,

                                 bool aRemoveOutsideOfCellRange)

 {

   int8_t index =

     GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   nsTableOuterFrame* tableFrame = do_QueryFrame(aTableContent->GetPrimaryFrame());

   if (!tableFrame)

     return NS_ERROR_FAILURE;

   int32_t minRowIndex = std::min(aStartRowIndex, aEndRowIndex);

   int32_t maxRowIndex = std::max(aStartRowIndex, aEndRowIndex);

   int32_t minColIndex = std::min(aStartColumnIndex, aEndColumnIndex);

   int32_t maxColIndex = std::max(aStartColumnIndex, aEndColumnIndex);

   // Strong reference because we sometimes remove the range

   nsRefPtr<nsRange> range = GetFirstCellRange();

   nsIContent* cellNode = GetFirstSelectedContent(range);

   NS_PRECONDITION(!range || cellNode, "Must have cellNode if had a range");

   int32_t curRowIndex, curColIndex;

   while (cellNode)

   {

     nsresult result = GetCellIndexes(cellNode, curRowIndex, curColIndex);

     if (NS_FAILED(result))

       return result;

 #ifdef DEBUG_TABLE_SELECTION

     if (!range)

       printf("RemoveCellsToSelection -- range is null\n");

 #endif

     if (range) {

       if (aRemoveOutsideOfCellRange) {

         if (curRowIndex < minRowIndex || curRowIndex > maxRowIndex || 

             curColIndex < minColIndex || curColIndex > maxColIndex) {

           mDomSelections[index]->RemoveRange(range);

           // Since we've removed the range, decrement pointer to next range

           mSelectedCellIndex--;

         }

       } else {

         // Remove cell from selection if it belongs to the given cells range or

         // it is spanned onto the cells range.

         nsTableCellFrame* cellFrame =

           tableFrame->GetCellFrameAt(curRowIndex, curColIndex);

         int32_t origRowIndex, origColIndex;

         cellFrame->GetRowIndex(origRowIndex);

         cellFrame->GetColIndex(origColIndex);

         uint32_t actualRowSpan =

           tableFrame->GetEffectiveRowSpanAt(origRowIndex, origColIndex);

         uint32_t actualColSpan =

           tableFrame->GetEffectiveColSpanAt(curRowIndex, curColIndex);

         if (origRowIndex <= maxRowIndex && maxRowIndex >= 0 &&

             origRowIndex + actualRowSpan - 1 >= static_cast<uint32_t>(minRowIndex) &&

             origColIndex <= maxColIndex && maxColIndex >= 0 &&

             origColIndex + actualColSpan - 1 >= static_cast<uint32_t>(minColIndex)) {

           mDomSelections[index]->RemoveRange(range);

           // Since we've removed the range, decrement pointer to next range

           mSelectedCellIndex--;

         }

       }

     }

     range = GetNextCellRange();

     cellNode = GetFirstSelectedContent(range);

     NS_PRECONDITION(!range || cellNode, "Must have cellNode if had a range");

   }

   return NS_OK;

 }

 nsresult

 nsFrameSelection::AddCellsToSelection(nsIContent *aTableContent,

                                       int32_t aStartRowIndex,

                                       int32_t aStartColumnIndex,

                                       int32_t aEndRowIndex,

                                       int32_t aEndColumnIndex)

 {

   int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);

   if (!mDomSelections[index])

     return NS_ERROR_NULL_POINTER;

   nsTableOuterFrame* tableFrame = do_QueryFrame(aTableContent->GetPrimaryFrame());

   if (!tableFrame) // Check that |table| is a table.

     return NS_ERROR_FAILURE;

   nsresult result = NS_OK;

   int32_t row = aStartRowIndex;

   while(true)

   {

     int32_t col = aStartColumnIndex;

     while(true)

     {

       nsTableCellFrame* cellFrame = tableFrame->GetCellFrameAt(row, col);

       // Skip cells that are spanned from previous locations or are already selected

       if (cellFrame) {

         int32_t origRow, origCol;

         cellFrame->GetRowIndex(origRow);

         cellFrame->GetColIndex(origCol);

         if (origRow == row && origCol == col && !cellFrame->IsSelected()) {

           result = SelectCellElement(cellFrame->GetContent());

           if (NS_FAILED(result)) return result;

         }

       }

       // Done when we reach end column

       if (col == aEndColumnIndex) break;

       if (aStartColumnIndex < aEndColumnIndex)

         col ++;

       else

         col--;

     };

     if (row == aEndRowIndex) break;

     if (aStartRowIndex < aEndRowIndex)

       row++;

     else

       row--;

   };

   return result;

 }

 nsresult

 nsFrameSelection::RemoveCellsFromSelection(nsIContent *aTable,

                                            int32_t aStartRowIndex,

                                            int32_t aStartColumnIndex,

                                            int32_t aEndRowIndex,

                                            int32_t aEndColumnIndex)

 {

   return UnselectCells(aTable, aStartRowIndex, aStartColumnIndex,

                        aEndRowIndex, aEndColumnIndex, false);

 }

 nsresult

 nsFrameSelection::RestrictCellsToSelection(nsIContent *aTable,

                                            int32_t aStartRowIndex,

                                            int32_t aStartColumnIndex,

                                            int32_t aEndRowIndex,

                                            int32_t aEndColumnIndex)

 {

   return UnselectCells(aTable, aStartRowIndex, aStartColumnIndex,

                        aEndRowIndex, aEndColumnIndex, true);

 }

 nsresult

 nsFrameSelection::SelectRowOrColumn(nsIContent *aCellContent, uint32_t aTarget)

 {

   if (!aCellContent) return NS_ERROR_NULL_POINTER;

   nsIContent* table = GetParentTable(aCellContent);

   if (!table) return NS_ERROR_NULL_POINTER;

   // Get table and cell layout interfaces to access 

   //   cell data based on cellmap location

   // Frames are not ref counted, so don't use an nsCOMPtr

   nsTableOuterFrame* tableFrame = do_QueryFrame(table->GetPrimaryFrame());

   if (!tableFrame) return NS_ERROR_FAILURE;

   nsITableCellLayout *cellLayout = GetCellLayout(aCellContent);

   if (!cellLayout) return NS_ERROR_FAILURE;

   // Get location of target cell:      

   int32_t rowIndex, colIndex;

   nsresult result = cellLayout->GetCellIndexes(rowIndex, colIndex);

   if (NS_FAILED(result)) return result;

   // Be sure we start at proper beginning

   // (This allows us to select row or col given ANY cell!)

   if (aTarget == nsISelectionPrivate::TABLESELECTION_ROW)

     colIndex = 0;

   if (aTarget == nsISelectionPrivate::TABLESELECTION_COLUMN)

     rowIndex = 0;

   nsCOMPtr<nsIContent> firstCell, lastCell;

   while (true) {

     // Loop through all cells in column or row to find first and last

     nsCOMPtr<nsIContent> curCellContent =

       tableFrame->GetCellAt(rowIndex, colIndex);

     if (!curCellContent)

       break;

     if (!firstCell)

       firstCell = curCellContent;

     lastCell = curCellContent.forget();

     // Move to next cell in cellmap, skipping spanned locations

     if (aTarget == nsISelectionPrivate::TABLESELECTION_ROW)

       colIndex += tableFrame->GetEffectiveRowSpanAt(rowIndex, colIndex);

     else

       rowIndex += tableFrame->GetEffectiveRowSpanAt(rowIndex, colIndex);

   }

   // Use SelectBlockOfCells:

   // This will replace existing selection,

   //  but allow unselecting by dragging out of selected region

   if (firstCell && lastCell)

   {

     if (!mStartSelectedCell)

     {

       // We are starting a new block, so select the first cell

       result = SelectCellElement(firstCell);

       if (NS_FAILED(result)) return result;

       mStartSelectedCell = firstCell;

     }

     nsCOMPtr<nsIContent> lastCellContent = do_QueryInterface(lastCell);

     result = SelectBlockOfCells(mStartSelectedCell, lastCellContent);

     // This gets set to the cell at end of row/col, 

     //   but we need it to be the cell under cursor

     mEndSelectedCell = aCellContent;

     return result;

   }

 #if 0

 // This is a more efficient strategy that appends row to current selection,

 //  but doesn't allow dragging OFF of an existing selection to unselect!

   do {

     // Loop through all cells in column or row

     result = tableLayout->GetCellDataAt(rowIndex, colIndex,

                                         getter_AddRefs(cellElement),

                                         curRowIndex, curColIndex,

                                         rowSpan, colSpan,

                                         actualRowSpan, actualColSpan,

                                         isSelected);

     if (NS_FAILED(result)) return result;

     // We're done when cell is not found

     if (!cellElement) break;

     // Check spans else we infinitely loop

     NS_ASSERTION(actualColSpan, "actualColSpan is 0!");

     NS_ASSERTION(actualRowSpan, "actualRowSpan is 0!");

     // Skip cells that are already selected or span from outside our region

     if (!isSelected && rowIndex == curRowIndex && colIndex == curColIndex)

     {

       result = SelectCellElement(cellElement);

       if (NS_FAILED(result)) return result;

     }

     // Move to next row or column in cellmap, skipping spanned locations

     if (aTarget == nsISelectionPrivate::TABLESELECTION_ROW)

       colIndex += actualColSpan;

     else

       rowIndex += actualRowSpan;

   }

   while (cellElement);

 #endif

   return NS_OK;

 }