The Tor Browser: comparison layout/generic/nsSelection.cpp

--1:000000000000
+:7067b6134963
+/* -*- 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;
+}
+nsIContent*
+nsFrameSelection::GetFirstCellNodeInRange(nsRange *aRange) const
+{
+if (!aRange) return nullptr;
+nsINode* startParent = aRange->GetStartParent();
+if (!startParent)
+return nullptr;
+int32_t offset = aRange->StartOffset();
+nsIContent* childContent = startParent->GetChildAt(offset);
+if (!childContent)
+return nullptr;
+// Don't return node if not a cell
+if (!IsCell(childContent))
+return nullptr;
+return childContent;
+}
+nsRange*
+nsFrameSelection::GetFirstCellRange()
+{
+int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
+if (!mDomSelections[index])
+return nullptr;
+nsRange* firstRange = mDomSelections[index]->GetRangeAt(0);
+if (!GetFirstCellNodeInRange(firstRange)) {
+return nullptr;
+}
+// Setup for next cell
+mSelectedCellIndex = 1;
+return firstRange;
+}
+nsRange*
+nsFrameSelection::GetNextCellRange()
+{
+int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
+if (!mDomSelections[index])
+return nullptr;
+nsRange* range = mDomSelections[index]->GetRangeAt(mSelectedCellIndex);
+// Get first node in next range of selection - test if it's a cell
+if (!GetFirstCellNodeInRange(range)) {
+return nullptr;
+}
+// Setup for next cell
+mSelectedCellIndex++;
+return range;
+}
+nsresult
+nsFrameSelection::GetCellIndexes(nsIContent *aCell,
+int32_t    &aRowIndex,
+int32_t    &aColIndex)
+{
+if (!aCell) return NS_ERROR_NULL_POINTER;
+aColIndex=0; // initialize out params
+aRowIndex=0;
+nsITableCellLayout *cellLayoutObject = GetCellLayout(aCell);
+if (!cellLayoutObject)  return NS_ERROR_FAILURE;
+return cellLayoutObject->GetCellIndexes(aRowIndex, aColIndex);
+}
+nsIContent*
+nsFrameSelection::IsInSameTable(nsIContent  *aContent1,
+nsIContent  *aContent2) const
+{
+if (!aContent1 || !aContent2) return nullptr;
+nsIContent* tableNode1 = GetParentTable(aContent1);
+nsIContent* tableNode2 = GetParentTable(aContent2);
+// Must be in the same table.  Note that we want to return false for
+// the test if both tables are null.
+return (tableNode1 == tableNode2) ? tableNode1 : nullptr;
+}
+nsIContent*
+nsFrameSelection::GetParentTable(nsIContent *aCell) const
+{
+if (!aCell) {
+return nullptr;
+}
+for (nsIContent* parent = aCell->GetParent(); parent;
+parent = parent->GetParent()) {
+if (parent->Tag() == nsGkAtoms::table &&
+parent->IsHTML()) {
+return parent;
+}
+}
+return nullptr;
+}
+nsresult
+nsFrameSelection::SelectCellElement(nsIContent *aCellElement)
+{
+nsIContent *parent = aCellElement->GetParent();
+// Get child offset
+int32_t offset = parent->IndexOf(aCellElement);
+return CreateAndAddRange(parent, offset);
+}
+nsresult
+Selection::getTableCellLocationFromRange(nsRange* aRange,
+int32_t* aSelectionType,
+int32_t* aRow, int32_t* aCol)
+{
+if (!aRange || !aSelectionType || !aRow || !aCol)
+return NS_ERROR_NULL_POINTER;
+*aSelectionType = nsISelectionPrivate::TABLESELECTION_NONE;
+*aRow = 0;
+*aCol = 0;
+// Must have access to frame selection to get cell info
+if (!mFrameSelection) return NS_OK;
+nsresult result = GetTableSelectionType(aRange, aSelectionType);
+if (NS_FAILED(result)) return result;
+// Don't fail if range does not point to a single table cell,
+//  let aSelectionType tell user if we don't have a cell
+if (*aSelectionType  != nsISelectionPrivate::TABLESELECTION_CELL)
+return NS_OK;
+// Get the child content (the cell) pointed to by starting node of range
+// We do minimal checking since GetTableSelectionType assures
+//   us that this really is a table cell
+nsCOMPtr<nsIContent> content = do_QueryInterface(aRange->GetStartParent());
+if (!content)
+return NS_ERROR_FAILURE;
+nsIContent *child = content->GetChildAt(aRange->StartOffset());
+if (!child)
+return NS_ERROR_FAILURE;
+//Note: This is a non-ref-counted pointer to the frame
+nsITableCellLayout *cellLayout = mFrameSelection->GetCellLayout(child);
+if (NS_FAILED(result))
+return result;
+if (!cellLayout)
+return NS_ERROR_FAILURE;
+return cellLayout->GetCellIndexes(*aRow, *aCol);
+}
+nsresult
+Selection::addTableCellRange(nsRange* aRange, bool* aDidAddRange,
+int32_t* aOutIndex)
+{
+if (!aDidAddRange || !aOutIndex)
+return NS_ERROR_NULL_POINTER;
+*aDidAddRange = false;
+*aOutIndex = -1;
+if (!mFrameSelection)
+return NS_OK;
+if (!aRange)
+return NS_ERROR_NULL_POINTER;
+nsresult result;
+// Get if we are adding a cell selection and the row, col of cell if we are
+int32_t newRow, newCol, tableMode;
+result = getTableCellLocationFromRange(aRange, &tableMode, &newRow, &newCol);
+if (NS_FAILED(result)) return result;
+// If not adding a cell range, we are done here
+if (tableMode != nsISelectionPrivate::TABLESELECTION_CELL)
+{
+mFrameSelection->mSelectingTableCellMode = tableMode;
+// Don't fail if range isn't a selected cell, aDidAddRange tells caller if we didn't proceed
+return NS_OK;
+}
+// Set frame selection mode only if not already set to a table mode
+//  so we don't lose the select row and column flags (not detected by getTableCellLocation)
+if (mFrameSelection->mSelectingTableCellMode == TABLESELECTION_NONE)
+mFrameSelection->mSelectingTableCellMode = tableMode;
+*aDidAddRange = true;
+return AddItem(aRange, aOutIndex);
+}
+//TODO: Figure out TABLESELECTION_COLUMN and TABLESELECTION_ALLCELLS
+nsresult
+Selection::GetTableSelectionType(nsIDOMRange* aDOMRange,
+int32_t* aTableSelectionType)
+{
+if (!aDOMRange || !aTableSelectionType)
+return NS_ERROR_NULL_POINTER;
+nsRange* range = static_cast<nsRange*>(aDOMRange);
+*aTableSelectionType = nsISelectionPrivate::TABLESELECTION_NONE;
+// Must have access to frame selection to get cell info
+if(!mFrameSelection) return NS_OK;
+nsINode* startNode = range->GetStartParent();
+if (!startNode) return NS_ERROR_FAILURE;
+nsINode* endNode = range->GetEndParent();
+if (!endNode) return NS_ERROR_FAILURE;
+// Not a single selected node
+if (startNode != endNode) return NS_OK;
+int32_t startOffset = range->StartOffset();
+int32_t endOffset = range->EndOffset();
+// Not a single selected node
+if ((endOffset - startOffset) != 1)
+return NS_OK;
+nsIContent* startContent = static_cast<nsIContent*>(startNode);
+if (!(startNode->IsElement() && startContent->IsHTML())) {
+// Implies a check for being an element; if we ever make this work
+// for non-HTML, need to keep checking for elements.
+return NS_OK;
+}
+nsIAtom *tag = startContent->Tag();
+if (tag == nsGkAtoms::tr)
+{
+*aTableSelectionType = nsISelectionPrivate::TABLESELECTION_CELL;
+}
+else //check to see if we are selecting a table or row (column and all cells not done yet)
+{
+nsIContent *child = startNode->GetChildAt(startOffset);
+if (!child)
+return NS_ERROR_FAILURE;
+tag = child->Tag();
+if (tag == nsGkAtoms::table)
+*aTableSelectionType = nsISelectionPrivate::TABLESELECTION_TABLE;
+else if (tag == nsGkAtoms::tr)
+*aTableSelectionType = nsISelectionPrivate::TABLESELECTION_ROW;
+}
+return NS_OK;
+}
+nsresult
+nsFrameSelection::CreateAndAddRange(nsINode *aParentNode, int32_t aOffset)
+{
+if (!aParentNode) return NS_ERROR_NULL_POINTER;
+nsRefPtr<nsRange> range = new nsRange(aParentNode);
+// Set range around child at given offset
+nsresult result = range->SetStart(aParentNode, aOffset);
+if (NS_FAILED(result)) return result;
+result = range->SetEnd(aParentNode, aOffset+1);
+if (NS_FAILED(result)) return result;
+int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
+if (!mDomSelections[index])
+return NS_ERROR_NULL_POINTER;
+return mDomSelections[index]->AddRange(range);
+}
+// End of Table Selection
+void
+nsFrameSelection::SetAncestorLimiter(nsIContent *aLimiter)
+{
+if (mAncestorLimiter != aLimiter) {
+mAncestorLimiter = aLimiter;
+int8_t index =
+GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
+if (!mDomSelections[index])
+return;
+if (!IsValidSelectionPoint(this, mDomSelections[index]->GetFocusNode())) {
+ClearNormalSelection();
+if (mAncestorLimiter) {
+PostReason(nsISelectionListener::NO_REASON);
+TakeFocus(mAncestorLimiter, 0, 0, HINTLEFT, false, false);
+}
+}
+}
+}
+//END nsFrameSelection methods
+//BEGIN nsISelection interface implementations
+nsresult
+nsFrameSelection::DeleteFromDocument()
+{
+nsresult res;
+// If we're already collapsed, then we do nothing (bug 719503).
+bool isCollapsed;
+int8_t index = GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
+if (!mDomSelections[index])
+return NS_ERROR_NULL_POINTER;
+mDomSelections[index]->GetIsCollapsed( &isCollapsed);
+if (isCollapsed)
+{
+return NS_OK;
+}
+nsRefPtr<Selection> selection = mDomSelections[index];
+for (int32_t rangeIdx = 0; rangeIdx < selection->GetRangeCount(); ++rangeIdx) {
+nsRefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
+res = range->DeleteContents();
+if (NS_FAILED(res))
+return res;
+}
+// Collapse to the new location.
+// If we deleted one character, then we move back one element.
+// FIXME  We don't know how to do this past frame boundaries yet.
+if (isCollapsed)
+mDomSelections[index]->Collapse(mDomSelections[index]->GetAnchorNode(), mDomSelections[index]->AnchorOffset()-1);
+else if (mDomSelections[index]->AnchorOffset() > 0)
+mDomSelections[index]->Collapse(mDomSelections[index]->GetAnchorNode(), mDomSelections[index]->AnchorOffset());
+#ifdef DEBUG
+else
+printf("Don't know how to set selection back past frame boundary\n");
+#endif
+return NS_OK;
+}
+void
+nsFrameSelection::SetDelayedCaretData(WidgetMouseEvent* aMouseEvent)
+{
+if (aMouseEvent) {
+mDelayedMouseEventValid = true;
+mDelayedMouseEventIsShift = aMouseEvent->IsShift();
+mDelayedMouseEventClickCount = aMouseEvent->clickCount;
+} else {
+mDelayedMouseEventValid = false;
+}
+}
+void
+nsFrameSelection::DisconnectFromPresShell()
+{
+StopAutoScrollTimer();
+for (int32_t i = 0; i < nsISelectionController::NUM_SELECTIONTYPES; i++) {
+mDomSelections[i]->Clear(nullptr);
+}
+mShell = nullptr;
+}
+//END nsISelection interface implementations
+#if 0
+#pragma mark -
+#endif
+// mozilla::dom::Selection implementation
+// note: this can return a nil anchor node
+Selection::Selection()
+: mCachedOffsetForFrame(nullptr)
+, mDirection(eDirNext)
+, mType(nsISelectionController::SELECTION_NORMAL)
+{
+SetIsDOMBinding();
+}
+Selection::Selection(nsFrameSelection* aList)
+: mFrameSelection(aList)
+, mCachedOffsetForFrame(nullptr)
+, mDirection(eDirNext)
+, mType(nsISelectionController::SELECTION_NORMAL)
+{
+SetIsDOMBinding();
+}
+Selection::~Selection()
+{
+setAnchorFocusRange(-1);
+uint32_t count = mRanges.Length();
+for (uint32_t i = 0; i < count; ++i) {
+mRanges[i].mRange->SetInSelection(false);
+}
+if (mAutoScrollTimer) {
+mAutoScrollTimer->Stop();
+mAutoScrollTimer = nullptr;
+}
+mScrollEvent.Revoke();
+if (mCachedOffsetForFrame) {
+delete mCachedOffsetForFrame;
+mCachedOffsetForFrame = nullptr;
+}
+}
+nsIDocument*
+Selection::GetParentObject() const
+{
+nsIPresShell* shell = GetPresShell();
+if (shell) {
+return shell->GetDocument();
+}
+return nullptr;
+}
+NS_IMPL_CYCLE_COLLECTION_CLASS(Selection)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Selection)
+// Unlink the selection listeners *before* we do RemoveAllRanges since
+// we don't want to notify the listeners during JS GC (they could be
+// in JS!).
+NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelectionListeners)
+tmp->RemoveAllRanges();
+NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameSelection)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Selection)
+{
+uint32_t i, count = tmp->mRanges.Length();
+for (i = 0; i < count; ++i) {
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRanges[i].mRange)
+}
+}
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAnchorFocusRange)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameSelection)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectionListeners)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(Selection)
+DOMCI_DATA(Selection, Selection)
+// QueryInterface implementation for Selection
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Selection)
+NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+NS_INTERFACE_MAP_ENTRY(nsISelection)
+NS_INTERFACE_MAP_ENTRY(nsISelectionPrivate)
+NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsISelection)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Selection)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Selection)
+NS_IMETHODIMP
+Selection::GetAnchorNode(nsIDOMNode** aAnchorNode)
+{
+nsINode* anchorNode = GetAnchorNode();
+if (anchorNode) {
+return CallQueryInterface(anchorNode, aAnchorNode);
+}
+*aAnchorNode = nullptr;
+return NS_OK;
+}
+nsINode*
+Selection::GetAnchorNode()
+{
+if (!mAnchorFocusRange)
+return nullptr;
+if (GetDirection() == eDirNext) {
+return mAnchorFocusRange->GetStartParent();
+}
+return mAnchorFocusRange->GetEndParent();
+}
+NS_IMETHODIMP
+Selection::GetAnchorOffset(int32_t* aAnchorOffset)
+{
+*aAnchorOffset = static_cast<int32_t>(AnchorOffset());
+return NS_OK;
+}
+// note: this can return a nil focus node
+NS_IMETHODIMP
+Selection::GetFocusNode(nsIDOMNode** aFocusNode)
+{
+nsINode* focusNode = GetFocusNode();
+if (focusNode) {
+return CallQueryInterface(focusNode, aFocusNode);
+}
+*aFocusNode = nullptr;
+return NS_OK;
+}
+nsINode*
+Selection::GetFocusNode()
+{
+if (!mAnchorFocusRange)
+return nullptr;
+if (GetDirection() == eDirNext){
+return mAnchorFocusRange->GetEndParent();
+}
+return mAnchorFocusRange->GetStartParent();
+}
+NS_IMETHODIMP
+Selection::GetFocusOffset(int32_t* aFocusOffset)
+{
+*aFocusOffset = static_cast<int32_t>(FocusOffset());
+return NS_OK;
+}
+void
+Selection::setAnchorFocusRange(int32_t indx)
+{
+if (indx >= (int32_t)mRanges.Length())
+return;
+if (indx < 0) //release all
+{
+mAnchorFocusRange = nullptr;
+}
+else{
+mAnchorFocusRange = mRanges[indx].mRange;
+}
+}
+uint32_t
+Selection::AnchorOffset()
+{
+if (!mAnchorFocusRange)
+return 0;
+if (GetDirection() == eDirNext){
+return mAnchorFocusRange->StartOffset();
+}
+return mAnchorFocusRange->EndOffset();
+}
+uint32_t
+Selection::FocusOffset()
+{
+if (!mAnchorFocusRange)
+return 0;
+if (GetDirection() == eDirNext){
+return mAnchorFocusRange->EndOffset();
+}
+return mAnchorFocusRange->StartOffset();
+}
+static nsresult
+CompareToRangeStart(nsINode* aCompareNode, int32_t aCompareOffset,
+nsRange* aRange, int32_t* aCmp)
+{
+nsINode* start = aRange->GetStartParent();
+NS_ENSURE_STATE(aCompareNode && start);
+// If the nodes that we're comparing are not in the same document,
+// assume that aCompareNode will fall at the end of the ranges.
+if (aCompareNode->GetCurrentDoc() != start->GetCurrentDoc() ||
+!start->GetCurrentDoc()) {
+*aCmp = 1;
+} else {
+*aCmp = nsContentUtils::ComparePoints(aCompareNode, aCompareOffset,
+start, aRange->StartOffset());
+}
+return NS_OK;
+}
+static nsresult
+CompareToRangeEnd(nsINode* aCompareNode, int32_t aCompareOffset,
+nsRange* aRange, int32_t* aCmp)
+{
+nsINode* end = aRange->GetEndParent();
+NS_ENSURE_STATE(aCompareNode && end);
+// If the nodes that we're comparing are not in the same document,
+// assume that aCompareNode will fall at the end of the ranges.
+if (aCompareNode->GetCurrentDoc() != end->GetCurrentDoc() ||
+!end->GetCurrentDoc()) {
+*aCmp = 1;
+} else {
+*aCmp = nsContentUtils::ComparePoints(aCompareNode, aCompareOffset,
+end, aRange->EndOffset());
+}
+return NS_OK;
+}
+// Selection::FindInsertionPoint
+//
+//    Binary searches the given sorted array of ranges for the insertion point
+//    for the given node/offset. The given comparator is used, and the index
+//    where the point should appear in the array is placed in *aInsertionPoint.
+//
+//    If there is an item in the array equal to the input point, we will return
+//    the index of this item.
+nsresult
+Selection::FindInsertionPoint(
+nsTArray<RangeData>* aElementArray,
+nsINode* aPointNode, int32_t aPointOffset,
+nsresult (*aComparator)(nsINode*,int32_t,nsRange*,int32_t*),
+int32_t* aPoint)
+{
+*aPoint = 0;
+int32_t beginSearch = 0;
+int32_t endSearch = aElementArray->Length(); // one beyond what to check
+if (endSearch) {
+int32_t center = endSearch - 1; // Check last index, then binary search
+do {
+nsRange* range = (*aElementArray)[center].mRange;
+int32_t cmp;
+nsresult rv = aComparator(aPointNode, aPointOffset, range, &cmp);
+NS_ENSURE_SUCCESS(rv, rv);
+if (cmp < 0) {        // point < cur
+endSearch = center;
+} else if (cmp > 0) { // point > cur
+beginSearch = center + 1;
+} else {              // found match, done
+beginSearch = center;
+break;
+}
+center = (endSearch - beginSearch) / 2 + beginSearch;
+} while (endSearch - beginSearch > 0);
+}
+*aPoint = beginSearch;
+return NS_OK;
+}
+// Selection::SubtractRange
+//
+//    A helper function that subtracts aSubtract from aRange, and adds
+//    1 or 2 RangeData objects representing the remaining non-overlapping
+//    difference to aOutput. It is assumed that the caller has checked that
+//    aRange and aSubtract do indeed overlap
+nsresult
+Selection::SubtractRange(RangeData* aRange, nsRange* aSubtract,
+nsTArray<RangeData>* aOutput)
+{
+nsRange* range = aRange->mRange;
+// First we want to compare to the range start
+int32_t cmp;
+nsresult rv = CompareToRangeStart(range->GetStartParent(),
+range->StartOffset(),
+aSubtract, &cmp);
+NS_ENSURE_SUCCESS(rv, rv);
+// Also, make a comparison to the range end
+int32_t cmp2;
+rv = CompareToRangeEnd(range->GetEndParent(),
+range->EndOffset(),
+aSubtract, &cmp2);
+NS_ENSURE_SUCCESS(rv, rv);
+// If the existing range left overlaps the new range (aSubtract) then
+// cmp < 0, and cmp2 < 0
+// If it right overlaps the new range then cmp > 0 and cmp2 > 0
+// If it fully contains the new range, then cmp < 0 and cmp2 > 0
+if (cmp2 > 0) {
+// We need to add a new RangeData to the output, running from
+// the end of aSubtract to the end of range
+nsRefPtr<nsRange> postOverlap = new nsRange(aSubtract->GetEndParent());
+rv =
+postOverlap->SetStart(aSubtract->GetEndParent(), aSubtract->EndOffset());
+NS_ENSURE_SUCCESS(rv, rv);
+rv =
+postOverlap->SetEnd(range->GetEndParent(), range->EndOffset());
+NS_ENSURE_SUCCESS(rv, rv);
+if (!postOverlap->Collapsed()) {
+if (!aOutput->InsertElementAt(0, RangeData(postOverlap)))
+return NS_ERROR_OUT_OF_MEMORY;
+(*aOutput)[0].mTextRangeStyle = aRange->mTextRangeStyle;
+}
+}
+if (cmp < 0) {
+// We need to add a new RangeData to the output, running from
+// the start of the range to the start of aSubtract
+nsRefPtr<nsRange> preOverlap = new nsRange(range->GetStartParent());
+nsresult rv =
+preOverlap->SetStart(range->GetStartParent(), range->StartOffset());
+NS_ENSURE_SUCCESS(rv, rv);
+rv =
+preOverlap->SetEnd(aSubtract->GetStartParent(), aSubtract->StartOffset());
+NS_ENSURE_SUCCESS(rv, rv);
+if (!preOverlap->Collapsed()) {
+if (!aOutput->InsertElementAt(0, RangeData(preOverlap)))
+return NS_ERROR_OUT_OF_MEMORY;
+(*aOutput)[0].mTextRangeStyle = aRange->mTextRangeStyle;
+}
+}
+return NS_OK;
+}
+nsresult
+Selection::AddItem(nsRange* aItem, int32_t* aOutIndex)
+{
+if (!aItem)
+return NS_ERROR_NULL_POINTER;
+if (!aItem->IsPositioned())
+return NS_ERROR_UNEXPECTED;
+NS_ASSERTION(aOutIndex, "aOutIndex can't be null");
+*aOutIndex = -1;
+// a common case is that we have no ranges yet
+if (mRanges.Length() == 0) {
+if (!mRanges.AppendElement(RangeData(aItem)))
+return NS_ERROR_OUT_OF_MEMORY;
+aItem->SetInSelection(true);
+*aOutIndex = 0;
+return NS_OK;
+}
+int32_t startIndex, endIndex;
+nsresult rv = GetIndicesForInterval(aItem->GetStartParent(),
+aItem->StartOffset(),
+aItem->GetEndParent(),
+aItem->EndOffset(), false,
+&startIndex, &endIndex);
+NS_ENSURE_SUCCESS(rv, rv);
+if (endIndex == -1) {
+// All ranges start after the given range. We can insert our range at
+// position 0, knowing there are no overlaps (handled below)
+startIndex = 0;
+endIndex = 0;
+} else if (startIndex == -1) {
+// All ranges end before the given range. We can insert our range at
+// the end of the array, knowing there are no overlaps (handled below)
+startIndex = mRanges.Length();
+endIndex = startIndex;
+}
+// If the range is already contained in mRanges, silently succeed
+bool sameRange = EqualsRangeAtPoint(aItem->GetStartParent(),
+aItem->StartOffset(),
+aItem->GetEndParent(),
+aItem->EndOffset(), startIndex);
+if (sameRange) {
+*aOutIndex = startIndex;
+return NS_OK;
+}
+if (startIndex == endIndex) {
+// The new range doesn't overlap any existing ranges
+if (!mRanges.InsertElementAt(startIndex, RangeData(aItem)))
+return NS_ERROR_OUT_OF_MEMORY;
+aItem->SetInSelection(true);
+*aOutIndex = startIndex;
+return NS_OK;
+}
+// We now know that at least 1 existing range overlaps with the range that
+// we are trying to add. In fact, the only ranges of interest are those at
+// the two end points, startIndex and endIndex - 1 (which may point to the
+// same range) as these may partially overlap the new range. Any ranges
+// between these indices are fully overlapped by the new range, and so can be
+// removed
+nsTArray<RangeData> overlaps;
+if (!overlaps.InsertElementAt(0, mRanges[startIndex]))
+return NS_ERROR_OUT_OF_MEMORY;
+if (endIndex - 1 != startIndex) {
+if (!overlaps.InsertElementAt(1, mRanges[endIndex - 1]))
+return NS_ERROR_OUT_OF_MEMORY;
+}
+// Remove all the overlapping ranges
+for (int32_t i = startIndex; i < endIndex; ++i) {
+mRanges[i].mRange->SetInSelection(false);
+}
+mRanges.RemoveElementsAt(startIndex, endIndex - startIndex);
+nsTArray<RangeData> temp;
+for (int32_t i = overlaps.Length() - 1; i >= 0; i--) {
+nsresult rv = SubtractRange(&overlaps[i], aItem, &temp);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+// Insert the new element into our "leftovers" array
+int32_t insertionPoint;
+rv = FindInsertionPoint(&temp, aItem->GetStartParent(),
+aItem->StartOffset(), CompareToRangeStart,
+&insertionPoint);
+NS_ENSURE_SUCCESS(rv, rv);
+if (!temp.InsertElementAt(insertionPoint, RangeData(aItem)))
+return NS_ERROR_OUT_OF_MEMORY;
+// Merge the leftovers back in to mRanges
+if (!mRanges.InsertElementsAt(startIndex, temp))
+return NS_ERROR_OUT_OF_MEMORY;
+for (uint32_t i = 0; i < temp.Length(); ++i) {
+temp[i].mRange->SetInSelection(true);
+}
+*aOutIndex = startIndex + insertionPoint;
+return NS_OK;
+}
+nsresult
+Selection::RemoveItem(nsRange* aItem)
+{
+if (!aItem)
+return NS_ERROR_NULL_POINTER;
+// Find the range's index & remove it. We could use FindInsertionPoint to
+// get O(log n) time, but that requires many expensive DOM comparisons.
+// For even several thousand items, this is probably faster because the
+// comparisons are so fast.
+int32_t idx = -1;
+uint32_t i;
+for (i = 0; i < mRanges.Length(); i ++) {
+if (mRanges[i].mRange == aItem) {
+idx = (int32_t)i;
+break;
+}
+}
+if (idx < 0)
+return NS_ERROR_INVALID_ARG;
+mRanges.RemoveElementAt(idx);
+aItem->SetInSelection(false);
+return NS_OK;
+}
+nsresult
+Selection::RemoveCollapsedRanges()
+{
+uint32_t i = 0;
+while (i < mRanges.Length()) {
+if (mRanges[i].mRange->Collapsed()) {
+nsresult rv = RemoveItem(mRanges[i].mRange);
+NS_ENSURE_SUCCESS(rv, rv);
+} else {
+++i;
+}
+}
+return NS_OK;
+}
+nsresult
+Selection::Clear(nsPresContext* aPresContext)
+{
+setAnchorFocusRange(-1);
+for (uint32_t i = 0; i < mRanges.Length(); ++i) {
+mRanges[i].mRange->SetInSelection(false);
+selectFrames(aPresContext, mRanges[i].mRange, false);
+}
+mRanges.Clear();
+// Reset direction so for more dependable table selection range handling
+SetDirection(eDirNext);
+// If this was an ATTENTION selection, change it back to normal now
+if (mFrameSelection &&
+mFrameSelection->GetDisplaySelection() ==
+nsISelectionController::SELECTION_ATTENTION) {
+mFrameSelection->SetDisplaySelection(nsISelectionController::SELECTION_ON);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetType(int16_t* aType)
+{
+NS_ENSURE_ARG_POINTER(aType);
+*aType = Type();
+return NS_OK;
+}
+// RangeMatches*Point
+//
+//    Compares the range beginning or ending point, and returns true if it
+//    exactly matches the given DOM point.
+static inline bool
+RangeMatchesBeginPoint(nsRange* aRange, nsINode* aNode, int32_t aOffset)
+{
+return aRange->GetStartParent() == aNode && aRange->StartOffset() == aOffset;
+}
+static inline bool
+RangeMatchesEndPoint(nsRange* aRange, nsINode* aNode, int32_t aOffset)
+{
+return aRange->GetEndParent() == aNode && aRange->EndOffset() == aOffset;
+}
+// Selection::EqualsRangeAtPoint
+//
+//    Utility method for checking equivalence of two ranges.
+bool
+Selection::EqualsRangeAtPoint(
+nsINode* aBeginNode, int32_t aBeginOffset,
+nsINode* aEndNode, int32_t aEndOffset,
+int32_t aRangeIndex)
+{
+if (aRangeIndex >=0 && aRangeIndex < (int32_t) mRanges.Length()) {
+nsRange* range = mRanges[aRangeIndex].mRange;
+if (RangeMatchesBeginPoint(range, aBeginNode, aBeginOffset) &&
+RangeMatchesEndPoint(range, aEndNode, aEndOffset))
+return true;
+}
+return false;
+}
+// Selection::GetRangesForInterval
+//
+//    XPCOM wrapper for the nsTArray version
+NS_IMETHODIMP
+Selection::GetRangesForInterval(nsIDOMNode* aBeginNode, int32_t aBeginOffset,
+nsIDOMNode* aEndNode, int32_t aEndOffset,
+bool aAllowAdjacent,
+uint32_t* aResultCount,
+nsIDOMRange*** aResults)
+{
+if (!aBeginNode || ! aEndNode || ! aResultCount || ! aResults)
+return NS_ERROR_NULL_POINTER;
+*aResultCount = 0;
+*aResults = nullptr;
+nsTArray<nsRefPtr<nsRange>> results;
+ErrorResult result;
+nsCOMPtr<nsINode> beginNode = do_QueryInterface(aBeginNode);
+nsCOMPtr<nsINode> endNode = do_QueryInterface(aEndNode);
+NS_ENSURE_TRUE(beginNode && endNode, NS_ERROR_NULL_POINTER);
+GetRangesForInterval(*beginNode, aBeginOffset, *endNode, aEndOffset,
+aAllowAdjacent, results, result);
+if (result.Failed()) {
+return result.ErrorCode();
+}
+*aResultCount = results.Length();
+if (*aResultCount == 0) {
+return NS_OK;
+}
+*aResults = static_cast<nsIDOMRange**>
+(nsMemory::Alloc(sizeof(nsIDOMRange*) * *aResultCount));
+NS_ENSURE_TRUE(*aResults, NS_ERROR_OUT_OF_MEMORY);
+for (uint32_t i = 0; i < *aResultCount; i++) {
+(*aResults)[i] = results[i].forget().take();
+}
+return NS_OK;
+}
+void
+Selection::GetRangesForInterval(nsINode& aBeginNode, int32_t aBeginOffset,
+nsINode& aEndNode, int32_t aEndOffset,
+bool aAllowAdjacent,
+nsTArray<nsRefPtr<nsRange>>& aReturn,
+mozilla::ErrorResult& aRv)
+{
+nsTArray<nsRange*> results;
+nsresult rv = GetRangesForIntervalArray(&aBeginNode, aBeginOffset,
+&aEndNode, aEndOffset,
+aAllowAdjacent, &results);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+return;
+}
+aReturn.SetLength(results.Length());
+for (uint32_t i = 0; i < results.Length(); ++i) {
+aReturn[i] = results[i]; // AddRefs
+}
+}
+// Selection::GetRangesForIntervalArray
+//
+//    Fills a nsTArray with the ranges overlapping the range specified by
+//    the given endpoints. Ranges in the selection exactly adjacent to the
+//    input range are not returned unless aAllowAdjacent is set.
+//
+//    For example, if the following ranges were in the selection
+//    (assume everything is within the same node)
+//
+//    Start Offset: 0 2 7 9
+//      End Offset: 2 5 9 10
+//
+//    and passed aBeginOffset of 2 and aEndOffset of 9, then with
+//    aAllowAdjacent set, all the ranges should be returned. If
+//    aAllowAdjacent was false, the ranges [2, 5] and [7, 9] only
+//    should be returned
+//
+//    Now that overlapping ranges are disallowed, there can be a maximum of
+//    2 adjacent ranges
+nsresult
+Selection::GetRangesForIntervalArray(nsINode* aBeginNode, int32_t aBeginOffset,
+nsINode* aEndNode, int32_t aEndOffset,
+bool aAllowAdjacent,
+nsTArray<nsRange*>* aRanges)
+{
+aRanges->Clear();
+int32_t startIndex, endIndex;
+nsresult res = GetIndicesForInterval(aBeginNode, aBeginOffset,
+aEndNode, aEndOffset, aAllowAdjacent,
+&startIndex, &endIndex);
+NS_ENSURE_SUCCESS(res, res);
+if (startIndex == -1 || endIndex == -1)
+return NS_OK;
+for (int32_t i = startIndex; i < endIndex; i++) {
+if (!aRanges->AppendElement(mRanges[i].mRange))
+return NS_ERROR_OUT_OF_MEMORY;
+}
+return NS_OK;
+}
+// Selection::GetIndicesForInterval
+//
+//    Works on the same principle as GetRangesForIntervalArray above, however
+//    instead this returns the indices into mRanges between which the
+//    overlapping ranges lie.
+nsresult
+Selection::GetIndicesForInterval(nsINode* aBeginNode, int32_t aBeginOffset,
+nsINode* aEndNode, int32_t aEndOffset,
+bool aAllowAdjacent,
+int32_t* aStartIndex, int32_t* aEndIndex)
+{
+int32_t startIndex;
+int32_t endIndex;
+if (!aStartIndex)
+aStartIndex = &startIndex;
+if (!aEndIndex)
+aEndIndex = &endIndex;
+*aStartIndex = -1;
+*aEndIndex = -1;
+if (mRanges.Length() == 0)
+return NS_OK;
+bool intervalIsCollapsed = aBeginNode == aEndNode &&
+aBeginOffset == aEndOffset;
+// Ranges that end before the given interval and begin after the given
+// interval can be discarded
+int32_t endsBeforeIndex;
+if (NS_FAILED(FindInsertionPoint(&mRanges, aEndNode, aEndOffset,
+&CompareToRangeStart,
+&endsBeforeIndex))) {
+return NS_OK;
+}
+if (endsBeforeIndex == 0) {
+nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+// If the interval is strictly before the range at index 0, we can optimize
+// by returning now - all ranges start after the given interval
+if (!RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset))
+return NS_OK;
+// We now know that the start point of mRanges[0].mRange equals the end of
+// the interval. Thus, when aAllowadjacent is true, the caller is always
+// interested in this range. However, when excluding adjacencies, we must
+// remember to include the range when both it and the given interval are
+// collapsed to the same point
+if (!aAllowAdjacent && !(endRange->Collapsed() && intervalIsCollapsed))
+return NS_OK;
+}
+*aEndIndex = endsBeforeIndex;
+int32_t beginsAfterIndex;
+if (NS_FAILED(FindInsertionPoint(&mRanges, aBeginNode, aBeginOffset,
+&CompareToRangeEnd,
+&beginsAfterIndex))) {
+return NS_OK;
+}
+if (beginsAfterIndex == (int32_t) mRanges.Length())
+return NS_OK; // optimization: all ranges are strictly before us
+if (aAllowAdjacent) {
+// At this point, one of the following holds:
+//   endsBeforeIndex == mRanges.Length(),
+//   endsBeforeIndex points to a range whose start point does not equal the
+//     given interval's start point
+//   endsBeforeIndex points to a range whose start point equals the given
+//     interval's start point
+// In the final case, there can be two such ranges, a collapsed range, and
+// an adjacent range (they will appear in mRanges in that order). For this
+// final case, we need to increment endsBeforeIndex, until one of the
+// first two possibilites hold
+while (endsBeforeIndex < (int32_t) mRanges.Length()) {
+nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+if (!RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset))
+break;
+endsBeforeIndex++;
+}
+// Likewise, one of the following holds:
+//   beginsAfterIndex == 0,
+//   beginsAfterIndex points to a range whose end point does not equal
+//     the given interval's end point
+//   beginsOnOrAfter points to a range whose end point equals the given
+//     interval's end point
+// In the final case, there can be two such ranges, an adjacent range, and
+// a collapsed range (they will appear in mRanges in that order). For this
+// final case, we only need to take action if both those ranges exist, and
+// we are pointing to the collapsed range - we need to point to the
+// adjacent range
+nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
+if (beginsAfterIndex > 0 && beginRange->Collapsed() &&
+RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset)) {
+beginRange = mRanges[beginsAfterIndex - 1].mRange;
+if (RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset))
+beginsAfterIndex--;
+}
+} else {
+// See above for the possibilities at this point. The only case where we
+// need to take action is when the range at beginsAfterIndex ends on
+// the given interval's start point, but that range isn't collapsed (a
+// collapsed range should be included in the returned results).
+nsRange* beginRange = mRanges[beginsAfterIndex].mRange;
+if (RangeMatchesEndPoint(beginRange, aBeginNode, aBeginOffset) &&
+!beginRange->Collapsed())
+beginsAfterIndex++;
+// Again, see above for the meaning of endsBeforeIndex at this point.
+// In particular, endsBeforeIndex may point to a collaped range which
+// represents the point at the end of the interval - this range should be
+// included
+if (endsBeforeIndex < (int32_t) mRanges.Length()) {
+nsRange* endRange = mRanges[endsBeforeIndex].mRange;
+if (RangeMatchesBeginPoint(endRange, aEndNode, aEndOffset) &&
+endRange->Collapsed())
+endsBeforeIndex++;
+}
+}
+NS_ASSERTION(beginsAfterIndex <= endsBeforeIndex,
+"Is mRanges not ordered?");
+NS_ENSURE_STATE(beginsAfterIndex <= endsBeforeIndex);
+*aStartIndex = beginsAfterIndex;
+*aEndIndex = endsBeforeIndex;
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetPrimaryFrameForAnchorNode(nsIFrame** aReturnFrame)
+{
+if (!aReturnFrame)
+return NS_ERROR_NULL_POINTER;
+int32_t frameOffset = 0;
+*aReturnFrame = 0;
+nsCOMPtr<nsIContent> content = do_QueryInterface(GetAnchorNode());
+if (content && mFrameSelection)
+{
+*aReturnFrame = mFrameSelection->
+GetFrameForNodeOffset(content, AnchorOffset(),
+mFrameSelection->GetHint(), &frameOffset);
+if (*aReturnFrame)
+return NS_OK;
+}
+return NS_ERROR_FAILURE;
+}
+NS_IMETHODIMP
+Selection::GetPrimaryFrameForFocusNode(nsIFrame** aReturnFrame,
+int32_t* aOffsetUsed,
+bool aVisual)
+{
+if (!aReturnFrame)
+return NS_ERROR_NULL_POINTER;
+nsCOMPtr<nsIContent> content = do_QueryInterface(GetFocusNode());
+if (!content || !mFrameSelection)
+return NS_ERROR_FAILURE;
+int32_t frameOffset = 0;
+*aReturnFrame = 0;
+if (!aOffsetUsed)
+aOffsetUsed = &frameOffset;
+nsFrameSelection::HINT hint = mFrameSelection->GetHint();
+if (aVisual) {
+nsIPresShell *presShell = mFrameSelection->GetShell();
+if (!presShell)
+return NS_ERROR_FAILURE;
+nsRefPtr<nsCaret> caret = presShell->GetCaret();
+if (!caret)
+return NS_ERROR_FAILURE;
+uint8_t caretBidiLevel = mFrameSelection->GetCaretBidiLevel();
+return caret->GetCaretFrameForNodeOffset(content, FocusOffset(),
+hint, caretBidiLevel, aReturnFrame, aOffsetUsed);
+}
+*aReturnFrame = mFrameSelection->
+GetFrameForNodeOffset(content, FocusOffset(),
+hint, aOffsetUsed);
+if (!*aReturnFrame)
+return NS_ERROR_FAILURE;
+return NS_OK;
+}
+//select all content children of aContent
+nsresult
+Selection::SelectAllFramesForContent(nsIContentIterator* aInnerIter,
+nsIContent* aContent,
+bool aSelected)
+{
+nsresult result = aInnerIter->Init(aContent);
+nsIFrame *frame;
+if (NS_SUCCEEDED(result))
+{
+// First select frame of content passed in
+frame = aContent->GetPrimaryFrame();
+if (frame && frame->GetType() == nsGkAtoms::textFrame) {
+nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
+textFrame->SetSelectedRange(0, aContent->GetText()->GetLength(), aSelected, mType);
+}
+// Now iterated through the child frames and set them
+while (!aInnerIter->IsDone()) {
+nsCOMPtr<nsIContent> innercontent =
+do_QueryInterface(aInnerIter->GetCurrentNode());
+frame = innercontent->GetPrimaryFrame();
+if (frame) {
+if (frame->GetType() == nsGkAtoms::textFrame) {
+nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
+textFrame->SetSelectedRange(0, innercontent->GetText()->GetLength(), aSelected, mType);
+} else {
+frame->InvalidateFrameSubtree();  // frame continuations?
+}
+}
+aInnerIter->Next();
+}
+return NS_OK;
+}
+return NS_ERROR_FAILURE;
+}
+/**
+* The idea of this helper method is to select or deselect "top to bottom",
+* traversing through the frames
+*/
+nsresult
+Selection::selectFrames(nsPresContext* aPresContext, nsRange* aRange,
+bool aSelect)
+{
+if (!mFrameSelection || !aPresContext || !aPresContext->GetPresShell()) {
+// nothing to do
+return NS_OK;
+}
+MOZ_ASSERT(aRange);
+if (mFrameSelection->GetTableCellSelection()) {
+nsINode* node = aRange->GetCommonAncestor();
+nsIFrame* frame = node->IsContent() ? node->AsContent()->GetPrimaryFrame()
+: aPresContext->FrameManager()->GetRootFrame();
+if (frame) {
+frame->InvalidateFrameSubtree();
+}
+return NS_OK;
+}
+nsCOMPtr<nsIContentIterator> iter = NS_NewContentSubtreeIterator();
+iter->Init(aRange);
+// Loop through the content iterator for each content node; for each text
+// node, call SetSelected on it:
+nsCOMPtr<nsIContent> content = do_QueryInterface(aRange->GetStartParent());
+NS_ENSURE_STATE(content);
+// We must call first one explicitly
+if (content->IsNodeOfType(nsINode::eTEXT)) {
+nsIFrame* frame = content->GetPrimaryFrame();
+// The frame could be an SVG text frame, in which case we'll ignore it.
+if (frame && frame->GetType() == nsGkAtoms::textFrame) {
+nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
+uint32_t startOffset = aRange->StartOffset();
+uint32_t endOffset;
+if (aRange->GetEndParent() == content) {
+endOffset = aRange->EndOffset();
+} else {
+endOffset = content->Length();
+}
+textFrame->SetSelectedRange(startOffset, endOffset, aSelect, mType);
+}
+}
+iter->First();
+nsCOMPtr<nsIContentIterator> inneriter = NS_NewContentIterator();
+for (iter->First(); !iter->IsDone(); iter->Next()) {
+content = do_QueryInterface(iter->GetCurrentNode());
+SelectAllFramesForContent(inneriter, content, aSelect);
+}
+// We must now do the last one if it is not the same as the first
+if (aRange->GetEndParent() != aRange->GetStartParent()) {
+nsresult res;
+content = do_QueryInterface(aRange->GetEndParent(), &res);
+NS_ENSURE_SUCCESS(res, res);
+NS_ENSURE_TRUE(content, res);
+if (content->IsNodeOfType(nsINode::eTEXT)) {
+nsIFrame* frame = content->GetPrimaryFrame();
+// The frame could be an SVG text frame, in which case we'll ignore it.
+if (frame && frame->GetType() == nsGkAtoms::textFrame) {
+nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
+textFrame->SetSelectedRange(0, aRange->EndOffset(), aSelect, mType);
+}
+}
+}
+return NS_OK;
+}
+// Selection::LookUpSelection
+//
+//    This function is called when a node wants to know where the selection is
+//    over itself.
+//
+//    Usually, this is called when we already know there is a selection over
+//    the node in question, and we only need to find the boundaries of it on
+//    that node. This is when slowCheck is false--a strict test is not needed.
+//    Other times, the caller has no idea, and wants us to test everything,
+//    so we are supposed to determine whether there is a selection over the
+//    node at all.
+//
+//    A previous version of this code used this flag to do less work when
+//    inclusion was already known (slowCheck=false). However, our tree
+//    structure allows us to quickly determine ranges overlapping the node,
+//    so we just ignore the slowCheck flag and do the full test every time.
+//
+//    PERFORMANCE: a common case is that we are doing a fast check with exactly
+//    one range in the selection. In this case, this function is slower than
+//    brute force because of the overhead of checking the tree. We can optimize
+//    this case to make it faster by doing the same thing the previous version
+//    of this function did in the case of 1 range. This would also mean that
+//    the aSlowCheck flag would have meaning again.
+NS_IMETHODIMP
+Selection::LookUpSelection(nsIContent* aContent, int32_t aContentOffset,
+int32_t aContentLength,
+SelectionDetails** aReturnDetails,
+SelectionType aType, bool aSlowCheck)
+{
+nsresult rv;
+if (!aContent || ! aReturnDetails)
+return NS_ERROR_NULL_POINTER;
+// it is common to have no ranges, to optimize that
+if (mRanges.Length() == 0)
+return NS_OK;
+nsTArray<nsRange*> overlappingRanges;
+rv = GetRangesForIntervalArray(aContent, aContentOffset,
+aContent, aContentOffset + aContentLength,
+false,
+&overlappingRanges);
+NS_ENSURE_SUCCESS(rv, rv);
+if (overlappingRanges.Length() == 0)
+return NS_OK;
+for (uint32_t i = 0; i < overlappingRanges.Length(); i++) {
+nsRange* range = overlappingRanges[i];
+nsINode* startNode = range->GetStartParent();
+nsINode* endNode = range->GetEndParent();
+int32_t startOffset = range->StartOffset();
+int32_t endOffset = range->EndOffset();
+int32_t start = -1, end = -1;
+if (startNode == aContent && endNode == aContent) {
+if (startOffset < (aContentOffset + aContentLength)  &&
+endOffset > aContentOffset) {
+// this range is totally inside the requested content range
+start = std::max(0, startOffset - aContentOffset);
+end = std::min(aContentLength, endOffset - aContentOffset);
+}
+// otherwise, range is inside the requested node, but does not intersect
+// the requested content range, so ignore it
+} else if (startNode == aContent) {
+if (startOffset < (aContentOffset + aContentLength)) {
+// the beginning of the range is inside the requested node, but the
+// end is outside, select everything from there to the end
+start = std::max(0, startOffset - aContentOffset);
+end = aContentLength;
+}
+} else if (endNode == aContent) {
+if (endOffset > aContentOffset) {
+// the end of the range is inside the requested node, but the beginning
+// is outside, select everything from the beginning to there
+start = 0;
+end = std::min(aContentLength, endOffset - aContentOffset);
+}
+} else {
+// this range does not begin or end in the requested node, but since
+// GetRangesForInterval returned this range, we know it overlaps.
+// Therefore, this node is enclosed in the range, and we select all
+// of it.
+start = 0;
+end = aContentLength;
+}
+if (start < 0)
+continue; // the ranges do not overlap the input range
+SelectionDetails* details = new SelectionDetails;
+details->mNext = *aReturnDetails;
+details->mStart = start;
+details->mEnd = end;
+details->mType = aType;
+RangeData *rd = FindRangeData(range);
+if (rd) {
+details->mTextRangeStyle = rd->mTextRangeStyle;
+}
+*aReturnDetails = details;
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::Repaint(nsPresContext* aPresContext)
+{
+int32_t arrCount = (int32_t)mRanges.Length();
+if (arrCount < 1)
+return NS_OK;
+int32_t i;
+for (i = 0; i < arrCount; i++)
+{
+nsresult rv = selectFrames(aPresContext, mRanges[i].mRange, true);
+if (NS_FAILED(rv)) {
+return rv;
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetCanCacheFrameOffset(bool* aCanCacheFrameOffset)
+{
+NS_ENSURE_ARG_POINTER(aCanCacheFrameOffset);
+if (mCachedOffsetForFrame)
+*aCanCacheFrameOffset = mCachedOffsetForFrame->mCanCacheFrameOffset;
+else
+*aCanCacheFrameOffset = false;
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::SetCanCacheFrameOffset(bool aCanCacheFrameOffset)
+{
+if (!mCachedOffsetForFrame) {
+mCachedOffsetForFrame = new CachedOffsetForFrame;
+}
+mCachedOffsetForFrame->mCanCacheFrameOffset = aCanCacheFrameOffset;
+// clean up cached frame when turn off cache
+// fix bug 207936
+if (!aCanCacheFrameOffset) {
+mCachedOffsetForFrame->mLastCaretFrame = nullptr;
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetCachedFrameOffset(nsIFrame* aFrame, int32_t inOffset,
+nsPoint& aPoint)
+{
+if (!mCachedOffsetForFrame) {
+mCachedOffsetForFrame = new CachedOffsetForFrame;
+}
+nsresult rv = NS_OK;
+if (mCachedOffsetForFrame->mCanCacheFrameOffset &&
+mCachedOffsetForFrame->mLastCaretFrame &&
+(aFrame == mCachedOffsetForFrame->mLastCaretFrame) &&
+(inOffset == mCachedOffsetForFrame->mLastContentOffset))
+{
+// get cached frame offset
+aPoint = mCachedOffsetForFrame->mCachedFrameOffset;
+}
+else
+{
+// Recalculate frame offset and cache it. Don't cache a frame offset if
+// GetPointFromOffset fails, though.
+rv = aFrame->GetPointFromOffset(inOffset, &aPoint);
+if (NS_SUCCEEDED(rv) && mCachedOffsetForFrame->mCanCacheFrameOffset) {
+mCachedOffsetForFrame->mCachedFrameOffset = aPoint;
+mCachedOffsetForFrame->mLastCaretFrame = aFrame;
+mCachedOffsetForFrame->mLastContentOffset = inOffset;
+}
+}
+return rv;
+}
+NS_IMETHODIMP
+Selection::SetAncestorLimiter(nsIContent* aContent)
+{
+if (mFrameSelection)
+mFrameSelection->SetAncestorLimiter(aContent);
+return NS_OK;
+}
+RangeData*
+Selection::FindRangeData(nsIDOMRange* aRange)
+{
+NS_ENSURE_TRUE(aRange, nullptr);
+for (uint32_t i = 0; i < mRanges.Length(); i++) {
+if (mRanges[i].mRange == aRange)
+return &mRanges[i];
+}
+return nullptr;
+}
+NS_IMETHODIMP
+Selection::SetTextRangeStyle(nsIDOMRange* aRange,
+const TextRangeStyle& aTextRangeStyle)
+{
+NS_ENSURE_ARG_POINTER(aRange);
+RangeData *rd = FindRangeData(aRange);
+if (rd) {
+rd->mTextRangeStyle = aTextRangeStyle;
+}
+return NS_OK;
+}
+nsresult
+Selection::StartAutoScrollTimer(nsIFrame* aFrame, nsPoint& aPoint,
+uint32_t aDelay)
+{
+NS_PRECONDITION(aFrame, "Need a frame");
+nsresult result;
+if (!mFrameSelection)
+return NS_OK;//nothing to do
+if (!mAutoScrollTimer)
+{
+mAutoScrollTimer = new nsAutoScrollTimer();
+result = mAutoScrollTimer->Init(mFrameSelection, this);
+if (NS_FAILED(result))
+return result;
+}
+result = mAutoScrollTimer->SetDelay(aDelay);
+if (NS_FAILED(result))
+return result;
+return DoAutoScroll(aFrame, aPoint);
+}
+nsresult
+Selection::StopAutoScrollTimer()
+{
+if (mAutoScrollTimer)
+return mAutoScrollTimer->Stop();
+return NS_OK;
+}
+nsresult
+Selection::DoAutoScroll(nsIFrame* aFrame, nsPoint& aPoint)
+{
+NS_PRECONDITION(aFrame, "Need a frame");
+if (mAutoScrollTimer)
+(void)mAutoScrollTimer->Stop();
+nsPresContext* presContext = aFrame->PresContext();
+nsRootPresContext* rootPC = presContext->GetRootPresContext();
+if (!rootPC)
+return NS_OK;
+nsIFrame* rootmostFrame = rootPC->PresShell()->FrameManager()->GetRootFrame();
+// Get the point relative to the root most frame because the scroll we are
+// about to do will change the coordinates of aFrame.
+nsPoint globalPoint = aPoint + aFrame->GetOffsetToCrossDoc(rootmostFrame);
+bool didScroll = presContext->PresShell()->ScrollFrameRectIntoView(
+aFrame,
+nsRect(aPoint, nsSize(0, 0)),
+nsIPresShell::ScrollAxis(),
+nsIPresShell::ScrollAxis(),
+0);
+//
+// Start the AutoScroll timer if necessary.
+//
+if (didScroll && mAutoScrollTimer)
+{
+nsPoint presContextPoint = globalPoint -
+presContext->PresShell()->FrameManager()->GetRootFrame()->GetOffsetToCrossDoc(rootmostFrame);
+mAutoScrollTimer->Start(presContext, presContextPoint);
+}
+return NS_OK;
+}
+/** RemoveAllRanges zeroes the selection
+*/
+NS_IMETHODIMP
+Selection::RemoveAllRanges()
+{
+ErrorResult result;
+RemoveAllRanges(result);
+return result.ErrorCode();
+}
+void
+Selection::RemoveAllRanges(ErrorResult& aRv)
+{
+if (!mFrameSelection)
+return; // nothing to do
+nsRefPtr<nsPresContext>  presContext = GetPresContext();
+nsresult  result = Clear(presContext);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+// Turn off signal for table selection
+mFrameSelection->ClearTableCellSelection();
+result = mFrameSelection->NotifySelectionListeners(GetType());
+// Also need to notify the frames!
+// PresShell::CharacterDataChanged should do that on DocumentChanged
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+}
+}
+/** AddRange adds the specified range to the selection
+*  @param aRange is the range to be added
+*/
+NS_IMETHODIMP
+Selection::AddRange(nsIDOMRange* aDOMRange)
+{
+if (!aDOMRange) {
+return NS_ERROR_NULL_POINTER;
+}
+nsRange* range = static_cast<nsRange*>(aDOMRange);
+ErrorResult result;
+AddRange(*range, result);
+return result.ErrorCode();
+}
+void
+Selection::AddRange(nsRange& aRange, ErrorResult& aRv)
+{
+// This inserts a table cell range in proper document order
+// and returns NS_OK if range doesn't contain just one table cell
+bool didAddRange;
+int32_t rangeIndex;
+nsresult result = addTableCellRange(&aRange, &didAddRange, &rangeIndex);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+if (!didAddRange)
+{
+result = AddItem(&aRange, &rangeIndex);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+}
+NS_ASSERTION(rangeIndex >= 0, "Range index not returned");
+setAnchorFocusRange(rangeIndex);
+// Make sure the caret appears on the next line, if at a newline
+if (mType == nsISelectionController::SELECTION_NORMAL)
+SetInterlinePosition(true);
+nsRefPtr<nsPresContext>  presContext = GetPresContext();
+selectFrames(presContext, &aRange, true);
+if (!mFrameSelection)
+return;//nothing to do
+result = mFrameSelection->NotifySelectionListeners(GetType());
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+}
+}
+// Selection::RemoveRange
+//
+//    Removes the given range from the selection. The tricky part is updating
+//    the flags on the frames that indicate whether they have a selection or
+//    not. There could be several selection ranges on the frame, and clearing
+//    the bit would cause the selection to not be drawn, even when there is
+//    another range on the frame (bug 346185).
+//
+//    We therefore find any ranges that intersect the same nodes as the range
+//    being removed, and cause them to set the selected bits back on their
+//    selected frames after we've cleared the bit from ours.
+nsresult
+Selection::RemoveRange(nsIDOMRange* aDOMRange)
+{
+if (!aDOMRange) {
+return NS_ERROR_INVALID_ARG;
+}
+nsRange* range = static_cast<nsRange*>(aDOMRange);
+ErrorResult result;
+RemoveRange(*range, result);
+return result.ErrorCode();
+}
+void
+Selection::RemoveRange(nsRange& aRange, ErrorResult& aRv)
+{
+nsresult rv = RemoveItem(&aRange);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+return;
+}
+nsINode* beginNode = aRange.GetStartParent();
+nsINode* endNode = aRange.GetEndParent();
+if (!beginNode || !endNode) {
+// Detached range; nothing else to do here.
+return;
+}
+// find out the length of the end node, so we can select all of it
+int32_t beginOffset, endOffset;
+if (endNode->IsNodeOfType(nsINode::eTEXT)) {
+// Get the length of the text. We can't just use the offset because
+// another range could be touching this text node but not intersect our
+// range.
+beginOffset = 0;
+endOffset = static_cast<nsIContent*>(endNode)->TextLength();
+} else {
+// For non-text nodes, the given offsets should be sufficient.
+beginOffset = aRange.StartOffset();
+endOffset = aRange.EndOffset();
+}
+// clear the selected bit from the removed range's frames
+nsRefPtr<nsPresContext>  presContext = GetPresContext();
+selectFrames(presContext, &aRange, false);
+// add back the selected bit for each range touching our nodes
+nsTArray<nsRange*> affectedRanges;
+rv = GetRangesForIntervalArray(beginNode, beginOffset,
+endNode, endOffset,
+true, &affectedRanges);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+return;
+}
+for (uint32_t i = 0; i < affectedRanges.Length(); i++) {
+selectFrames(presContext, affectedRanges[i], true);
+}
+int32_t cnt = mRanges.Length();
+if (&aRange == mAnchorFocusRange) {
+// Reset anchor to LAST range or clear it if there are no ranges.
+setAnchorFocusRange(cnt - 1);
+// When the selection is user-created it makes sense to scroll the range
+// into view. The spell-check selection, however, is created and destroyed
+// in the background. We don't want to scroll in this case or the view
+// might appear to be moving randomly (bug 337871).
+if (mType != nsISelectionController::SELECTION_SPELLCHECK && cnt > 0)
+ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION);
+}
+if (!mFrameSelection)
+return;//nothing to do
+rv = mFrameSelection->NotifySelectionListeners(GetType());
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+}
+/*
+* Collapse sets the whole selection to be one point.
+*/
+NS_IMETHODIMP
+Selection::Collapse(nsIDOMNode* aParentNode, int32_t aOffset)
+{
+nsCOMPtr<nsINode> parentNode = do_QueryInterface(aParentNode);
+return Collapse(parentNode, aOffset);
+}
+NS_IMETHODIMP
+Selection::CollapseNative(nsINode* aParentNode, int32_t aOffset)
+{
+return Collapse(aParentNode, aOffset);
+}
+nsresult
+Selection::Collapse(nsINode* aParentNode, int32_t aOffset)
+{
+if (!aParentNode)
+return NS_ERROR_INVALID_ARG;
+ErrorResult result;
+Collapse(*aParentNode, static_cast<uint32_t>(aOffset), result);
+return result.ErrorCode();
+}
+void
+Selection::Collapse(nsINode& aParentNode, uint32_t aOffset, ErrorResult& aRv)
+{
+if (!mFrameSelection) {
+aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection
+return;
+}
+nsCOMPtr<nsINode> kungfuDeathGrip = &aParentNode;
+mFrameSelection->InvalidateDesiredX();
+if (!IsValidSelectionPoint(mFrameSelection, &aParentNode)) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+nsresult result;
+nsRefPtr<nsPresContext> presContext = GetPresContext();
+if (!presContext || presContext->Document() != aParentNode.OwnerDoc()) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+// Delete all of the current ranges
+Clear(presContext);
+// Turn off signal for table selection
+mFrameSelection->ClearTableCellSelection();
+nsRefPtr<nsRange> range = new nsRange(&aParentNode);
+result = range->SetEnd(&aParentNode, aOffset);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+result = range->SetStart(&aParentNode, aOffset);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+#ifdef DEBUG_SELECTION
+nsCOMPtr<nsIContent> content = do_QueryInterface(&aParentNode);
+nsCOMPtr<nsIDocument> doc = do_QueryInterface(&aParentNode);
+printf ("Sel. Collapse to %p %s %d\n", &aParentNode,
+content ? nsAtomCString(content->Tag()).get()
+: (doc ? "DOCUMENT" : "???"),
+aOffset);
+#endif
+int32_t rangeIndex = -1;
+result = AddItem(range, &rangeIndex);
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+return;
+}
+setAnchorFocusRange(0);
+selectFrames(presContext, range, true);
+result = mFrameSelection->NotifySelectionListeners(GetType());
+if (NS_FAILED(result)) {
+aRv.Throw(result);
+}
+}
+/*
+* Sets the whole selection to be one point
+* at the start of the current selection
+*/
+NS_IMETHODIMP
+Selection::CollapseToStart()
+{
+ErrorResult result;
+CollapseToStart(result);
+return result.ErrorCode();
+}
+void
+Selection::CollapseToStart(ErrorResult& aRv)
+{
+int32_t cnt;
+nsresult rv = GetRangeCount(&cnt);
+if (NS_FAILED(rv) || cnt <= 0) {
+aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+return;
+}
+// Get the first range
+nsRange* firstRange = mRanges[0].mRange;
+if (!firstRange) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+if (mFrameSelection) {
+int16_t reason = mFrameSelection->PopReason() | nsISelectionListener::COLLAPSETOSTART_REASON;
+mFrameSelection->PostReason(reason);
+}
+nsINode* parent = firstRange->GetStartParent();
+if (!parent) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+Collapse(*parent, firstRange->StartOffset(), aRv);
+}
+/*
+* Sets the whole selection to be one point
+* at the end of the current selection
+*/
+NS_IMETHODIMP
+Selection::CollapseToEnd()
+{
+ErrorResult result;
+CollapseToEnd(result);
+return result.ErrorCode();
+}
+void
+Selection::CollapseToEnd(ErrorResult& aRv)
+{
+int32_t cnt;
+nsresult rv = GetRangeCount(&cnt);
+if (NS_FAILED(rv) || cnt <= 0) {
+aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+return;
+}
+// Get the last range
+nsRange* lastRange = mRanges[cnt - 1].mRange;
+if (!lastRange) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+if (mFrameSelection) {
+int16_t reason = mFrameSelection->PopReason() | nsISelectionListener::COLLAPSETOEND_REASON;
+mFrameSelection->PostReason(reason);
+}
+nsINode* parent = lastRange->GetEndParent();
+if (!parent) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+Collapse(*parent, lastRange->EndOffset(), aRv);
+}
+/*
+* IsCollapsed -- is the whole selection just one point, or unset?
+*/
+bool
+Selection::IsCollapsed()
+{
+uint32_t cnt = mRanges.Length();
+if (cnt == 0) {
+return true;
+}
+if (cnt != 1) {
+return false;
+}
+return mRanges[0].mRange->Collapsed();
+}
+/* virtual */
+bool
+Selection::Collapsed()
+{
+return IsCollapsed();
+}
+NS_IMETHODIMP
+Selection::GetIsCollapsed(bool* aIsCollapsed)
+{
+NS_ENSURE_TRUE(aIsCollapsed, NS_ERROR_NULL_POINTER);
+*aIsCollapsed = IsCollapsed();
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetRangeCount(int32_t* aRangeCount)
+{
+*aRangeCount = (int32_t)RangeCount();
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::GetRangeAt(int32_t aIndex, nsIDOMRange** aReturn)
+{
+ErrorResult result;
+*aReturn = GetRangeAt(aIndex, result);
+NS_IF_ADDREF(*aReturn);
+return result.ErrorCode();
+}
+nsRange*
+Selection::GetRangeAt(uint32_t aIndex, ErrorResult& aRv)
+{
+nsRange* range = GetRangeAt(aIndex);
+if (!range) {
+aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+return nullptr;
+}
+return range;
+}
+nsRange*
+Selection::GetRangeAt(int32_t aIndex)
+{
+RangeData empty(nullptr);
+return mRanges.SafeElementAt(aIndex, empty).mRange;
+}
+/*
+utility function
+*/
+nsresult
+Selection::SetAnchorFocusToRange(nsRange* aRange)
+{
+NS_ENSURE_STATE(mAnchorFocusRange);
+nsresult res = RemoveItem(mAnchorFocusRange);
+if (NS_FAILED(res))
+return res;
+int32_t aOutIndex = -1;
+res = AddItem(aRange, &aOutIndex);
+if (NS_FAILED(res))
+return res;
+setAnchorFocusRange(aOutIndex);
+return NS_OK;
+}
+void
+Selection::ReplaceAnchorFocusRange(nsRange* aRange)
+{
+NS_ENSURE_TRUE_VOID(mAnchorFocusRange);
+nsRefPtr<nsPresContext> presContext = GetPresContext();
+if (presContext) {
+selectFrames(presContext, mAnchorFocusRange, false);
+SetAnchorFocusToRange(aRange);
+selectFrames(presContext, mAnchorFocusRange, true);
+}
+}
+/*
+Notes which might come in handy for extend:
+We can tell the direction of the selection by asking for the anchors selection
+if the begin is less than the end then we know the selection is to the "right".
+else it is a backwards selection.
+a = anchor
+1 = old cursor
+2 = new cursor
+if (a <= 1 && 1 <=2)    a,1,2  or (a1,2)
+if (a < 2 && 1 > 2)     a,2,1
+if (1 < a && a <2)      1,a,2
+if (a > 2 && 2 >1)      1,2,a
+if (2 < a && a <1)      2,a,1
+if (a > 1 && 1 >2)      2,1,a
+then execute
+a  1  2 select from 1 to 2
+a  2  1 deselect from 2 to 1
+1  a  2 deselect from 1 to a select from a to 2
+1  2  a deselect from 1 to 2
+2  1  a = continue selection from 2 to 1
+*/
+/*
+* Extend extends the selection away from the anchor.
+* We don't need to know the direction, because we always change the focus.
+*/
+NS_IMETHODIMP
+Selection::Extend(nsIDOMNode* aParentNode, int32_t aOffset)
+{
+nsCOMPtr<nsINode> parentNode = do_QueryInterface(aParentNode);
+return Extend(parentNode, aOffset);
+}
+NS_IMETHODIMP
+Selection::ExtendNative(nsINode* aParentNode, int32_t aOffset)
+{
+return Extend(aParentNode, aOffset);
+}
+nsresult
+Selection::Extend(nsINode* aParentNode, int32_t aOffset)
+{
+if (!aParentNode)
+return NS_ERROR_INVALID_ARG;
+ErrorResult result;
+Extend(*aParentNode, static_cast<uint32_t>(aOffset), result);
+return result.ErrorCode();
+}
+void
+Selection::Extend(nsINode& aParentNode, uint32_t aOffset, ErrorResult& aRv)
+{
+// First, find the range containing the old focus point:
+if (!mAnchorFocusRange) {
+aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+return;
+}
+if (!mFrameSelection) {
+aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection
+return;
+}
+nsresult res;
+if (!IsValidSelectionPoint(mFrameSelection, &aParentNode)) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+nsRefPtr<nsPresContext> presContext = GetPresContext();
+if (!presContext || presContext->Document() != aParentNode.OwnerDoc()) {
+aRv.Throw(NS_ERROR_FAILURE);
+return;
+}
+//mFrameSelection->InvalidateDesiredX();
+nsINode* anchorNode = GetAnchorNode();
+nsINode* focusNode = GetFocusNode();
+uint32_t anchorOffset = AnchorOffset();
+uint32_t focusOffset = FocusOffset();
+nsRefPtr<nsRange> range = mAnchorFocusRange->CloneRange();
+nsINode* startNode = range->GetStartParent();
+nsINode* endNode = range->GetEndParent();
+int32_t startOffset = range->StartOffset();
+int32_t endOffset = range->EndOffset();
+nsDirection dir = GetDirection();
+//compare anchor to old cursor.
+// We pass |disconnected| to the following ComparePoints calls in order
+// to avoid assertions. ComparePoints returns 1 in the disconnected case
+// and we can end up in various cases below, but it is assumed that in
+// any of the cases we end up, the nsRange implementation will collapse
+// the range to the new point because we can not make a valid range with
+// a disconnected point. This means that whatever range is currently
+// selected will be cleared.
+bool disconnected = false;
+bool shouldClearRange = false;
+int32_t result1 = nsContentUtils::ComparePoints(anchorNode, anchorOffset,
+focusNode, focusOffset,
+&disconnected);
+//compare old cursor to new cursor
+shouldClearRange |= disconnected;
+int32_t result2 = nsContentUtils::ComparePoints(focusNode, focusOffset,
+&aParentNode, aOffset,
+&disconnected);
+//compare anchor to new cursor
+shouldClearRange |= disconnected;
+int32_t result3 = nsContentUtils::ComparePoints(anchorNode, anchorOffset,
+&aParentNode, aOffset,
+&disconnected);
+// If the points are disconnected, the range will be collapsed below,
+// resulting in a range that selects nothing.
+if (shouldClearRange) {
+// Repaint the current range with the selection removed.
+selectFrames(presContext, range, false);
+}
+nsRefPtr<nsRange> difRange = new nsRange(&aParentNode);
+if ((result1 == 0 && result3 < 0) || (result1 <= 0 && result2 < 0)){//a1,2  a,1,2
+//select from 1 to 2 unless they are collapsed
+range->SetEnd(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+dir = eDirNext;
+res = difRange->SetEnd(range->GetEndParent(), range->EndOffset());
+nsresult tmp = difRange->SetStart(focusNode, focusOffset);
+if (NS_FAILED(tmp)) {
+res = tmp;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+selectFrames(presContext, difRange , true);
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+else if (result1 == 0 && result3 > 0){//2, a1
+//select from 2 to 1a
+dir = eDirPrevious;
+range->SetStart(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+selectFrames(presContext, range, true);
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+else if (result3 <= 0 && result2 >= 0) {//a,2,1 or a2,1 or a,21 or a21
+//deselect from 2 to 1
+res = difRange->SetEnd(focusNode, focusOffset);
+difRange->SetStart(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+range->SetEnd(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+selectFrames(presContext, difRange, false); // deselect now
+difRange->SetEnd(range->GetEndParent(), range->EndOffset());
+selectFrames(presContext, difRange, true); // must reselect last node maybe more
+}
+else if (result1 >= 0 && result3 <= 0) {//1,a,2 or 1a,2 or 1,a2 or 1a2
+if (GetDirection() == eDirPrevious){
+res = range->SetStart(endNode, endOffset);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+dir = eDirNext;
+range->SetEnd(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+if (focusNode != anchorNode || focusOffset != anchorOffset) {//if collapsed diff dont do anything
+res = difRange->SetStart(focusNode, focusOffset);
+nsresult tmp = difRange->SetEnd(anchorNode, anchorOffset);
+if (NS_FAILED(tmp)) {
+res = tmp;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+//deselect from 1 to a
+selectFrames(presContext, difRange , false);
+}
+else
+{
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+//select from a to 2
+selectFrames(presContext, range , true);
+}
+else if (result2 <= 0 && result3 >= 0) {//1,2,a or 12,a or 1,2a or 12a
+//deselect from 1 to 2
+difRange->SetEnd(aParentNode, aOffset, aRv);
+res = difRange->SetStart(focusNode, focusOffset);
+if (aRv.Failed()) {
+return;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+dir = eDirPrevious;
+range->SetStart(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+selectFrames(presContext, difRange , false);
+difRange->SetStart(range->GetStartParent(), range->StartOffset());
+selectFrames(presContext, difRange, true);//must reselect last node
+}
+else if (result3 >= 0 && result1 <= 0) {//2,a,1 or 2a,1 or 2,a1 or 2a1
+if (GetDirection() == eDirNext){
+range->SetEnd(startNode, startOffset);
+}
+dir = eDirPrevious;
+range->SetStart(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+//deselect from a to 1
+if (focusNode != anchorNode || focusOffset!= anchorOffset) {//if collapsed diff dont do anything
+res = difRange->SetStart(anchorNode, anchorOffset);
+nsresult tmp = difRange->SetEnd(focusNode, focusOffset);
+if (NS_FAILED(tmp)) {
+res = tmp;
+}
+tmp = SetAnchorFocusToRange(range);
+if (NS_FAILED(tmp)) {
+res = tmp;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+selectFrames(presContext, difRange, false);
+}
+else
+{
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+//select from 2 to a
+selectFrames(presContext, range , true);
+}
+else if (result2 >= 0 && result1 >= 0) {//2,1,a or 21,a or 2,1a or 21a
+//select from 2 to 1
+range->SetStart(aParentNode, aOffset, aRv);
+if (aRv.Failed()) {
+return;
+}
+dir = eDirPrevious;
+res = difRange->SetEnd(focusNode, focusOffset);
+nsresult tmp = difRange->SetStart(range->GetStartParent(), range->StartOffset());
+if (NS_FAILED(tmp)) {
+res = tmp;
+}
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+selectFrames(presContext, difRange, true);
+res = SetAnchorFocusToRange(range);
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+return;
+}
+}
+DEBUG_OUT_RANGE(range);
+#ifdef DEBUG_SELECTION
+if (eDirNext == mDirection)
+printf("    direction = 1  LEFT TO RIGHT\n");
+else
+printf("    direction = 0  RIGHT TO LEFT\n");
+#endif
+SetDirection(dir);
+#ifdef DEBUG_SELECTION
+nsCOMPtr<nsIContent> content = do_QueryInterface(&aParentNode);
+printf ("Sel. Extend to %p %s %d\n", content.get(),
+nsAtomCString(content->Tag()).get(), aOffset);
+#endif
+res = mFrameSelection->NotifySelectionListeners(GetType());
+if (NS_FAILED(res)) {
+aRv.Throw(res);
+}
+}
+NS_IMETHODIMP
+Selection::SelectAllChildren(nsIDOMNode* aParentNode)
+{
+ErrorResult result;
+nsCOMPtr<nsINode> node = do_QueryInterface(aParentNode);
+NS_ENSURE_TRUE(node, NS_ERROR_INVALID_ARG);
+SelectAllChildren(*node, result);
+return result.ErrorCode();
+}
+void
+Selection::SelectAllChildren(nsINode& aNode, ErrorResult& aRv)
+{
+if (mFrameSelection)
+{
+mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
+}
+Collapse(aNode, 0, aRv);
+if (aRv.Failed()) {
+return;
+}
+if (mFrameSelection)
+{
+mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
+}
+Extend(aNode, aNode.GetChildCount(), aRv);
+}
+NS_IMETHODIMP
+Selection::ContainsNode(nsIDOMNode* aNode, bool aAllowPartial, bool* aYes)
+{
+if (!aYes)
+return NS_ERROR_NULL_POINTER;
+*aYes = false;
+nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+ErrorResult result;
+*aYes = ContainsNode(node, aAllowPartial, result);
+return result.ErrorCode();
+}
+bool
+Selection::ContainsNode(nsINode* aNode, bool aAllowPartial, ErrorResult& aRv)
+{
+nsresult rv;
+if (mRanges.Length() == 0 || !aNode)
+return false;
+// XXXbz this duplicates the GetNodeLength code in nsRange.cpp
+uint32_t nodeLength;
+bool isData = aNode->IsNodeOfType(nsINode::eDATA_NODE);
+if (isData) {
+nodeLength = static_cast<nsIContent*>(aNode)->TextLength();
+} else {
+nodeLength = aNode->GetChildCount();
+}
+nsTArray<nsRange*> overlappingRanges;
+rv = GetRangesForIntervalArray(aNode, 0, aNode, nodeLength,
+false, &overlappingRanges);
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+return false;
+}
+if (overlappingRanges.Length() == 0)
+return false; // no ranges overlap
+// if the caller said partial intersections are OK, we're done
+if (aAllowPartial) {
+return true;
+}
+// text nodes always count as inside
+if (isData) {
+return true;
+}
+// The caller wants to know if the node is entirely within the given range,
+// so we have to check all intersecting ranges.
+for (uint32_t i = 0; i < overlappingRanges.Length(); i++) {
+bool nodeStartsBeforeRange, nodeEndsAfterRange;
+if (NS_SUCCEEDED(nsRange::CompareNodeToRange(aNode, overlappingRanges[i],
+&nodeStartsBeforeRange,
+&nodeEndsAfterRange))) {
+if (!nodeStartsBeforeRange && !nodeEndsAfterRange) {
+return true;
+}
+}
+}
+return false;
+}
+nsPresContext*
+Selection::GetPresContext() const
+{
+nsIPresShell *shell = GetPresShell();
+if (!shell) {
+return nullptr;
+}
+return shell->GetPresContext();
+}
+nsIPresShell*
+Selection::GetPresShell() const
+{
+if (!mFrameSelection)
+return nullptr;//nothing to do
+return mFrameSelection->GetShell();
+}
+nsIFrame *
+Selection::GetSelectionAnchorGeometry(SelectionRegion aRegion, nsRect* aRect)
+{
+if (!mFrameSelection)
+return nullptr;  // nothing to do
+NS_ENSURE_TRUE(aRect, nullptr);
+aRect->SetRect(0, 0, 0, 0);
+switch (aRegion) {
+case nsISelectionController::SELECTION_ANCHOR_REGION:
+case nsISelectionController::SELECTION_FOCUS_REGION:
+return GetSelectionEndPointGeometry(aRegion, aRect);
+break;
+case nsISelectionController::SELECTION_WHOLE_SELECTION:
+break;
+default:
+return nullptr;
+}
+NS_ASSERTION(aRegion == nsISelectionController::SELECTION_WHOLE_SELECTION,
+"should only be SELECTION_WHOLE_SELECTION here");
+nsRect anchorRect;
+nsIFrame* anchorFrame = GetSelectionEndPointGeometry(
+nsISelectionController::SELECTION_ANCHOR_REGION, &anchorRect);
+if (!anchorFrame)
+return nullptr;
+nsRect focusRect;
+nsIFrame* focusFrame = GetSelectionEndPointGeometry(
+nsISelectionController::SELECTION_FOCUS_REGION, &focusRect);
+if (!focusFrame)
+return nullptr;
+NS_ASSERTION(anchorFrame->PresContext() == focusFrame->PresContext(),
+"points of selection in different documents?");
+// make focusRect relative to anchorFrame
+focusRect += focusFrame->GetOffsetTo(anchorFrame);
+aRect->UnionRectEdges(anchorRect, focusRect);
+return anchorFrame;
+}
+nsIFrame *
+Selection::GetSelectionEndPointGeometry(SelectionRegion aRegion, nsRect* aRect)
+{
+if (!mFrameSelection)
+return nullptr;  // nothing to do
+NS_ENSURE_TRUE(aRect, nullptr);
+aRect->SetRect(0, 0, 0, 0);
+nsINode    *node       = nullptr;
+uint32_t    nodeOffset = 0;
+nsIFrame   *frame      = nullptr;
+switch (aRegion) {
+case nsISelectionController::SELECTION_ANCHOR_REGION:
+node       = GetAnchorNode();
+nodeOffset = AnchorOffset();
+break;
+case nsISelectionController::SELECTION_FOCUS_REGION:
+node       = GetFocusNode();
+nodeOffset = FocusOffset();
+break;
+default:
+return nullptr;
+}
+if (!node)
+return nullptr;
+nsCOMPtr<nsIContent> content = do_QueryInterface(node);
+NS_ENSURE_TRUE(content.get(), nullptr);
+int32_t frameOffset = 0;
+frame = mFrameSelection->GetFrameForNodeOffset(content, nodeOffset,
+mFrameSelection->GetHint(),
+&frameOffset);
+if (!frame)
+return nullptr;
+// Figure out what node type we have, then get the
+// appropriate rect for it's nodeOffset.
+bool isText = node->IsNodeOfType(nsINode::eTEXT);
+nsPoint pt(0, 0);
+if (isText) {
+nsIFrame* childFrame = nullptr;
+frameOffset = 0;
+nsresult rv =
+frame->GetChildFrameContainingOffset(nodeOffset,
+mFrameSelection->GetHint(),
+&frameOffset, &childFrame);
+if (NS_FAILED(rv))
+return nullptr;
+if (!childFrame)
+return nullptr;
+frame = childFrame;
+// Get the x coordinate of the offset into the text frame.
+rv = GetCachedFrameOffset(frame, nodeOffset, pt);
+if (NS_FAILED(rv))
+return nullptr;
+}
+// Return the rect relative to the frame, with zero width.
+if (isText) {
+aRect->x = pt.x;
+} else if (mFrameSelection->GetHint() == nsFrameSelection::HINTLEFT) {
+// It's the frame's right edge we're interested in.
+aRect->x = frame->GetRect().width;
+}
+aRect->height = frame->GetRect().height;
+return frame;
+}
+NS_IMETHODIMP
+Selection::ScrollSelectionIntoViewEvent::Run()
+{
+if (!mSelection)
+return NS_OK;  // event revoked
+int32_t flags = Selection::SCROLL_DO_FLUSH |
+Selection::SCROLL_SYNCHRONOUS;
+mSelection->mScrollEvent.Forget();
+mSelection->ScrollIntoView(mRegion, mVerticalScroll,
+mHorizontalScroll, mFlags | flags);
+return NS_OK;
+}
+nsresult
+Selection::PostScrollSelectionIntoViewEvent(
+SelectionRegion aRegion,
+int32_t aFlags,
+nsIPresShell::ScrollAxis aVertical,
+nsIPresShell::ScrollAxis aHorizontal)
+{
+// If we've already posted an event, revoke it and place a new one at the
+// end of the queue to make sure that any new pending reflow events are
+// processed before we scroll. This will insure that we scroll to the
+// correct place on screen.
+mScrollEvent.Revoke();
+nsRefPtr<ScrollSelectionIntoViewEvent> ev =
+new ScrollSelectionIntoViewEvent(this, aRegion, aVertical, aHorizontal,
+aFlags);
+nsresult rv = NS_DispatchToCurrentThread(ev);
+NS_ENSURE_SUCCESS(rv, rv);
+mScrollEvent = ev;
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::ScrollIntoView(SelectionRegion aRegion, bool aIsSynchronous,
+int16_t aVPercent, int16_t aHPercent)
+{
+ErrorResult result;
+ScrollIntoView(aRegion, aIsSynchronous, aVPercent, aHPercent, result);
+if (result.Failed()) {
+return result.ErrorCode();
+}
+return NS_OK;
+}
+void
+Selection::ScrollIntoView(int16_t aRegion, bool aIsSynchronous,
+int16_t aVPercent, int16_t aHPercent,
+ErrorResult& aRv)
+{
+nsresult rv = ScrollIntoViewInternal(aRegion, aIsSynchronous,
+nsIPresShell::ScrollAxis(aVPercent),
+nsIPresShell::ScrollAxis(aHPercent));
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+}
+NS_IMETHODIMP
+Selection::ScrollIntoViewInternal(SelectionRegion aRegion, bool aIsSynchronous,
+nsIPresShell::ScrollAxis aVertical,
+nsIPresShell::ScrollAxis aHorizontal)
+{
+return ScrollIntoView(aRegion, aVertical, aHorizontal,
+aIsSynchronous ? Selection::SCROLL_SYNCHRONOUS : 0);
+}
+nsresult
+Selection::ScrollIntoView(SelectionRegion aRegion,
+nsIPresShell::ScrollAxis aVertical,
+nsIPresShell::ScrollAxis aHorizontal,
+int32_t aFlags)
+{
+if (!mFrameSelection)
+return NS_OK;//nothing to do
+nsCOMPtr<nsIPresShell> presShell = mFrameSelection->GetShell();
+if (!presShell)
+return NS_OK;
+if (mFrameSelection->GetBatching())
+return NS_OK;
+if (!(aFlags & Selection::SCROLL_SYNCHRONOUS))
+return PostScrollSelectionIntoViewEvent(aRegion, aFlags,
+aVertical, aHorizontal);
+// Now that text frame character offsets are always valid (though not
+// necessarily correct), the worst that will happen if we don't flush here
+// is that some callers might scroll to the wrong place.  Those should
+// either manually flush if they're in a safe position for it or use the
+// async version of this method.
+if (aFlags & Selection::SCROLL_DO_FLUSH) {
+presShell->FlushPendingNotifications(Flush_Layout);
+// Reget the presshell, since it might have been Destroy'ed.
+presShell = mFrameSelection ? mFrameSelection->GetShell() : nullptr;
+if (!presShell)
+return NS_OK;
+}
+//
+// Scroll the selection region into view.
+//
+nsRect rect;
+nsIFrame* frame = GetSelectionAnchorGeometry(aRegion, &rect);
+if (!frame)
+return NS_ERROR_FAILURE;
+// Scroll vertically to get the caret into view, but only if the container
+// is perceived to be scrollable in that direction (i.e. there is a visible
+// vertical scrollbar or the scroll range is at least one device pixel)
+aVertical.mOnlyIfPerceivedScrollableDirection = true;
+uint32_t flags = 0;
+if (aFlags & Selection::SCROLL_FIRST_ANCESTOR_ONLY) {
+flags |= nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY;
+}
+if (aFlags & Selection::SCROLL_OVERFLOW_HIDDEN) {
+flags |= nsIPresShell::SCROLL_OVERFLOW_HIDDEN;
+}
+presShell->ScrollFrameRectIntoView(frame, rect, aVertical, aHorizontal,
+flags);
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::AddSelectionListener(nsISelectionListener* aNewListener)
+{
+if (!aNewListener)
+return NS_ERROR_NULL_POINTER;
+ErrorResult result;
+AddSelectionListener(aNewListener, result);
+if (result.Failed()) {
+return result.ErrorCode();
+}
+return NS_OK;
+}
+void
+Selection::AddSelectionListener(nsISelectionListener* aNewListener,
+ErrorResult& aRv)
+{
+bool result = mSelectionListeners.AppendObject(aNewListener); // AddRefs
+if (!result) {
+aRv.Throw(NS_ERROR_FAILURE);
+}
+}
+NS_IMETHODIMP
+Selection::RemoveSelectionListener(nsISelectionListener* aListenerToRemove)
+{
+if (!aListenerToRemove)
+return NS_ERROR_NULL_POINTER;
+ErrorResult result;
+RemoveSelectionListener(aListenerToRemove, result);
+if (result.Failed()) {
+return result.ErrorCode();
+}
+return NS_OK;
+}
+void
+Selection::RemoveSelectionListener(nsISelectionListener* aListenerToRemove,
+ErrorResult& aRv)
+{
+bool result = mSelectionListeners.RemoveObject(aListenerToRemove); // Releases
+if (!result) {
+aRv.Throw(NS_ERROR_FAILURE);
+}
+}
+nsresult
+Selection::NotifySelectionListeners()
+{
+if (!mFrameSelection)
+return NS_OK;//nothing to do
+if (mFrameSelection->GetBatching()) {
+mFrameSelection->SetDirty();
+return NS_OK;
+}
+nsCOMArray<nsISelectionListener> selectionListeners(mSelectionListeners);
+int32_t cnt = selectionListeners.Count();
+if (cnt != mSelectionListeners.Count()) {
+return NS_ERROR_OUT_OF_MEMORY;  // nsCOMArray is fallible
+}
+nsCOMPtr<nsIDOMDocument> domdoc;
+nsIPresShell* ps = GetPresShell();
+if (ps) {
+domdoc = do_QueryInterface(ps->GetDocument());
+}
+short reason = mFrameSelection->PopReason();
+for (int32_t i = 0; i < cnt; i++) {
+selectionListeners[i]->NotifySelectionChanged(domdoc, this, reason);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::StartBatchChanges()
+{
+if (mFrameSelection)
+mFrameSelection->StartBatchChanges();
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::EndBatchChanges()
+{
+if (mFrameSelection)
+mFrameSelection->EndBatchChanges();
+return NS_OK;
+}
+NS_IMETHODIMP
+Selection::DeleteFromDocument()
+{
+ErrorResult result;
+DeleteFromDocument(result);
+return result.ErrorCode();
+}
+void
+Selection::DeleteFromDocument(ErrorResult& aRv)
+{
+if (!mFrameSelection)
+return;//nothing to do
+nsresult rv = mFrameSelection->DeleteFromDocument();
+if (NS_FAILED(rv)) {
+aRv.Throw(rv);
+}
+}
+NS_IMETHODIMP
+Selection::Modify(const nsAString& aAlter, const nsAString& aDirection,
+const nsAString& aGranularity)
+{
+ErrorResult result;
+Modify(aAlter, aDirection, aGranularity, result);
+return result.ErrorCode();
+}
+void
+Selection::Modify(const nsAString& aAlter, const nsAString& aDirection,
+const nsAString& aGranularity, ErrorResult& aRv)
+{
+// Silently exit if there's no selection or no focus node.
+if (!mFrameSelection || !GetAnchorFocusRange() || !GetFocusNode()) {
+return;
+}
+if (!aAlter.LowerCaseEqualsLiteral("move") &&
+!aAlter.LowerCaseEqualsLiteral("extend")) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+if (!aDirection.LowerCaseEqualsLiteral("forward") &&
+!aDirection.LowerCaseEqualsLiteral("backward") &&
+!aDirection.LowerCaseEqualsLiteral("left") &&
+!aDirection.LowerCaseEqualsLiteral("right")) {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+// Line moves are always visual.
+bool visual  = aDirection.LowerCaseEqualsLiteral("left") ||
+aDirection.LowerCaseEqualsLiteral("right") ||
+aGranularity.LowerCaseEqualsLiteral("line");
+bool forward = aDirection.LowerCaseEqualsLiteral("forward") ||
+aDirection.LowerCaseEqualsLiteral("right");
+bool extend  = aAlter.LowerCaseEqualsLiteral("extend");
+// The uint32_t casts below prevent an enum mismatch warning.
+nsSelectionAmount amount;
+uint32_t keycode;
+if (aGranularity.LowerCaseEqualsLiteral("character")) {
+amount = eSelectCluster;
+keycode = forward ? (uint32_t) nsIDOMKeyEvent::DOM_VK_RIGHT :
+(uint32_t) nsIDOMKeyEvent::DOM_VK_LEFT;
+}
+else if (aGranularity.LowerCaseEqualsLiteral("word")) {
+amount = eSelectWordNoSpace;
+keycode = forward ? (uint32_t) nsIDOMKeyEvent::DOM_VK_RIGHT :
+(uint32_t) nsIDOMKeyEvent::DOM_VK_LEFT;
+}
+else if (aGranularity.LowerCaseEqualsLiteral("line")) {
+amount = eSelectLine;
+keycode = forward ? (uint32_t) nsIDOMKeyEvent::DOM_VK_DOWN :
+(uint32_t) nsIDOMKeyEvent::DOM_VK_UP;
+}
+else if (aGranularity.LowerCaseEqualsLiteral("lineboundary")) {
+amount = eSelectLine;
+keycode = forward ? (uint32_t) nsIDOMKeyEvent::DOM_VK_END :
+(uint32_t) nsIDOMKeyEvent::DOM_VK_HOME;
+}
+else if (aGranularity.LowerCaseEqualsLiteral("sentence") ||
+aGranularity.LowerCaseEqualsLiteral("sentenceboundary") ||
+aGranularity.LowerCaseEqualsLiteral("paragraph") ||
+aGranularity.LowerCaseEqualsLiteral("paragraphboundary") ||
+aGranularity.LowerCaseEqualsLiteral("documentboundary")) {
+aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
+}
+else {
+aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+return;
+}
+// If the anchor doesn't equal the focus and we try to move without first
+// collapsing the selection, MoveCaret will collapse the selection and quit.
+// To avoid this, we need to collapse the selection first.
+nsresult rv = NS_OK;
+if (!extend) {
+nsINode* focusNode = GetFocusNode();
+// We should have checked earlier that there was a focus node.
+if (!focusNode) {
+aRv.Throw(NS_ERROR_UNEXPECTED);
+return;
+}
+uint32_t focusOffset = FocusOffset();
+Collapse(focusNode, focusOffset);
+}
+// If the base level of the focused frame is odd, we may have to swap the
+// direction of the keycode.
+nsIFrame *frame;
+int32_t offset;
+rv = GetPrimaryFrameForFocusNode(&frame, &offset, visual);
+if (NS_SUCCEEDED(rv) && frame) {
+nsBidiLevel baseLevel = nsBidiPresUtils::GetFrameBaseLevel(frame);
+if (baseLevel & 1) {
+if (!visual && keycode == nsIDOMKeyEvent::DOM_VK_RIGHT) {
+keycode = nsIDOMKeyEvent::DOM_VK_LEFT;
+}
+else if (!visual && keycode == nsIDOMKeyEvent::DOM_VK_LEFT) {
+keycode = nsIDOMKeyEvent::DOM_VK_RIGHT;
+}
+else if (visual && keycode == nsIDOMKeyEvent::DOM_VK_HOME) {
+keycode = nsIDOMKeyEvent::DOM_VK_END;
+}
+else if (visual && keycode == nsIDOMKeyEvent::DOM_VK_END) {
+keycode = nsIDOMKeyEvent::DOM_VK_HOME;
+}
+}
+}
+// MoveCaret will return an error if it can't move in the specified
+// direction, but we just ignore this error unless it's a line move, in which
+// case we call nsISelectionController::CompleteMove to move the cursor to
+// the beginning/end of the line.
+rv = mFrameSelection->MoveCaret(keycode, extend, amount, visual);
+if (aGranularity.LowerCaseEqualsLiteral("line") && NS_FAILED(rv)) {
+nsCOMPtr<nsISelectionController> shell =
+do_QueryInterface(mFrameSelection->GetShell());
+if (!shell)
+return;
+shell->CompleteMove(forward, extend);
+}
+}
+/** SelectionLanguageChange modifies the cursor Bidi level after a change in keyboard direction
+*  @param aLangRTL is true if the new language is right-to-left or false if the new language is left-to-right
+*/
+NS_IMETHODIMP
+Selection::SelectionLanguageChange(bool aLangRTL)
+{
+if (!mFrameSelection)
+return NS_ERROR_NOT_INITIALIZED; // Can't do selection
+nsresult result;
+nsIFrame *focusFrame = 0;
+result = GetPrimaryFrameForFocusNode(&focusFrame, nullptr, false);
+if (NS_FAILED(result)) {
+return result;
+}
+if (!focusFrame) {
+return NS_ERROR_FAILURE;
+}
+int32_t frameStart, frameEnd;
+focusFrame->GetOffsets(frameStart, frameEnd);
+nsRefPtr<nsPresContext> context = GetPresContext();
+uint8_t levelBefore, levelAfter;
+if (!context) {
+return NS_ERROR_FAILURE;
+}
+uint8_t level = NS_GET_EMBEDDING_LEVEL(focusFrame);
+int32_t focusOffset = static_cast<int32_t>(FocusOffset());
+if ((focusOffset != frameStart) && (focusOffset != frameEnd))
+// the cursor is not at a frame boundary, so the level of both the characters (logically) before and after the cursor
+//  is equal to the frame level
+levelBefore = levelAfter = level;
+else {
+// the cursor is at a frame boundary, so use GetPrevNextBidiLevels to find the level of the characters
+//  before and after the cursor
+nsCOMPtr<nsIContent> focusContent = do_QueryInterface(GetFocusNode());
+/*
+nsFrameSelection::HINT hint;
+if ((focusOffset == frameStart && level)        // beginning of an RTL frame
+|| (focusOffset == frameEnd && !level)) {   // end of an LTR frame
+hint = nsFrameSelection::HINTRIGHT;
+}
+else {                                          // end of an RTL frame or beginning of an LTR frame
+hint = nsFrameSelection::HINTLEFT;
+}
+mFrameSelection->SetHint(hint);
+*/
+nsPrevNextBidiLevels levels = mFrameSelection->
+GetPrevNextBidiLevels(focusContent, focusOffset, false);
+levelBefore = levels.mLevelBefore;
+levelAfter = levels.mLevelAfter;
+}
+if ((levelBefore & 1) == (levelAfter & 1)) {
+// if cursor is between two characters with the same orientation, changing the keyboard language
+//  must toggle the cursor level between the level of the character with the lowest level
+//  (if the new language corresponds to the orientation of that character) and this level plus 1
+//  (if the new language corresponds to the opposite orientation)
+if ((level != levelBefore) && (level != levelAfter))
+level = std::min(levelBefore, levelAfter);
+if ((level & 1) == aLangRTL)
+mFrameSelection->SetCaretBidiLevel(level);
+else
+mFrameSelection->SetCaretBidiLevel(level + 1);
+}
+else {
+// if cursor is between characters with opposite orientations, changing the keyboard language must change
+//  the cursor level to that of the adjacent character with the orientation corresponding to the new language.
+if ((levelBefore & 1) == aLangRTL)
+mFrameSelection->SetCaretBidiLevel(levelBefore);
+else
+mFrameSelection->SetCaretBidiLevel(levelAfter);
+}
+// The caret might have moved, so invalidate the desired X position
+// for future usages of up-arrow or down-arrow
+mFrameSelection->InvalidateDesiredX();
+return NS_OK;
+}
+NS_IMETHODIMP_(nsDirection)
+Selection::GetSelectionDirection() {
+return mDirection;
+}
+NS_IMETHODIMP_(void)
+Selection::SetSelectionDirection(nsDirection aDirection) {
+mDirection = aDirection;
+}
+JSObject*
+Selection::WrapObject(JSContext* aCx)
+{
+return mozilla::dom::SelectionBinding::Wrap(aCx, this);
+}
+// nsAutoCopyListener
+nsAutoCopyListener* nsAutoCopyListener::sInstance = nullptr;
+NS_IMPL_ISUPPORTS(nsAutoCopyListener, nsISelectionListener)
+/*
+* What we do now:
+* On every selection change, we copy to the clipboard anew, creating a
+* HTML buffer, a transferable, an nsISupportsString and
+* a huge mess every time.  This is basically what nsPresShell::DoCopy does
+* to move the selection into the clipboard for Edit->Copy.
+*
+* What we should do, to make our end of the deal faster:
+* Create a singleton transferable with our own magic converter.  When selection
+* changes (use a quick cache to detect ``real'' changes), we put the new
+* nsISelection in the transferable.  Our magic converter will take care of
+* transferable->whatever-other-format when the time comes to actually
+* hand over the clipboard contents.
+*
+* Other issues:
+* - which X clipboard should we populate?
+* - should we use a different one than Edit->Copy, so that inadvertant
+*   selections (or simple clicks, which currently cause a selection
+*   notification, regardless of if they're in the document which currently has
+*   selection!) don't lose the contents of the ``application''?  Or should we
+*   just put some intelligence in the ``is this a real selection?'' code to
+*   protect our selection against clicks in other documents that don't create
+*   selections?
+* - maybe we should just never clear the X clipboard?  That would make this
+*   problem just go away, which is very tempting.
+*/
+NS_IMETHODIMP
+nsAutoCopyListener::NotifySelectionChanged(nsIDOMDocument *aDoc,
+nsISelection *aSel, int16_t aReason)
+{
+if (!(aReason & nsISelectionListener::MOUSEUP_REASON   ||
+aReason & nsISelectionListener::SELECTALL_REASON ||
+aReason & nsISelectionListener::KEYPRESS_REASON))
+return NS_OK; //dont care if we are still dragging
+bool collapsed;
+if (!aDoc || !aSel ||
+NS_FAILED(aSel->GetIsCollapsed(&collapsed)) || collapsed) {
+#ifdef DEBUG_CLIPBOARD
+fprintf(stderr, "CLIPBOARD: no selection/collapsed selection\n");
+#endif
+/* clear X clipboard? */
+return NS_OK;
+}
+nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
+NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
+// call the copy code
+return nsCopySupport::HTMLCopy(aSel, doc, nsIClipboard::kSelectionClipboard);
+}

The Tor Browser / file comparison

comparison: layout/generic/nsSelection.cpp

layout/generic/nsSelection.cpp