summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsSelection.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsSelection.cpp')
-rw-r--r--layout/generic/nsSelection.cpp6837
1 files changed, 6837 insertions, 0 deletions
diff --git a/layout/generic/nsSelection.cpp b/layout/generic/nsSelection.cpp
new file mode 100644
index 000000000..e0d65632e
--- /dev/null
+++ b/layout/generic/nsSelection.cpp
@@ -0,0 +1,6837 @@
+/* -*- 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 "nsDeviceContext.h"
+#include "nsIContent.h"
+#include "nsIDOMNode.h"
+#include "nsRange.h"
+#include "nsCOMArray.h"
+#include "nsITableCellLayout.h"
+#include "nsTArray.h"
+#include "nsTableWrapperFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsIContentIterator.h"
+#include "nsIDocumentEncoder.h"
+#include "nsTextFragment.h"
+#include <algorithm>
+#include "nsContentUtils.h"
+
+#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"
+
+#include "nsPresContext.h"
+#include "nsIPresShell.h"
+#include "nsCaret.h"
+#include "AccessibleCaretEventHub.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 "SelectionChangeListener.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"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/layers/ScrollInputMethods.h"
+#include "nsViewManager.h"
+
+#include "nsIEditor.h"
+#include "nsIHTMLEditor.h"
+#include "nsFocusManager.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using mozilla::layers::ScrollInputMethod;
+
+//#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
+
+/******************************************************************************
+ * Utility methods defined in nsISelectionController.idl
+ ******************************************************************************/
+
+namespace mozilla {
+
+const char*
+ToChar(SelectionType aSelectionType)
+{
+ switch (aSelectionType) {
+ case SelectionType::eInvalid:
+ return "SelectionType::eInvalid";
+ case SelectionType::eNone:
+ return "SelectionType::eNone";
+ case SelectionType::eNormal:
+ return "SelectionType::eNormal";
+ case SelectionType::eSpellCheck:
+ return "SelectionType::eSpellCheck";
+ case SelectionType::eIMERawClause:
+ return "SelectionType::eIMERawClause";
+ case SelectionType::eIMESelectedRawClause:
+ return "SelectionType::eIMESelectedRawClause";
+ case SelectionType::eIMEConvertedClause:
+ return "SelectionType::eIMEConvertedClause";
+ case SelectionType::eIMESelectedClause:
+ return "SelectionType::eIMESelectedClause";
+ case SelectionType::eAccessibility:
+ return "SelectionType::eAccessibility";
+ case SelectionType::eFind:
+ return "SelectionType::eFind";
+ case SelectionType::eURLSecondary:
+ return "SelectionType::eURLSecondary";
+ case SelectionType::eURLStrikeout:
+ return "SelectionType::eURLStrikeout";
+ default:
+ return "Invalid SelectionType";
+ }
+}
+
+static bool
+IsValidSelectionType(RawSelectionType aRawSelectionType)
+{
+ switch (static_cast<SelectionType>(aRawSelectionType)) {
+ case SelectionType::eNone:
+ case SelectionType::eNormal:
+ case SelectionType::eSpellCheck:
+ case SelectionType::eIMERawClause:
+ case SelectionType::eIMESelectedRawClause:
+ case SelectionType::eIMEConvertedClause:
+ case SelectionType::eIMESelectedClause:
+ case SelectionType::eAccessibility:
+ case SelectionType::eFind:
+ case SelectionType::eURLSecondary:
+ case SelectionType::eURLStrikeout:
+ return true;
+ default:
+ return false;
+ }
+}
+
+SelectionType
+ToSelectionType(RawSelectionType aRawSelectionType)
+{
+ if (!IsValidSelectionType(aRawSelectionType)) {
+ return SelectionType::eInvalid;
+ }
+ return static_cast<SelectionType>(aRawSelectionType);
+}
+
+RawSelectionType
+ToRawSelectionType(SelectionType aSelectionType)
+{
+ return static_cast<RawSelectionType>(aSelectionType);
+}
+
+bool operator &(SelectionType aSelectionType,
+ RawSelectionType aRawSelectionTypes)
+{
+ return (ToRawSelectionType(aSelectionType) & aRawSelectionTypes) != 0;
+}
+
+} // namespace mozilla
+
+/******************************************************************************
+ * nsPeekOffsetStruct
+ ******************************************************************************/
+
+//#define DEBUG_SELECTION // uncomment for printf describing every collapse and extend.
+//#define DEBUG_NAVIGATION
+
+
+//#define DEBUG_TABLE_SELECTION 1
+
+nsPeekOffsetStruct::nsPeekOffsetStruct(nsSelectionAmount aAmount,
+ nsDirection aDirection,
+ int32_t aStartOffset,
+ nsPoint aDesiredPos,
+ bool aJumpLines,
+ bool aScrollViewStop,
+ bool aIsKeyboardSelect,
+ bool aVisual,
+ bool aExtend,
+ EWordMovementType aWordMovementType)
+ : mAmount(aAmount)
+ , mDirection(aDirection)
+ , mStartOffset(aStartOffset)
+ , mDesiredPos(aDesiredPos)
+ , mWordMovementType(aWordMovementType)
+ , mJumpLines(aJumpLines)
+ , mScrollViewStop(aScrollViewStop)
+ , mIsKeyboardSelect(aIsKeyboardSelect)
+ , mVisual(aVisual)
+ , mExtend(aExtend)
+ , mResultContent()
+ , mResultFrame(nullptr)
+ , mContentOffset(0)
+ , mAttach(CARET_ASSOCIATE_BEFORE)
+{
+}
+
+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?
+};
+
+class nsAutoScrollTimer final : public nsITimerCallback
+{
+public:
+
+ NS_DECL_ISUPPORTS
+
+ nsAutoScrollTimer()
+ : mFrameSelection(0), mSelection(0), mPresContext(0), mPoint(0,0), mDelay(30)
+ {
+ }
+
+ // 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 = nullptr;
+ }
+
+ 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) 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());
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->HandleDrag(frame, pt);
+ if (!frame.IsAlive())
+ return NS_OK;
+
+ NS_ASSERTION(frame->PresContext() == mPresContext, "document mismatch?");
+ mSelection->DoAutoScroll(frame, pt);
+ }
+ return NS_OK;
+ }
+
+protected:
+ virtual ~nsAutoScrollTimer()
+ {
+ if (mTimer) {
+ mTimer->Cancel();
+ }
+ }
+
+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 aSelectionType)
+{
+ switch (aSelectionType) {
+ case SelectionType::eNormal:
+ return 0;
+ case SelectionType::eSpellCheck:
+ return 1;
+ case SelectionType::eIMERawClause:
+ return 2;
+ case SelectionType::eIMESelectedRawClause:
+ return 3;
+ case SelectionType::eIMEConvertedClause:
+ return 4;
+ case SelectionType::eIMESelectedClause:
+ return 5;
+ case SelectionType::eAccessibility:
+ return 6;
+ case SelectionType::eFind:
+ return 7;
+ case SelectionType::eURLSecondary:
+ return 8;
+ case SelectionType::eURLStrikeout:
+ return 9;
+ default:
+ return -1;
+ }
+ /* NOTREACHED */
+}
+
+static SelectionType
+GetSelectionTypeFromIndex(int8_t aIndex)
+{
+ static const SelectionType kSelectionTypes[] = {
+ SelectionType::eNormal,
+ SelectionType::eSpellCheck,
+ SelectionType::eIMERawClause,
+ SelectionType::eIMESelectedRawClause,
+ SelectionType::eIMEConvertedClause,
+ SelectionType::eIMESelectedClause,
+ SelectionType::eAccessibility,
+ SelectionType::eFind,
+ SelectionType::eURLSecondary,
+ SelectionType::eURLStrikeout
+ };
+ if (NS_WARN_IF(aIndex < 0) ||
+ NS_WARN_IF(static_cast<size_t>(aIndex) >= ArrayLength(kSelectionTypes))) {
+ return SelectionType::eNormal;
+ }
+ return kSelectionTypes[aIndex];
+}
+
+/*
+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);
+}
+
+namespace mozilla {
+struct MOZ_RAII AutoPrepareFocusRange
+{
+ AutoPrepareFocusRange(Selection* aSelection,
+ bool aContinueSelection,
+ bool aMultipleSelection
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+ {
+ MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+
+ if (aSelection->mRanges.Length() <= 1) {
+ return;
+ }
+
+ if (aSelection->mFrameSelection->IsUserSelectionReason()) {
+ mUserSelect.emplace(aSelection);
+ }
+ bool userSelection = aSelection->mUserInitiated;
+
+ nsTArray<RangeData>& ranges = aSelection->mRanges;
+ if (!userSelection ||
+ (!aContinueSelection && aMultipleSelection)) {
+ // Scripted command or the user is starting a new explicit multi-range
+ // selection.
+ for (RangeData& entry : ranges) {
+ entry.mRange->SetIsGenerated(false);
+ }
+ return;
+ }
+
+ int16_t reason = aSelection->mFrameSelection->mSelectionChangeReason;
+ bool isAnchorRelativeOp = (reason & (nsISelectionListener::DRAG_REASON |
+ nsISelectionListener::MOUSEDOWN_REASON |
+ nsISelectionListener::MOUSEUP_REASON |
+ nsISelectionListener::COLLAPSETOSTART_REASON));
+ if (!isAnchorRelativeOp) {
+ return;
+ }
+
+ // This operation is against the anchor but our current mAnchorFocusRange
+ // represents the focus in a multi-range selection. The anchor from a user
+ // perspective is the most distant generated range on the opposite side.
+ // Find that range and make it the mAnchorFocusRange.
+ const size_t len = ranges.Length();
+ size_t newAnchorFocusIndex = size_t(-1);
+ if (aSelection->GetDirection() == eDirNext) {
+ for (size_t i = 0; i < len; ++i) {
+ if (ranges[i].mRange->IsGenerated()) {
+ newAnchorFocusIndex = i;
+ break;
+ }
+ }
+ } else {
+ size_t i = len;
+ while (i--) {
+ if (ranges[i].mRange->IsGenerated()) {
+ newAnchorFocusIndex = i;
+ break;
+ }
+ }
+ }
+
+ if (newAnchorFocusIndex == size_t(-1)) {
+ // There are no generated ranges - that's fine.
+ return;
+ }
+
+ // Setup the new mAnchorFocusRange and mark the old one as generated.
+ if (aSelection->mAnchorFocusRange) {
+ aSelection->mAnchorFocusRange->SetIsGenerated(true);
+ }
+ nsRange* range = ranges[newAnchorFocusIndex].mRange;
+ range->SetIsGenerated(false);
+ aSelection->mAnchorFocusRange = range;
+
+ // Remove all generated ranges (including the old mAnchorFocusRange).
+ RefPtr<nsPresContext> presContext = aSelection->GetPresContext();
+ size_t i = len;
+ while (i--) {
+ range = aSelection->mRanges[i].mRange;
+ if (range->IsGenerated()) {
+ range->SetSelection(nullptr);
+ aSelection->selectFrames(presContext, range, false);
+ aSelection->mRanges.RemoveElementAt(i);
+ }
+ }
+ if (aSelection->mFrameSelection) {
+ aSelection->mFrameSelection->InvalidateDesiredPos();
+ }
+ }
+
+ Maybe<Selection::AutoUserInitiated> mUserSelect;
+ MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+};
+
+} // namespace mozilla
+
+////////////BEGIN nsFrameSelection methods
+
+nsFrameSelection::nsFrameSelection()
+{
+ for (size_t i = 0; i < kPresentSelectionTypeCount; i++){
+ mDomSelections[i] = new Selection(this);
+ mDomSelections[i]->SetType(GetSelectionTypeFromIndex(i));
+ }
+ mBatching = 0;
+ mChangesDuringBatching = false;
+ mNotifyFrames = true;
+
+ mMouseDoubleDownState = false;
+
+ mHint = CARET_ASSOCIATE_BEFORE;
+ mCaretBidiLevel = BIDI_LEVEL_UNDEFINED;
+ mKbdBidiLevel = NSBIDI_LTR;
+
+ mDragSelectingCells = false;
+ mSelectingTableCellMode = 0;
+ mSelectedCellIndex = 0;
+
+ nsAutoCopyListener *autoCopy = nullptr;
+ // On macOS, cache the current selection to send to osx service menu.
+#ifdef XP_MACOSX
+ autoCopy = nsAutoCopyListener::GetInstance(nsIClipboard::kSelectionCache);
+#endif
+
+ // Check to see if the autocopy pref is enabled
+ // and add the autocopy listener if it is
+ if (Preferences::GetBool("clipboard.autocopy")) {
+ autoCopy = nsAutoCopyListener::GetInstance(nsIClipboard::kSelectionClipboard);
+ }
+
+ if (autoCopy) {
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ 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;
+}
+
+nsFrameSelection::~nsFrameSelection()
+{
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsFrameSelection)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsFrameSelection)
+ for (size_t i = 0; i < kPresentSelectionTypeCount; ++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;
+ }
+ for (size_t i = 0; i < kPresentSelectionTypeCount; ++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)
+
+// Get the x (or y, in vertical writing mode) position requested
+// by the Key Handling for line-up/down
+nsresult
+nsFrameSelection::FetchDesiredPos(nsPoint &aDesiredPos)
+{
+ if (!mShell) {
+ NS_ERROR("fetch desired position failed");
+ return NS_ERROR_FAILURE;
+ }
+ if (mDesiredPosSet) {
+ aDesiredPos = mDesiredPos;
+ return NS_OK;
+ }
+
+ RefPtr<nsCaret> caret = mShell->GetCaret();
+ if (!caret) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ caret->SetSelection(mDomSelections[index]);
+
+ nsRect coord;
+ nsIFrame* caretFrame = caret->GetGeometry(&coord);
+ if (!caretFrame) {
+ return NS_ERROR_FAILURE;
+ }
+ nsPoint viewOffset(0, 0);
+ nsView* view = nullptr;
+ caretFrame->GetOffsetFromView(viewOffset, &view);
+ if (view) {
+ coord += viewOffset;
+ }
+ aDesiredPos = coord.TopLeft();
+ return NS_OK;
+}
+
+void
+nsFrameSelection::InvalidateDesiredPos() // do not listen to mDesiredPos;
+ // you must get another.
+{
+ mDesiredPosSet = false;
+}
+
+void
+nsFrameSelection::SetDesiredPos(nsPoint aPos)
+{
+ mDesiredPos = aPos;
+ mDesiredPosSet = 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(SelectionType::eNormal);
+ 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(nsBidiLevel 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;
+
+ RefPtr<nsCaret> caret;
+ if (mShell && (caret = mShell->GetCaret())) {
+ caret->SchedulePaint();
+ }
+
+ return;
+}
+
+nsBidiLevel
+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->NodeInfo()->NameAtom();
+}
+
+// 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;
+ mDragState = false;
+ mDesiredPosSet = false;
+ mLimiter = aLimiter;
+ mCaretMovementStyle =
+ Preferences::GetInt("bidi.edit.caret_movement_style", 2);
+
+ // This should only ever be initialized on the main thread, so we are OK here.
+ static bool prefCachesInitialized = false;
+ if (!prefCachesInitialized) {
+ prefCachesInitialized = true;
+
+ Preferences::AddBoolVarCache(&sSelectionEventsEnabled,
+ "dom.select_events.enabled", false);
+ Preferences::AddBoolVarCache(&sSelectionEventsOnTextControlsEnabled,
+ "dom.select_events.textcontrols.enabled", false);
+ }
+
+ RefPtr<AccessibleCaretEventHub> eventHub = mShell->GetAccessibleCaretEventHub();
+ if (eventHub) {
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ if (mDomSelections[index]) {
+ mDomSelections[index]->AddSelectionListener(eventHub);
+ }
+ }
+
+ nsIDocument* doc = aShell->GetDocument();
+ if (sSelectionEventsEnabled ||
+ (doc && nsContentUtils::IsSystemPrincipal(doc->NodePrincipal()))) {
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ if (mDomSelections[index]) {
+ // The Selection instance will hold a strong reference to its selectionchangelistener
+ // so we don't have to worry about that!
+ RefPtr<SelectionChangeListener> listener = new SelectionChangeListener;
+ mDomSelections[index]->AddSelectionListener(listener);
+ }
+ }
+}
+
+bool nsFrameSelection::sSelectionEventsEnabled = false;
+bool nsFrameSelection::sSelectionEventsOnTextControlsEnabled = false;
+
+nsresult
+nsFrameSelection::MoveCaret(nsDirection aDirection,
+ bool aContinueSelection,
+ nsSelectionAmount aAmount,
+ CaretMovementStyle aMovementStyle)
+{
+ bool visualMovement = aMovementStyle == eVisual ||
+ (aMovementStyle == eUsePrefStyle &&
+ (mCaretMovementStyle == 1 ||
+ (mCaretMovementStyle == 2 && !aContinueSelection)));
+
+ 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;
+ nsPoint desiredPos(0, 0); //we must keep this around and revalidate it when its just UP/DOWN
+
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ RefPtr<Selection> sel = mDomSelections[index];
+ if (!sel)
+ return NS_ERROR_NULL_POINTER;
+
+ int32_t scrollFlags = Selection::SCROLL_FOR_CARET_MOVE;
+ 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;
+ }
+
+ int32_t caretStyle = Preferences::GetInt("layout.selection.caret_style", 0);
+ if (caretStyle == 0
+#ifdef XP_WIN
+ && aAmount != eSelectLine
+#endif
+ ) {
+ // Put caret at the selection edge in the |aDirection| direction.
+ caretStyle = 2;
+ }
+
+ bool doCollapse = !isCollapsed && !aContinueSelection && caretStyle == 2 &&
+ aAmount <= eSelectLine;
+ if (doCollapse) {
+ if (aDirection == eDirPrevious) {
+ PostReason(nsISelectionListener::COLLAPSETOSTART_REASON);
+ mHint = CARET_ASSOCIATE_AFTER;
+ } else {
+ PostReason(nsISelectionListener::COLLAPSETOEND_REASON);
+ mHint = CARET_ASSOCIATE_BEFORE;
+ }
+ } else {
+ PostReason(nsISelectionListener::KEYPRESS_REASON);
+ }
+
+ AutoPrepareFocusRange prep(sel, aContinueSelection, false);
+
+ if (aAmount == eSelectLine) {
+ result = FetchDesiredPos(desiredPos);
+ if (NS_FAILED(result)) {
+ return result;
+ }
+ SetDesiredPos(desiredPos);
+ }
+
+ if (doCollapse) {
+ const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();
+ if (anchorFocusRange) {
+ nsINode* node;
+ int32_t offset;
+ if (aDirection == eDirPrevious) {
+ node = anchorFocusRange->GetStartParent();
+ offset = anchorFocusRange->StartOffset();
+ } else {
+ node = anchorFocusRange->GetEndParent();
+ offset = anchorFocusRange->EndOffset();
+ }
+ sel->Collapse(node, offset);
+ }
+ 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,
+ visualMovement);
+
+ 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, desiredPos,
+ true, mLimiter != nullptr, true, visualMovement,
+ aContinueSelection);
+
+ nsBidiDirection paraDir = nsBidiPresUtils::ParagraphDirection(frame);
+
+ CaretAssociateHint tHint(mHint); //temporary variable so we dont set mHint until it is necessary
+ switch (aAmount){
+ case eSelectCharacter:
+ case eSelectCluster:
+ case eSelectWord:
+ case eSelectWordNoSpace:
+ InvalidateDesiredPos();
+ pos.mAmount = aAmount;
+ pos.mDirection = (visualMovement && paraDir == NSBIDI_RTL)
+ ? nsDirection(1 - aDirection) : aDirection;
+ break;
+ case eSelectLine:
+ pos.mAmount = aAmount;
+ pos.mDirection = aDirection;
+ break;
+ case eSelectBeginLine:
+ case eSelectEndLine:
+ InvalidateDesiredPos();
+ pos.mAmount = aAmount;
+ pos.mDirection = (visualMovement && paraDir == NSBIDI_RTL)
+ ? nsDirection(1 - aDirection) : aDirection;
+ break;
+ default:
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_SUCCEEDED(result = frame->PeekOffset(&pos)) && pos.mResultContent)
+ {
+ nsIFrame *theFrame;
+ int32_t currentOffset, frameStart, frameEnd;
+
+ if (aAmount <= eSelectWordNoSpace)
+ {
+ // 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 ASSOCIATE_BEFORE 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 = CARET_ASSOCIATE_BEFORE;
+ else
+ tHint = CARET_ASSOCIATE_AFTER;
+ } 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 = pos.mAttach;
+ theFrame = GetFrameForNodeOffset(pos.mResultContent, pos.mContentOffset,
+ tHint, &currentOffset);
+ if (!theFrame)
+ return NS_ERROR_FAILURE;
+
+ theFrame->GetOffsets(frameStart, frameEnd);
+ }
+
+ if (context->BidiEnabled())
+ {
+ switch (aAmount) {
+ case eSelectBeginLine:
+ case eSelectEndLine: {
+ // In Bidi contexts, PeekOffset calculates pos.mContentOffset
+ // differently depending on whether the movement is visual or logical.
+ // For visual movement, pos.mContentOffset depends on the direction-
+ // ality of the first/last frame on the line (theFrame), and the caret
+ // directionality must correspond.
+ FrameBidiData bidiData = theFrame->GetBidiData();
+ SetCaretBidiLevel(visualMovement ? bidiData.embeddingLevel
+ : bidiData.baseLevel);
+ 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(theFrame->GetEmbeddingLevel());
+ }
+ else {
+ BidiLevelFromMove(mShell, pos.mResultContent, pos.mContentOffset,
+ aAmount, tHint);
+ }
+ }
+ }
+ result = TakeFocus(pos.mResultContent, pos.mContentOffset, pos.mContentOffset,
+ tHint, aContinueSelection, false);
+ } else if (aAmount <= eSelectWordNoSpace && aDirection == eDirNext &&
+ !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 = CARET_ASSOCIATE_BEFORE; // 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.StealNSResult();
+ }
+ 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.StealNSResult();
+ }
+ return NS_OK;
+}
+
+void
+Selection::SetInterlinePosition(bool aHintRight, ErrorResult& aRv)
+{
+ if (!mFrameSelection) {
+ aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection
+ return;
+ }
+ mFrameSelection->SetHint(aHintRight ? CARET_ASSOCIATE_AFTER : CARET_ASSOCIATE_BEFORE);
+}
+
+NS_IMETHODIMP
+Selection::GetInterlinePosition(bool* aHintRight)
+{
+ ErrorResult result;
+ *aHintRight = GetInterlinePosition(result);
+ if (result.Failed()) {
+ return result.StealNSResult();
+ }
+ 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() == CARET_ASSOCIATE_AFTER;
+}
+
+Nullable<int16_t>
+Selection::GetCaretBidiLevel(mozilla::ErrorResult& aRv) const
+{
+ if (!mFrameSelection) {
+ aRv.Throw(NS_ERROR_NOT_INITIALIZED);
+ return Nullable<int16_t>();
+ }
+ nsBidiLevel caretBidiLevel = mFrameSelection->GetCaretBidiLevel();
+ return (caretBidiLevel & BIDI_LEVEL_UNDEFINED) ?
+ Nullable<int16_t>() : Nullable<int16_t>(caretBidiLevel);
+}
+
+void
+Selection::SetCaretBidiLevel(const Nullable<int16_t>& aCaretBidiLevel, mozilla::ErrorResult& aRv)
+{
+ if (!mFrameSelection) {
+ aRv.Throw(NS_ERROR_NOT_INITIALIZED);
+ return;
+ }
+ if (aCaretBidiLevel.IsNull()) {
+ mFrameSelection->UndefineCaretBidiLevel();
+ } else {
+ mFrameSelection->SetCaretBidiLevel(aCaretBidiLevel.Value());
+ }
+}
+
+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,
+ CaretAssociateHint 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
+ nsBidiLevel currentLevel = currentFrame->GetEmbeddingLevel();
+ levels.SetData(currentFrame, currentFrame, currentLevel, currentLevel);
+ return levels;
+ }
+
+ nsIFrame *newFrame;
+ int32_t offset;
+ bool jumpedLine, movedOverNonSelectableText;
+ nsresult rv = currentFrame->GetFrameFromDirection(direction, false,
+ aJumpLines, true,
+ &newFrame, &offset, &jumpedLine,
+ &movedOverNonSelectableText);
+ if (NS_FAILED(rv))
+ newFrame = nullptr;
+
+ FrameBidiData currentBidi = currentFrame->GetBidiData();
+ nsBidiLevel currentLevel = currentBidi.embeddingLevel;
+ nsBidiLevel newLevel = newFrame ? newFrame->GetEmbeddingLevel()
+ : currentBidi.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 = currentBidi.baseLevel;
+ }
+ if (newFrame && newFrame->GetType() == nsGkAtoms::brFrame) {
+ newFrame = nullptr;
+ newLevel = currentBidi.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,
+ nsBidiLevel aBidiLevel,
+ nsIFrame **aFrameOut) const
+{
+ NS_ENSURE_STATE(mShell);
+ nsBidiLevel 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
+ false // aSkipPopupChecks
+ );
+ 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 = foundFrame->GetEmbeddingLevel();
+
+ } while (foundLevel > aBidiLevel);
+
+ return NS_OK;
+}
+
+
+nsresult
+nsFrameSelection::MaintainSelection(nsSelectionAmount aAmount)
+{
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ mMaintainedAmount = aAmount;
+
+ const nsRange* anchorFocusRange =
+ mDomSelections[index]->GetAnchorFocusRange();
+ if (anchorFocusRange && aAmount != eSelectNoAmount) {
+ 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 aAmount is the amount of the move that gave the caret its 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,
+ nsSelectionAmount aAmount,
+ CaretAssociateHint aHint)
+{
+ switch (aAmount) {
+
+ // Movement within the line: the new cursor Bidi level is the level of the
+ // last character moved over
+ case eSelectCharacter:
+ case eSelectCluster:
+ case eSelectWord:
+ case eSelectWordNoSpace:
+ case eSelectBeginLine:
+ case eSelectEndLine:
+ case eSelectNoAmount:
+ {
+ nsPrevNextBidiLevels levels = GetPrevNextBidiLevels(aNode, aContentOffset,
+ aHint, false);
+
+ SetCaretBidiLevel(aHint == CARET_ASSOCIATE_BEFORE ?
+ levels.mLevelBefore : levels.mLevelAfter);
+ break;
+ }
+ /*
+ // Up and Down: the new cursor Bidi level is the smaller of the two surrounding characters
+ case eSelectLine:
+ case eSelectParagraph:
+ 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(clickInFrame->GetEmbeddingLevel());
+}
+
+
+bool
+nsFrameSelection::AdjustForMaintainedSelection(nsIContent *aContent,
+ int32_t aOffset)
+{
+ if (!mMaintainRange)
+ return false;
+
+ if (!aContent) {
+ return false;
+ }
+
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ 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,
+ CaretAssociateHint aHint)
+{
+ if (!aNewFocus)
+ return NS_ERROR_INVALID_ARG;
+
+ InvalidateDesiredPos();
+
+ 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.
+
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ AutoPrepareFocusRange prep(mDomSelections[index], aContinueSelection, aMultipleSelection);
+ return TakeFocus(aNewFocus, aContentOffset, aContentEndOffset, 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,
+ CARET_ASSOCIATE_AFTER, &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,
+ nsPoint(0, 0), false, mLimiter != nullptr,
+ false, false, false);
+ if (NS_SUCCEEDED(frame->PeekOffset(&charPos))) {
+ frame = charPos.mResultFrame;
+ offset = charPos.mContentOffset;
+ }
+ }
+
+ nsPeekOffsetStruct pos(amount, direction, offset, nsPoint(0, 0),
+ false, mLimiter != nullptr, false, 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.associate);
+}
+
+nsresult
+nsFrameSelection::StartAutoScrollTimer(nsIFrame *aFrame,
+ nsPoint aPoint,
+ uint32_t aDelay)
+{
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ return mDomSelections[index]->StartAutoScrollTimer(aFrame, aPoint, aDelay);
+}
+
+void
+nsFrameSelection::StopAutoScrollTimer()
+{
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ 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,
+ CaretAssociateHint 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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ Maybe<Selection::AutoUserInitiated> userSelect;
+ if (IsUserSelectionReason()) {
+ userSelect.emplace(mDomSelections[index]);
+ }
+
+ //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();
+
+ RefPtr<nsRange> newRange = new nsRange(aNewFocus);
+
+ newRange->SetStart(aNewFocus, aContentOffset);
+ newRange->SetEnd(aNewFocus, aContentOffset);
+ mDomSelections[index]->AddRange(newRange);
+ mBatching = batching;
+ mChangesDuringBatching = changes;
+ } else {
+ bool oldDesiredPosSet = mDesiredPosSet; //need to keep old desired position if it was set.
+ mDomSelections[index]->Collapse(aNewFocus, aContentOffset);
+ mDesiredPosSet = oldDesiredPosSet; //now reset desired pos 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);
+ bool editableCell = false;
+ RefPtr<nsPresContext> context = mShell->GetPresContext();
+ if (context) {
+ nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(nsContentUtils::GetHTMLEditor(context));
+ if (editor) {
+ nsINode* cellparent = GetCellParent(aNewFocus);
+ nsCOMPtr<nsINode> editorHostNode = editor->GetActiveEditingHost();
+ editableCell = cellparent && editorHostNode &&
+ nsContentUtils::ContentIsDescendantOf(cellparent, editorHostNode);
+ if (editableCell) {
+ mCellParent = cellparent;
+#ifdef DEBUG_TABLE_SELECTION
+ 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, eVoidEvent, 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.mModifiers &= ~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(SelectionType::eNormal);
+}
+
+
+SelectionDetails*
+nsFrameSelection::LookUpSelection(nsIContent *aContent,
+ int32_t aContentOffset,
+ int32_t aContentLength,
+ bool aSlowCheck) const
+{
+ if (!aContent || !mShell)
+ return nullptr;
+
+ SelectionDetails* details = nullptr;
+
+ for (size_t j = 0; j < kPresentSelectionTypeCount; j++) {
+ if (mDomSelections[j]) {
+ mDomSelections[j]->LookUpSelection(aContent, aContentOffset,
+ aContentLength, &details,
+ ToSelectionType(1 << j),
+ aSlowCheck);
+ }
+ }
+
+ return details;
+}
+
+void
+nsFrameSelection::SetDragState(bool aState)
+{
+ if (mDragState == aState)
+ return;
+
+ mDragState = aState;
+
+ if (!mDragState)
+ {
+ mDragSelectingCells = false;
+ // Notify that reason is mouse up.
+ PostReason(nsISelectionListener::MOUSEUP_REASON);
+ NotifySelectionListeners(SelectionType::eNormal);
+ }
+}
+
+Selection*
+nsFrameSelection::GetSelection(SelectionType aSelectionType) const
+{
+ int8_t index = GetIndexFromSelectionType(aSelectionType);
+ if (index < 0)
+ return nullptr;
+
+ return mDomSelections[index];
+}
+
+nsresult
+nsFrameSelection::ScrollSelectionIntoView(SelectionType aSelectionType,
+ SelectionRegion aRegion,
+ int16_t aFlags) const
+{
+ int8_t index = GetIndexFromSelectionType(aSelectionType);
+ 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);
+ }
+ if (aFlags & nsISelectionController::SCROLL_FOR_CARET_MOVE) {
+ flags |= Selection::SCROLL_FOR_CARET_MOVE;
+ }
+
+ // After ScrollSelectionIntoView(), the pending notifications might be
+ // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
+ RefPtr<Selection> sel = mDomSelections[index];
+ return sel->ScrollIntoView(aRegion, verticalScroll,
+ nsIPresShell::ScrollAxis(), flags);
+}
+
+nsresult
+nsFrameSelection::RepaintSelection(SelectionType aSelectionType)
+{
+ int8_t index = GetIndexFromSelectionType(aSelectionType);
+ if (index < 0)
+ return NS_ERROR_INVALID_ARG;
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+ NS_ENSURE_STATE(mShell);
+
+// On macOS, update the selection cache to the new active selection
+// aka the current selection.
+#ifdef XP_MACOSX
+ nsFocusManager* fm = nsFocusManager::GetFocusManager();
+ // Check an active window exists otherwise there cannot be a current selection
+ // and that it's a normal selection.
+ if (fm->GetActiveWindow() && aSelectionType == SelectionType::eNormal) {
+ UpdateSelectionCacheOnRepaintSelection(mDomSelections[index]);
+ }
+#endif
+ return mDomSelections[index]->Repaint(mShell->GetPresContext());
+}
+
+nsIFrame*
+nsFrameSelection::GetFrameForNodeOffset(nsIContent* aNode,
+ int32_t aOffset,
+ CaretAssociateHint aHint,
+ int32_t* aReturnOffset) const
+{
+ if (!aNode || !aReturnOffset || !mShell)
+ return nullptr;
+
+ if (aOffset < 0)
+ return nullptr;
+
+ if (!aNode->GetPrimaryFrame() &&
+ !mShell->FrameManager()->GetDisplayContentsStyleFor(aNode)) {
+ return nullptr;
+ }
+
+ nsIFrame* returnFrame = nullptr;
+ nsCOMPtr<nsIContent> theNode;
+
+ while (true) {
+ *aReturnOffset = aOffset;
+
+ theNode = aNode;
+
+ if (aNode->IsElement()) {
+ int32_t childIndex = 0;
+ int32_t numChildren = theNode->GetChildCount();
+
+ if (aHint == CARET_ASSOCIATE_BEFORE) {
+ if (aOffset > 0) {
+ childIndex = aOffset - 1;
+ } else {
+ childIndex = aOffset;
+ }
+ } else {
+ NS_ASSERTION(aHint == CARET_ASSOCIATE_AFTER, "unknown direction");
+ 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) {
+ break;
+ }
+
+ theNode = childNode;
+ }
+
+ // Now that we have the child node, check if it too
+ // can contain children. If so, descend into child.
+ if (theNode->IsElement() &&
+ theNode->GetChildCount() &&
+ !theNode->HasIndependentSelection()) {
+ aNode = theNode;
+ aOffset = aOffset > childIndex ? theNode->GetChildCount() : 0;
+ continue;
+ } else {
+ // 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)) {
+ break;
+ }
+
+ *aReturnOffset = (int32_t)textLength;
+ } else {
+ *aReturnOffset = 0;
+ }
+ } else {
+ int32_t numChildren = aNode->GetChildCount();
+ int32_t newChildIndex =
+ aHint == CARET_ASSOCIATE_BEFORE ? childIndex - 1 : childIndex + 1;
+
+ if (newChildIndex >= 0 && newChildIndex < numChildren) {
+ nsCOMPtr<nsIContent> newChildNode = aNode->GetChildAt(newChildIndex);
+ if (!newChildNode) {
+ return nullptr;
+ }
+
+ aNode = newChildNode;
+ aOffset = aHint == CARET_ASSOCIATE_BEFORE ? aNode->GetChildCount() : 0;
+ continue;
+ } else {
+ // newChildIndex is illegal which means we're at first or last
+ // child. Just use original node to get the frame.
+ 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();
+ }
+
+ returnFrame = theNode->GetPrimaryFrame();
+ if (!returnFrame) {
+ if (aHint == CARET_ASSOCIATE_BEFORE) {
+ if (aOffset > 0) {
+ --aOffset;
+ continue;
+ } else {
+ break;
+ }
+ } else {
+ int32_t end = theNode->GetChildCount();
+ if (aOffset < end) {
+ ++aOffset;
+ continue;
+ } else {
+ break;
+ }
+ }
+ }
+
+ break;
+ } // end while
+
+ if (!returnFrame)
+ return nullptr;
+
+ // If we ended up here and were asked to position the caret after a visible
+ // break, let's return the frame on the next line instead if it exists.
+ if (aOffset > 0 && (uint32_t) aOffset >= aNode->Length() &&
+ theNode == aNode->GetLastChild()) {
+ nsIFrame* newFrame;
+ nsLayoutUtils::IsInvisibleBreak(theNode, &newFrame);
+ if (newFrame) {
+ returnFrame = newFrame;
+ *aReturnOffset = 0;
+ }
+ }
+
+ // find the child frame containing the offset we want
+ returnFrame->GetChildFrameContainingOffset(*aReturnOffset, aHint == CARET_ASSOCIATE_AFTER,
+ &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 mDesiredPos value of nsFrameSelection, but I havent seen that behavior in other windows applications yet.
+ nsISelection* domSel = GetSelection(SelectionType::eNormal);
+ if (!domSel) {
+ return;
+ }
+
+ nsRect caretPos;
+ nsIFrame* caretFrame = nsCaret::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
+ mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
+ (uint32_t) ScrollInputMethod::MainThreadScrollPage);
+ aScrollableFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),
+ nsIScrollableFrame::PAGES,
+ nsIScrollableFrame::SMOOTH);
+
+ // place the caret
+ HandleClick(offsets.content, offsets.offset,
+ offsets.offset, aExtend, false, CARET_ASSOCIATE_AFTER);
+}
+
+nsresult
+nsFrameSelection::PhysicalMove(int16_t aDirection, int16_t aAmount,
+ bool aExtend)
+{
+ 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;
+ }
+
+ // Check that parameters are safe
+ if (aDirection < 0 || aDirection > 3 || aAmount < 0 || aAmount > 1) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsPresContext *context = mShell->GetPresContext();
+ if (!context) {
+ return NS_ERROR_FAILURE;
+ }
+
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ RefPtr<Selection> sel = mDomSelections[index];
+ if (!sel) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ // Map the abstract movement amounts (0-1) to direction-specific
+ // selection units.
+ static const nsSelectionAmount inlineAmount[] =
+ { eSelectCluster, eSelectWord };
+ static const nsSelectionAmount blockPrevAmount[] =
+ { eSelectLine, eSelectBeginLine };
+ static const nsSelectionAmount blockNextAmount[] =
+ { eSelectLine, eSelectEndLine };
+
+ struct PhysicalToLogicalMapping {
+ nsDirection direction;
+ const nsSelectionAmount *amounts;
+ };
+ static const PhysicalToLogicalMapping verticalLR[4] = {
+ { eDirPrevious, blockPrevAmount }, // left
+ { eDirNext, blockNextAmount }, // right
+ { eDirPrevious, inlineAmount }, // up
+ { eDirNext, inlineAmount } // down
+ };
+ static const PhysicalToLogicalMapping verticalRL[4] = {
+ { eDirNext, blockNextAmount },
+ { eDirPrevious, blockPrevAmount },
+ { eDirPrevious, inlineAmount },
+ { eDirNext, inlineAmount }
+ };
+ static const PhysicalToLogicalMapping horizontal[4] = {
+ { eDirPrevious, inlineAmount },
+ { eDirNext, inlineAmount },
+ { eDirPrevious, blockPrevAmount },
+ { eDirNext, blockNextAmount }
+ };
+
+ WritingMode wm;
+ nsIFrame *frame = nullptr;
+ int32_t offsetused = 0;
+ if (NS_SUCCEEDED(sel->GetPrimaryFrameForFocusNode(&frame, &offsetused,
+ true))) {
+ if (frame) {
+ if (!frame->StyleContext()->IsTextCombined()) {
+ wm = frame->GetWritingMode();
+ } else {
+ // Using different direction for horizontal-in-vertical would
+ // make it hard to navigate via keyboard. Inherit the moving
+ // direction from its parent.
+ MOZ_ASSERT(frame->GetType() == nsGkAtoms::textFrame);
+ wm = frame->GetParent()->GetWritingMode();
+ MOZ_ASSERT(wm.IsVertical(), "Text combined "
+ "can only appear in vertical text");
+ }
+ }
+ }
+
+ const PhysicalToLogicalMapping& mapping =
+ wm.IsVertical()
+ ? wm.IsVerticalLR() ? verticalLR[aDirection] : verticalRL[aDirection]
+ : horizontal[aDirection];
+
+ nsresult rv = MoveCaret(mapping.direction, aExtend, mapping.amounts[aAmount],
+ eVisual);
+ if (NS_FAILED(rv)) {
+ // If we tried to do a line move, but couldn't move in the given direction,
+ // then we'll "promote" this to a line-edge move instead.
+ if (mapping.amounts[aAmount] == eSelectLine) {
+ rv = MoveCaret(mapping.direction, aExtend, mapping.amounts[aAmount + 1],
+ eVisual);
+ }
+ // And if it was a next-word move that failed (which can happen when
+ // eat_space_to_next_word is true, see bug 1153237), then just move forward
+ // to the line-edge.
+ else if (mapping.amounts[aAmount] == eSelectWord &&
+ mapping.direction == eDirNext) {
+ rv = MoveCaret(eDirNext, aExtend, eSelectEndLine, eVisual);
+ }
+ }
+
+ return rv;
+}
+
+nsresult
+nsFrameSelection::CharacterMove(bool aForward, bool aExtend)
+{
+ return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectCluster,
+ eUsePrefStyle);
+}
+
+nsresult
+nsFrameSelection::CharacterExtendForDelete()
+{
+ return MoveCaret(eDirNext, true, eSelectCluster, eLogical);
+}
+
+nsresult
+nsFrameSelection::CharacterExtendForBackspace()
+{
+ return MoveCaret(eDirPrevious, true, eSelectCharacter, eLogical);
+}
+
+nsresult
+nsFrameSelection::WordMove(bool aForward, bool aExtend)
+{
+ return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectWord,
+ eUsePrefStyle);
+}
+
+nsresult
+nsFrameSelection::WordExtendForDelete(bool aForward)
+{
+ return MoveCaret(aForward ? eDirNext : eDirPrevious, true, eSelectWord,
+ eLogical);
+}
+
+nsresult
+nsFrameSelection::LineMove(bool aForward, bool aExtend)
+{
+ return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectLine,
+ eUsePrefStyle);
+}
+
+nsresult
+nsFrameSelection::IntraLineMove(bool aForward, bool aExtend)
+{
+ if (aForward) {
+ return MoveCaret(eDirNext, aExtend, eSelectEndLine, eLogical);
+ } else {
+ return MoveCaret(eDirPrevious, aExtend, eSelectBeginLine, eLogical);
+ }
+}
+
+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);
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ AutoPrepareFocusRange prep(mDomSelections[index], false, false);
+ return TakeFocus(rootContent, 0, numChildren, CARET_ASSOCIATE_BEFORE, false, false);
+}
+
+//////////END FRAMESELECTION
+
+void
+nsFrameSelection::StartBatchChanges()
+{
+ mBatching++;
+}
+
+void
+nsFrameSelection::EndBatchChanges(int16_t aReason)
+{
+ mBatching--;
+ NS_ASSERTION(mBatching >=0,"Bad mBatching");
+
+ if (mBatching == 0 && mChangesDuringBatching) {
+ int16_t postReason = PopReason() | aReason;
+ PostReason(postReason);
+ mChangesDuringBatching = false;
+ NotifySelectionListeners(SelectionType::eNormal);
+ }
+}
+
+
+nsresult
+nsFrameSelection::NotifySelectionListeners(SelectionType aSelectionType)
+{
+ int8_t index = GetIndexFromSelectionType(aSelectionType);
+ 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->IsAnyOfHTMLElements(nsGkAtoms::td, nsGkAtoms::th);
+}
+
+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(SelectionType::eNormal);
+ 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 (mDragState && 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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ mDomSelections[index]->SetDirection(eDirNext);
+
+ // Stack-class to wrap all table selection changes in
+ // BeginBatchChanges() / EndBatchChanges()
+ SelectionBatcher selectionBatcher(mDomSelections[index]);
+
+ int32_t startRowIndex, startColIndex, curRowIndex, curColIndex;
+ if (mDragState && 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 = %p, mEndSelectedCell = %p, childContent = %p \n",
+ mStartSelectedCell.get(), mEndSelectedCell.get(), 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 (mDragState)
+ {
+#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=%p\n",
+ mDragSelectingCells, mStartSelectedCell.get());
+#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=%p\n",
+ mAppendStartSelectedCell.get());
+#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.
+ RefPtr<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;
+
+ 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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ nsTableWrapperFrame* 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
+ RefPtr<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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ nsTableWrapperFrame* 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
+ nsTableWrapperFrame* 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(SelectionType::eNormal);
+ 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(SelectionType::eNormal);
+ 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->IsHTMLElement(nsGkAtoms::table)) {
+ 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->IsHTMLElement())) {
+ // 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;
+ }
+
+ if (startContent->IsHTMLElement(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;
+
+ if (child->IsHTMLElement(nsGkAtoms::table))
+ *aTableSelectionType = nsISelectionPrivate::TABLESELECTION_TABLE;
+ else if (child->IsHTMLElement(nsGkAtoms::tr))
+ *aTableSelectionType = nsISelectionPrivate::TABLESELECTION_ROW;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+nsFrameSelection::CreateAndAddRange(nsINode *aParentNode, int32_t aOffset)
+{
+ if (!aParentNode) return NS_ERROR_NULL_POINTER;
+
+ RefPtr<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(SelectionType::eNormal);
+ 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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return;
+
+ if (!IsValidSelectionPoint(this, mDomSelections[index]->GetFocusNode())) {
+ ClearNormalSelection();
+ if (mAncestorLimiter) {
+ PostReason(nsISelectionListener::NO_REASON);
+ TakeFocus(mAncestorLimiter, 0, 0, CARET_ASSOCIATE_BEFORE, 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(SelectionType::eNormal);
+ if (!mDomSelections[index])
+ return NS_ERROR_NULL_POINTER;
+
+ mDomSelections[index]->GetIsCollapsed( &isCollapsed);
+ if (isCollapsed)
+ {
+ return NS_OK;
+ }
+
+ RefPtr<Selection> selection = mDomSelections[index];
+ for (uint32_t rangeIdx = 0; rangeIdx < selection->RangeCount(); ++rangeIdx) {
+ RefPtr<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->mClickCount;
+ } else {
+ mDelayedMouseEventValid = false;
+ }
+}
+
+void
+nsFrameSelection::DisconnectFromPresShell()
+{
+ RefPtr<AccessibleCaretEventHub> eventHub = mShell->GetAccessibleCaretEventHub();
+ if (eventHub) {
+ int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+ mDomSelections[index]->RemoveSelectionListener(eventHub);
+ }
+
+ StopAutoScrollTimer();
+ for (size_t i = 0; i < kPresentSelectionTypeCount; 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)
+ , mSelectionType(SelectionType::eNormal)
+ , mUserInitiated(false)
+ , mSelectionChangeBlockerCount(0)
+{
+}
+
+Selection::Selection(nsFrameSelection* aList)
+ : mFrameSelection(aList)
+ , mCachedOffsetForFrame(nullptr)
+ , mDirection(eDirNext)
+ , mSelectionType(SelectionType::eNormal)
+ , mUserInitiated(false)
+ , mSelectionChangeBlockerCount(0)
+{
+}
+
+Selection::~Selection()
+{
+ setAnchorFocusRange(-1);
+
+ uint32_t count = mRanges.Length();
+ for (uint32_t i = 0; i < count; ++i) {
+ mRanges[i].mRange->SetSelection(nullptr);
+ }
+
+ 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)
+
+// 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->GetComposedDoc() != start->GetComposedDoc() ||
+ !start->GetComposedDoc()) {
+ *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->GetComposedDoc() != end->GetComposedDoc() ||
+ !end->GetComposedDoc()) {
+ *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
+ RefPtr<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
+ RefPtr<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;
+}
+
+void
+Selection::UserSelectRangesToAdd(nsRange* aItem, nsTArray<RefPtr<nsRange>>& aRangesToAdd)
+{
+ aItem->ExcludeNonSelectableNodes(&aRangesToAdd);
+ if (aRangesToAdd.IsEmpty()) {
+ ErrorResult err;
+ nsINode* node = aItem->GetStartContainer(err);
+ if (node && node->IsContent() && node->AsContent()->GetEditingHost()) {
+ // A contenteditable node with user-select:none, for example.
+ // Allow it to have a collapsed selection (for the caret).
+ aItem->Collapse(GetDirection() == eDirPrevious);
+ aRangesToAdd.AppendElement(aItem);
+ }
+ }
+}
+
+nsresult
+Selection::AddItem(nsRange* aItem, int32_t* aOutIndex, bool aNoStartSelect)
+{
+ if (!aItem)
+ return NS_ERROR_NULL_POINTER;
+ if (!aItem->IsPositioned())
+ return NS_ERROR_UNEXPECTED;
+
+ NS_ASSERTION(aOutIndex, "aOutIndex can't be null");
+
+ if (mUserInitiated) {
+ AutoTArray<RefPtr<nsRange>, 4> rangesToAdd;
+ *aOutIndex = -1;
+
+ nsIDocument* doc = GetParentObject();
+ bool selectEventsEnabled =
+ nsFrameSelection::sSelectionEventsEnabled ||
+ (doc && nsContentUtils::IsSystemPrincipal(doc->NodePrincipal()));
+
+ if (!aNoStartSelect &&
+ mSelectionType == SelectionType::eNormal &&
+ selectEventsEnabled && Collapsed() &&
+ !IsBlockingSelectionChangeEvents()) {
+ // First, we generate the ranges to add with a scratch range, which is a
+ // clone of the original range passed in. We do this seperately, because the
+ // selectstart event could have caused the world to change, and required
+ // ranges to be re-generated
+ RefPtr<nsRange> scratchRange = aItem->CloneRange();
+ UserSelectRangesToAdd(scratchRange, rangesToAdd);
+ bool newRangesNonEmpty = rangesToAdd.Length() > 1 ||
+ (rangesToAdd.Length() == 1 && !rangesToAdd[0]->Collapsed());
+
+ MOZ_ASSERT(!newRangesNonEmpty || nsContentUtils::IsSafeToRunScript());
+ if (newRangesNonEmpty && nsContentUtils::IsSafeToRunScript()) {
+ // We consider a selection to be starting if we are currently collapsed,
+ // and the selection is becoming uncollapsed, and this is caused by a user
+ // initiated event.
+ bool defaultAction = true;
+
+ // The spec currently doesn't say that we should dispatch this event
+ // on text controls, so for now we only support doing that under a
+ // pref, disabled by default.
+ // See https://github.com/w3c/selection-api/issues/53.
+ bool dispatchEvent = true;
+ nsCOMPtr<nsINode> target = aItem->GetStartParent();
+ if (nsFrameSelection::sSelectionEventsOnTextControlsEnabled) {
+ // Get the first element which isn't in a native anonymous subtree
+ while (target && target->IsInNativeAnonymousSubtree()) {
+ target = target->GetParent();
+ }
+ } else {
+ if (target->IsInNativeAnonymousSubtree()) {
+ // This is a selection under a text control, so don't dispatch the
+ // event.
+ dispatchEvent = false;
+ }
+ }
+
+ if (dispatchEvent) {
+ nsContentUtils::DispatchTrustedEvent(GetParentObject(), target,
+ NS_LITERAL_STRING("selectstart"),
+ true, true, &defaultAction);
+
+ if (!defaultAction) {
+ return NS_OK;
+ }
+
+ // As we just dispatched an event to the DOM, something could have
+ // changed under our feet. Re-generate the rangesToAdd array, and ensure
+ // that the range we are about to add is still valid.
+ if (!aItem->IsPositioned()) {
+ return NS_ERROR_UNEXPECTED;
+ }
+ }
+ }
+
+ // The scratch ranges we generated may be invalid now, throw them out
+ rangesToAdd.ClearAndRetainStorage();
+ }
+
+ // Generate the ranges to add
+ UserSelectRangesToAdd(aItem, rangesToAdd);
+ size_t newAnchorFocusIndex =
+ GetDirection() == eDirPrevious ? 0 : rangesToAdd.Length() - 1;
+ for (size_t i = 0; i < rangesToAdd.Length(); ++i) {
+ int32_t index;
+ nsresult rv = AddItemInternal(rangesToAdd[i], &index);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (i == newAnchorFocusIndex) {
+ *aOutIndex = index;
+ rangesToAdd[i]->SetIsGenerated(false);
+ } else {
+ rangesToAdd[i]->SetIsGenerated(true);
+ }
+ }
+ return NS_OK;
+ }
+ return AddItemInternal(aItem, aOutIndex);
+}
+
+nsresult
+Selection::AddItemInternal(nsRange* aItem, int32_t* aOutIndex)
+{
+ MOZ_ASSERT(aItem);
+ MOZ_ASSERT(aItem->IsPositioned());
+ MOZ_ASSERT(aOutIndex);
+
+ *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->SetSelection(this);
+
+ *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->SetSelection(this);
+ *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->SetSelection(nullptr);
+ }
+ 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->SetSelection(this);
+ }
+
+ *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->SetSelection(nullptr);
+ 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->SetSelection(nullptr);
+ 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 = ToRawSelectionType(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<RefPtr<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.StealNSResult();
+ }
+ *aResultCount = results.Length();
+ if (*aResultCount == 0) {
+ return NS_OK;
+ }
+
+ *aResults = static_cast<nsIDOMRange**>
+ (moz_xmalloc(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<RefPtr<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;
+
+ CaretAssociationHint hint = mFrameSelection->GetHint();
+
+ if (aVisual) {
+ nsBidiLevel caretBidiLevel = mFrameSelection->GetCaretBidiLevel();
+
+ return nsCaret::GetCaretFrameForNodeOffset(mFrameSelection,
+ 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, mSelectionType);
+ }
+ // 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, mSelectionType);
+ } 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());
+ if (!content) {
+ // Don't warn, bug 1055722
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // 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,
+ mSelectionType);
+ }
+ }
+
+ 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,
+ mSelectionType);
+ }
+ }
+ }
+ 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 aSelectionType,
+ 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->mSelectionType = aSelectionType;
+ 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::GetAncestorLimiter(nsIContent** aContent)
+{
+ if (mFrameSelection) {
+ nsCOMPtr<nsIContent> c = mFrameSelection->GetAncestorLimiter();
+ c.forget(aContent);
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+Selection::SetAncestorLimiter(nsIContent* aContent)
+{
+ if (mFrameSelection) {
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->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();
+ nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
+ nsRootPresContext* rootPC = presContext->GetRootPresContext();
+ if (!rootPC)
+ return NS_OK;
+ nsIFrame* rootmostFrame = rootPC->PresShell()->FrameManager()->GetRootFrame();
+ nsWeakFrame weakRootFrame(rootmostFrame);
+ nsWeakFrame weakFrame(aFrame);
+ // 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 done = false;
+ bool didScroll;
+ while (true) {
+ didScroll = shell->ScrollFrameRectIntoView(
+ aFrame, nsRect(aPoint, nsSize(0, 0)),
+ nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis(),
+ 0);
+ if (!weakFrame || !weakRootFrame) {
+ return NS_OK;
+ }
+ if (!didScroll && !done) {
+ // If aPoint is at the screen edge then try to scroll anyway, once.
+ RefPtr<nsDeviceContext> dx = shell->GetViewManager()->GetDeviceContext();
+ nsRect screen;
+ dx->GetRect(screen);
+ nsPoint screenPoint = globalPoint +
+ rootmostFrame->GetScreenRectInAppUnits().TopLeft();
+ nscoord onePx = nsPresContext::AppUnitsPerCSSPixel();
+ nscoord scrollAmount = 10 * onePx;
+ if (std::abs(screen.x - screenPoint.x) <= onePx) {
+ aPoint.x -= scrollAmount;
+ } else if (std::abs(screen.XMost() - screenPoint.x) <= onePx) {
+ aPoint.x += scrollAmount;
+ } else if (std::abs(screen.y - screenPoint.y) <= onePx) {
+ aPoint.y -= scrollAmount;
+ } else if (std::abs(screen.YMost() - screenPoint.y) <= onePx) {
+ aPoint.y += scrollAmount;
+ } else {
+ break;
+ }
+ done = true;
+ continue;
+ }
+ break;
+ }
+
+ // Start the AutoScroll timer if necessary.
+ if (didScroll && mAutoScrollTimer) {
+ nsPoint presContextPoint = globalPoint -
+ shell->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.StealNSResult();
+}
+
+void
+Selection::RemoveAllRanges(ErrorResult& aRv)
+{
+ if (!mFrameSelection)
+ return; // nothing to do
+ RefPtr<nsPresContext> presContext = GetPresContext();
+ nsresult result = Clear(presContext);
+ if (NS_FAILED(result)) {
+ aRv.Throw(result);
+ return;
+ }
+
+ // Turn off signal for table selection
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->ClearTableCellSelection();
+
+ result = frameSelection->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.StealNSResult();
+}
+
+void
+Selection::AddRange(nsRange& aRange, ErrorResult& aRv)
+{
+ return AddRangeInternal(aRange, GetParentObject(), aRv);
+}
+
+void
+Selection::AddRangeInternal(nsRange& aRange, nsIDocument* aDocument,
+ ErrorResult& aRv)
+{
+ nsINode* rangeRoot = aRange.GetRoot();
+ if (aDocument != rangeRoot && (!rangeRoot ||
+ aDocument != rangeRoot->GetComposedDoc())) {
+ // http://w3c.github.io/selection-api/#dom-selection-addrange
+ // "... if the root of the range's boundary points are the document
+ // associated with context object. Otherwise, this method must do nothing."
+ return;
+ }
+
+ // 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;
+ }
+ }
+
+ if (rangeIndex < 0) {
+ return;
+ }
+
+ setAnchorFocusRange(rangeIndex);
+
+ // Make sure the caret appears on the next line, if at a newline
+ if (mSelectionType == SelectionType::eNormal) {
+ SetInterlinePosition(true);
+ }
+
+ RefPtr<nsPresContext> presContext = GetPresContext();
+ selectFrames(presContext, &aRange, true);
+
+ if (!mFrameSelection)
+ return;//nothing to do
+
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ result = frameSelection->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.StealNSResult();
+}
+
+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
+ RefPtr<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 (mSelectionType != SelectionType::eSpellCheck && cnt > 0) {
+ ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION);
+ }
+ }
+
+ if (!mFrameSelection)
+ return;//nothing to do
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ rv = frameSelection->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.StealNSResult();
+}
+
+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> parentNode = &aParentNode;
+
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->InvalidateDesiredPos();
+ if (!IsValidSelectionPoint(frameSelection, parentNode)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+ nsresult result;
+
+ RefPtr<nsPresContext> presContext = GetPresContext();
+ if (!presContext || presContext->Document() != parentNode->OwnerDoc()) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ // Delete all of the current ranges
+ Clear(presContext);
+
+ // Turn off signal for table selection
+ frameSelection->ClearTableCellSelection();
+
+ // Hack to display the caret on the right line (bug 1237236).
+ if (frameSelection->GetHint() != CARET_ASSOCIATE_AFTER &&
+ parentNode->IsContent()) {
+ int32_t frameOffset;
+ nsTextFrame* f =
+ do_QueryFrame(nsCaret::GetFrameAndOffset(this, parentNode,
+ aOffset, &frameOffset));
+ if (f && f->IsAtEndOfLine() && f->HasSignificantTerminalNewline()) {
+ if ((parentNode->AsContent() == f->GetContent() &&
+ f->GetContentEnd() == int32_t(aOffset)) ||
+ (parentNode == f->GetContent()->GetParentNode() &&
+ parentNode->IndexOf(f->GetContent()) + 1 == int32_t(aOffset))) {
+ frameSelection->SetHint(CARET_ASSOCIATE_AFTER);
+ }
+ }
+ }
+
+ RefPtr<nsRange> range = new nsRange(parentNode);
+ result = range->SetEnd(parentNode, aOffset);
+ if (NS_FAILED(result)) {
+ aRv.Throw(result);
+ return;
+ }
+ result = range->SetStart(parentNode, aOffset);
+ if (NS_FAILED(result)) {
+ aRv.Throw(result);
+ return;
+ }
+
+#ifdef DEBUG_SELECTION
+ nsCOMPtr<nsIContent> content = do_QueryInterface(parentNode);
+ nsCOMPtr<nsIDocument> doc = do_QueryInterface(parentNode);
+ printf ("Sel. Collapse to %p %s %d\n", parentNode.get(),
+ content ? nsAtomCString(content->NodeInfo()->NameAtom()).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 = frameSelection->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.StealNSResult();
+}
+
+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.StealNSResult();
+}
+
+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() const
+{
+ 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.StealNSResult();
+}
+
+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) const
+{
+ RangeData empty(nullptr);
+ return mRanges.SafeElementAt(aIndex, empty).mRange;
+}
+
+/*
+utility function
+*/
+nsresult
+Selection::SetAnchorFocusToRange(nsRange* aRange)
+{
+ NS_ENSURE_STATE(mAnchorFocusRange);
+
+ bool collapsed = Collapsed();
+
+ nsresult res = RemoveItem(mAnchorFocusRange);
+ if (NS_FAILED(res))
+ return res;
+
+ int32_t aOutIndex = -1;
+ res = AddItem(aRange, &aOutIndex, !collapsed);
+ if (NS_FAILED(res))
+ return res;
+ setAnchorFocusRange(aOutIndex);
+
+ return NS_OK;
+}
+
+void
+Selection::ReplaceAnchorFocusRange(nsRange* aRange)
+{
+ NS_ENSURE_TRUE_VOID(mAnchorFocusRange);
+ RefPtr<nsPresContext> presContext = GetPresContext();
+ if (presContext) {
+ selectFrames(presContext, mAnchorFocusRange, false);
+ SetAnchorFocusToRange(aRange);
+ selectFrames(presContext, mAnchorFocusRange, true);
+ }
+}
+
+void
+Selection::AdjustAnchorFocusForMultiRange(nsDirection aDirection)
+{
+ if (aDirection == mDirection) {
+ return;
+ }
+ SetDirection(aDirection);
+
+ if (RangeCount() <= 1) {
+ return;
+ }
+
+ nsRange* firstRange = GetRangeAt(0);
+ nsRange* lastRange = GetRangeAt(RangeCount() - 1);
+
+ if (mDirection == eDirPrevious) {
+ firstRange->SetIsGenerated(false);
+ lastRange->SetIsGenerated(true);
+ setAnchorFocusRange(0);
+ } else { // aDir == eDirNext
+ firstRange->SetIsGenerated(true);
+ lastRange->SetIsGenerated(false);
+ setAnchorFocusRange(RangeCount() - 1);
+ }
+}
+
+/*
+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.StealNSResult();
+}
+
+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;
+ }
+
+ RefPtr<nsPresContext> presContext = GetPresContext();
+ if (!presContext || presContext->Document() != aParentNode.OwnerDoc()) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+#ifdef DEBUG_SELECTION
+ nsDirection oldDirection = GetDirection();
+#endif
+ nsINode* anchorNode = GetAnchorNode();
+ nsINode* focusNode = GetFocusNode();
+ uint32_t anchorOffset = AnchorOffset();
+ uint32_t focusOffset = FocusOffset();
+
+ RefPtr<nsRange> range = mAnchorFocusRange->CloneRange();
+
+ nsINode* startNode = range->GetStartParent();
+ nsINode* endNode = range->GetEndParent();
+ int32_t startOffset = range->StartOffset();
+ int32_t endOffset = range->EndOffset();
+
+ //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);
+ }
+
+ RefPtr<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;
+ }
+ SetDirection(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
+ SetDirection(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;
+ }
+ }
+ SetDirection(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;
+ }
+ SetDirection(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);
+ }
+ SetDirection(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;
+ }
+ SetDirection(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;
+ }
+ }
+
+ if (mRanges.Length() > 1) {
+ for (size_t i = 0; i < mRanges.Length(); ++i) {
+ nsRange* range = mRanges[i].mRange;
+ MOZ_ASSERT(range->IsInSelection());
+ selectFrames(presContext, range, range->IsInSelection());
+ }
+ }
+
+ DEBUG_OUT_RANGE(range);
+#ifdef DEBUG_SELECTION
+ if (GetDirection() != oldDirection) {
+ printf(" direction changed to %s\n",
+ GetDirection() == eDirNext? "eDirNext":"eDirPrevious");
+ }
+ nsCOMPtr<nsIContent> content = do_QueryInterface(&aParentNode);
+ printf ("Sel. Extend to %p %s %d\n", content.get(),
+ nsAtomCString(content->NodeInfo()->NameAtom()).get(), aOffset);
+#endif
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ res = frameSelection->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.StealNSResult();
+}
+
+void
+Selection::SelectAllChildren(nsINode& aNode, ErrorResult& aRv)
+{
+ if (mFrameSelection) {
+ mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
+ }
+ SelectionBatcher batch(this);
+
+ Collapse(aNode, 0, aRv);
+ if (aRv.Failed()) {
+ return;
+ }
+
+ 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);
+ if (!node) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ ErrorResult result;
+ *aYes = ContainsNode(*node, aAllowPartial, result);
+ return result.StealNSResult();
+}
+
+bool
+Selection::ContainsNode(nsINode& aNode, bool aAllowPartial, ErrorResult& aRv)
+{
+ nsresult rv;
+ if (mRanges.Length() == 0) {
+ 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;
+}
+
+class PointInRectChecker : public nsLayoutUtils::RectCallback {
+public:
+ explicit PointInRectChecker(const nsPoint& aPoint)
+ : mPoint(aPoint)
+ , mMatchFound(false)
+ {
+ }
+
+ void AddRect(const nsRect& aRect) override
+ {
+ mMatchFound = mMatchFound || aRect.Contains(mPoint);
+ }
+
+ bool MatchFound()
+ {
+ return mMatchFound;
+ }
+
+private:
+ nsPoint mPoint;
+ bool mMatchFound;
+};
+
+bool
+Selection::ContainsPoint(const nsPoint& aPoint)
+{
+ if (IsCollapsed()) {
+ return false;
+ }
+ PointInRectChecker checker(aPoint);
+ for (uint32_t i = 0; i < RangeCount(); i++) {
+ nsRange* range = GetRangeAt(i);
+ nsRange::CollectClientRectsAndText(&checker, nullptr, range,
+ range->GetStartParent(), range->StartOffset(),
+ range->GetEndParent(), range->EndOffset(),
+ true, false);
+ if (checker.MatchFound()) {
+ 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);
+ 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() == CARET_ASSOCIATE_BEFORE) {
+ // 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;
+
+ Selection* sel = mSelection; // workaround to satisfy static analysis
+ RefPtr<Selection> kungFuDeathGrip(sel);
+ 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();
+
+ RefPtr<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.StealNSResult();
+ }
+ 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;
+ }
+
+ if (aFlags & Selection::SCROLL_FOR_CARET_MOVE) {
+ mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
+ (uint32_t) ScrollInputMethod::MainThreadScrollCaretIntoView);
+ }
+
+ 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.StealNSResult();
+ }
+ 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.StealNSResult();
+ }
+ 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
+
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ if (frameSelection->GetBatching()) {
+ frameSelection->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 = frameSelection->PopReason();
+ for (int32_t i = 0; i < cnt; i++) {
+ selectionListeners[i]->NotifySelectionChanged(domdoc, this, reason);
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+Selection::StartBatchChanges()
+{
+ if (mFrameSelection) {
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->StartBatchChanges();
+ }
+ return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+Selection::EndBatchChanges()
+{
+ return EndBatchChangesInternal();
+}
+
+nsresult
+Selection::EndBatchChangesInternal(int16_t aReason)
+{
+ if (mFrameSelection) {
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ frameSelection->EndBatchChanges(aReason);
+ }
+ return NS_OK;
+}
+
+void
+Selection::AddSelectionChangeBlocker()
+{
+ mSelectionChangeBlockerCount++;
+}
+
+void
+Selection::RemoveSelectionChangeBlocker()
+{
+ MOZ_ASSERT(mSelectionChangeBlockerCount > 0,
+ "mSelectionChangeBlockerCount has an invalid value - "
+ "maybe you have a mismatched RemoveSelectionChangeBlocker?");
+ mSelectionChangeBlockerCount--;
+}
+
+bool
+Selection::IsBlockingSelectionChangeEvents() const
+{
+ return mSelectionChangeBlockerCount > 0;
+}
+
+NS_IMETHODIMP
+Selection::DeleteFromDocument()
+{
+ ErrorResult result;
+ DeleteFromDocument(result);
+ return result.StealNSResult();
+}
+
+void
+Selection::DeleteFromDocument(ErrorResult& aRv)
+{
+ if (!mFrameSelection)
+ return;//nothing to do
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ nsresult rv = frameSelection->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.StealNSResult();
+}
+
+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");
+
+ nsSelectionAmount amount;
+ if (aGranularity.LowerCaseEqualsLiteral("character")) {
+ amount = eSelectCluster;
+ } else if (aGranularity.LowerCaseEqualsLiteral("word")) {
+ amount = eSelectWordNoSpace;
+ } else if (aGranularity.LowerCaseEqualsLiteral("line")) {
+ amount = eSelectLine;
+ } else if (aGranularity.LowerCaseEqualsLiteral("lineboundary")) {
+ amount = forward ? eSelectEndLine : eSelectBeginLine;
+ } else if (aGranularity.LowerCaseEqualsLiteral("sentence") ||
+ aGranularity.LowerCaseEqualsLiteral("sentenceboundary") ||
+ aGranularity.LowerCaseEqualsLiteral("paragraph") ||
+ aGranularity.LowerCaseEqualsLiteral("paragraphboundary") ||
+ aGranularity.LowerCaseEqualsLiteral("documentboundary")) {
+ aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
+ return;
+ } 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 paragraph direction of the focused frame is right-to-left,
+ // we may have to swap the direction of movement.
+ nsIFrame *frame;
+ int32_t offset;
+ rv = GetPrimaryFrameForFocusNode(&frame, &offset, visual);
+ if (NS_SUCCEEDED(rv) && frame) {
+ nsBidiDirection paraDir = nsBidiPresUtils::ParagraphDirection(frame);
+
+ if (paraDir == NSBIDI_RTL && visual) {
+ if (amount == eSelectBeginLine) {
+ amount = eSelectEndLine;
+ forward = !forward;
+ } else if (amount == eSelectEndLine) {
+ amount = eSelectBeginLine;
+ forward = !forward;
+ }
+ }
+ }
+
+ // 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.
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+ rv = frameSelection->MoveCaret(forward ? eDirNext : eDirPrevious,
+ extend, amount,
+ visual ? nsFrameSelection::eVisual
+ : nsFrameSelection::eLogical);
+
+ if (aGranularity.LowerCaseEqualsLiteral("line") && NS_FAILED(rv)) {
+ nsCOMPtr<nsISelectionController> shell =
+ do_QueryInterface(frameSelection->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
+
+ RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
+
+ // if the direction of the language hasn't changed, nothing to do
+ nsBidiLevel kbdBidiLevel = aLangRTL ? NSBIDI_RTL : NSBIDI_LTR;
+ if (kbdBidiLevel == frameSelection->mKbdBidiLevel) {
+ return NS_OK;
+ }
+
+ frameSelection->mKbdBidiLevel = kbdBidiLevel;
+
+ 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);
+ RefPtr<nsPresContext> context = GetPresContext();
+ nsBidiLevel levelBefore, levelAfter;
+ if (!context) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsBidiLevel level = focusFrame->GetEmbeddingLevel();
+ 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());
+ nsPrevNextBidiLevels levels = frameSelection->
+ GetPrevNextBidiLevels(focusContent, focusOffset, false);
+
+ levelBefore = levels.mLevelBefore;
+ levelAfter = levels.mLevelAfter;
+ }
+
+ if (IS_SAME_DIRECTION(levelBefore, levelAfter)) {
+ // 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 (IS_SAME_DIRECTION(level, kbdBidiLevel))
+ frameSelection->SetCaretBidiLevel(level);
+ else
+ frameSelection->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 (IS_SAME_DIRECTION(levelBefore, kbdBidiLevel))
+ frameSelection->SetCaretBidiLevel(levelBefore);
+ else
+ frameSelection->SetCaretBidiLevel(levelAfter);
+ }
+
+ // The caret might have moved, so invalidate the desired position
+ // for future usages of up-arrow or down-arrow
+ frameSelection->InvalidateDesiredPos();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP_(nsDirection)
+Selection::GetSelectionDirection() {
+ return mDirection;
+}
+
+NS_IMETHODIMP_(void)
+Selection::SetSelectionDirection(nsDirection aDirection) {
+ mDirection = aDirection;
+}
+
+JSObject*
+Selection::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return mozilla::dom::SelectionBinding::Wrap(aCx, this, aGivenProto);
+}
+
+// AutoHideSelectionChanges
+AutoHideSelectionChanges::AutoHideSelectionChanges(const nsFrameSelection* aFrame)
+ : AutoHideSelectionChanges(
+ aFrame ? aFrame->GetSelection(SelectionType::eNormal) : nullptr)
+{}
+
+// 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.
+ *
+ * On macOS,
+ * nsIClipboard::kSelectionCache is the flag for current selection cache.
+ * Set the current selection cache on the parent process in
+ * widget cocoa nsClipboard whenever selection changes.
+ */
+
+NS_IMETHODIMP
+nsAutoCopyListener::NotifySelectionChanged(nsIDOMDocument *aDoc,
+ nsISelection *aSel, int16_t aReason)
+{
+ if (mCachedClipboard == nsIClipboard::kSelectionCache) {
+ nsFocusManager* fm = nsFocusManager::GetFocusManager();
+ // If no active window, do nothing because a current selection changed
+ // cannot occur unless it is in the active window.
+ if (!fm->GetActiveWindow()) {
+ return NS_OK;
+ }
+ }
+
+ 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
+ // If on macOS, clear the current selection transferable cached
+ // on the parent process (nsClipboard) when the selection is empty.
+ if (mCachedClipboard == nsIClipboard::kSelectionCache) {
+ return nsCopySupport::ClearSelectionCache();
+ }
+ /* 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,
+ mCachedClipboard, false);
+}
+
+/**
+ * See Bug 1288453.
+ *
+ * Update the selection cache on repaint to handle when a pre-existing
+ * selection becomes active aka the current selection.
+ *
+ * 1. Change the current selection by click n dragging another selection.
+ * - Make a selection on content page. Make a selection in a text editor.
+ * - You can click n drag the content selection to make it active again.
+ * 2. Change the current selection when switching to a tab with a selection.
+ * - Make selection in tab.
+ * - Switching tabs will make its respective selection active.
+ *
+ * Therefore, we only update the selection cache on a repaint
+ * if the current selection being repainted is not an empty selection.
+ *
+ * If the current selection is empty. The current selection cache
+ * would be cleared by nsAutoCopyListener::NotifySelectionChanged.
+ */
+nsresult
+nsFrameSelection::UpdateSelectionCacheOnRepaintSelection(Selection* aSel)
+{
+ nsIPresShell* ps = aSel->GetPresShell();
+ if (!ps) {
+ return NS_OK;
+ }
+ nsCOMPtr<nsIDocument> aDoc = ps->GetDocument();
+
+ bool collapsed;
+ if (aDoc && aSel &&
+ NS_SUCCEEDED(aSel->GetIsCollapsed(&collapsed)) && !collapsed) {
+ return nsCopySupport::HTMLCopy(aSel, aDoc,
+ nsIClipboard::kSelectionCache, false);
+ }
+
+ return NS_OK;
+}
+
+// SelectionChangeListener
+
+SelectionChangeListener::RawRangeData::RawRangeData(const nsRange* aRange)
+{
+ mozilla::ErrorResult rv;
+ mStartParent = aRange->GetStartContainer(rv);
+ rv.SuppressException();
+ mEndParent = aRange->GetEndContainer(rv);
+ rv.SuppressException();
+ mStartOffset = aRange->GetStartOffset(rv);
+ rv.SuppressException();
+ mEndOffset = aRange->GetEndOffset(rv);
+ rv.SuppressException();
+}
+
+bool
+SelectionChangeListener::RawRangeData::Equals(const nsRange* aRange)
+{
+ mozilla::ErrorResult rv;
+ bool eq = mStartParent == aRange->GetStartContainer(rv);
+ rv.SuppressException();
+ eq = eq && mEndParent == aRange->GetEndContainer(rv);
+ rv.SuppressException();
+ eq = eq && mStartOffset == aRange->GetStartOffset(rv);
+ rv.SuppressException();
+ eq = eq && mEndOffset == aRange->GetEndOffset(rv);
+ rv.SuppressException();
+ return eq;
+}
+
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+ SelectionChangeListener::RawRangeData& aField,
+ const char* aName,
+ uint32_t aFlags = 0)
+{
+ ImplCycleCollectionTraverse(aCallback, aField.mStartParent, "mStartParent", aFlags);
+ ImplCycleCollectionTraverse(aCallback, aField.mEndParent, "mEndParent", aFlags);
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(SelectionChangeListener)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SelectionChangeListener)
+ tmp->mOldRanges.Clear();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SelectionChangeListener)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOldRanges);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SelectionChangeListener)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(nsISelectionListener)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(SelectionChangeListener)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(SelectionChangeListener)
+
+NS_IMETHODIMP
+SelectionChangeListener::NotifySelectionChanged(nsIDOMDocument* aDoc,
+ nsISelection* aSel, int16_t aReason)
+{
+ RefPtr<Selection> sel = aSel->AsSelection();
+
+ nsIDocument* doc = sel->GetParentObject();
+ if (!(doc && nsContentUtils::IsSystemPrincipal(doc->NodePrincipal())) &&
+ !nsFrameSelection::sSelectionEventsEnabled) {
+ return NS_OK;
+ }
+
+ // Check if the ranges have actually changed
+ // Don't bother checking this if we are hiding changes.
+ if (mOldRanges.Length() == sel->RangeCount() && !sel->IsBlockingSelectionChangeEvents()) {
+ bool changed = false;
+
+ for (size_t i = 0; i < mOldRanges.Length(); i++) {
+ if (!mOldRanges[i].Equals(sel->GetRangeAt(i))) {
+ changed = true;
+ break;
+ }
+ }
+
+ if (!changed) {
+ return NS_OK;
+ }
+ }
+
+ // The ranges have actually changed, update the mOldRanges array
+ mOldRanges.ClearAndRetainStorage();
+ for (size_t i = 0; i < sel->RangeCount(); i++) {
+ mOldRanges.AppendElement(RawRangeData(sel->GetRangeAt(i)));
+ }
+
+ // If we are hiding changes, then don't do anything else. We do this after we
+ // update mOldRanges so that changes after the changes stop being hidden don't
+ // incorrectly trigger a change, even though they didn't change anything
+ if (sel->IsBlockingSelectionChangeEvents()) {
+ return NS_OK;
+ }
+
+ // The spec currently doesn't say that we should dispatch this event on text
+ // controls, so for now we only support doing that under a pref, disabled by
+ // default.
+ // See https://github.com/w3c/selection-api/issues/53.
+ if (nsFrameSelection::sSelectionEventsOnTextControlsEnabled) {
+ nsCOMPtr<nsINode> target;
+
+ // Check if we should be firing this event to a different node than the
+ // document. The limiter of the nsFrameSelection will be within the native
+ // anonymous subtree of the node we want to fire the event on. We need to
+ // climb up the parent chain to escape the native anonymous subtree, and then
+ // fire the event.
+ if (const nsFrameSelection* fs = sel->GetFrameSelection()) {
+ if (nsCOMPtr<nsIContent> root = fs->GetLimiter()) {
+ while (root && root->IsInNativeAnonymousSubtree()) {
+ root = root->GetParent();
+ }
+
+ target = root.forget();
+ }
+ }
+
+ // If we didn't get a target before, we can instead fire the event at the document.
+ if (!target) {
+ nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
+ target = doc.forget();
+ }
+
+ if (target) {
+ RefPtr<AsyncEventDispatcher> asyncDispatcher =
+ new AsyncEventDispatcher(target, NS_LITERAL_STRING("selectionchange"), false);
+ asyncDispatcher->PostDOMEvent();
+ }
+ } else {
+ if (const nsFrameSelection* fs = sel->GetFrameSelection()) {
+ if (nsCOMPtr<nsIContent> root = fs->GetLimiter()) {
+ if (root->IsInNativeAnonymousSubtree()) {
+ return NS_OK;
+ }
+ }
+ }
+
+ nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
+ if (doc) {
+ RefPtr<AsyncEventDispatcher> asyncDispatcher =
+ new AsyncEventDispatcher(doc, NS_LITERAL_STRING("selectionchange"), false);
+ asyncDispatcher->PostDOMEvent();
+ }
+ }
+
+ return NS_OK;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-02 20:02:43 +0000