428 lines
16 KiB
C++
428 lines
16 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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/. */
|
|
|
|
#ifndef mozilla_Selection_h__
|
|
#define mozilla_Selection_h__
|
|
|
|
#include "nsIWeakReference.h"
|
|
|
|
#include "mozilla/AutoRestore.h"
|
|
#include "mozilla/TextRange.h"
|
|
#include "nsISelection.h"
|
|
#include "nsISelectionController.h"
|
|
#include "nsISelectionListener.h"
|
|
#include "nsISelectionPrivate.h"
|
|
#include "nsRange.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsWrapperCache.h"
|
|
|
|
struct CachedOffsetForFrame;
|
|
class nsAutoScrollTimer;
|
|
class nsIContentIterator;
|
|
class nsIFrame;
|
|
class nsFrameSelection;
|
|
struct SelectionDetails;
|
|
class nsCopySupport;
|
|
class nsHTMLCopyEncoder;
|
|
|
|
namespace mozilla {
|
|
class ErrorResult;
|
|
struct AutoPrepareFocusRange;
|
|
namespace dom {
|
|
class DocGroup;
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
struct RangeData
|
|
{
|
|
explicit RangeData(nsRange* aRange)
|
|
: mRange(aRange)
|
|
{}
|
|
|
|
RefPtr<nsRange> mRange;
|
|
mozilla::TextRangeStyle mTextRangeStyle;
|
|
};
|
|
|
|
// Note, the ownership of mozilla::dom::Selection depends on which way the
|
|
// object is created. When nsFrameSelection has created Selection,
|
|
// addreffing/releasing the Selection object is aggregated to nsFrameSelection.
|
|
// Otherwise normal addref/release is used. This ensures that nsFrameSelection
|
|
// is never deleted before its Selections.
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class Selection final : public nsISelection,
|
|
public nsWrapperCache,
|
|
public nsISelectionPrivate,
|
|
public nsSupportsWeakReference
|
|
{
|
|
protected:
|
|
virtual ~Selection();
|
|
|
|
public:
|
|
Selection();
|
|
explicit Selection(nsFrameSelection *aList);
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Selection, nsISelection)
|
|
NS_DECL_NSISELECTION
|
|
NS_DECL_NSISELECTIONPRIVATE
|
|
|
|
virtual Selection* AsSelection() override { return this; }
|
|
|
|
nsresult EndBatchChangesInternal(int16_t aReason = nsISelectionListener::NO_REASON);
|
|
|
|
nsIDocument* GetParentObject() const;
|
|
DocGroup* GetDocGroup() const;
|
|
|
|
// utility methods for scrolling the selection into view
|
|
nsPresContext* GetPresContext() const;
|
|
nsIPresShell* GetPresShell() const;
|
|
nsFrameSelection* GetFrameSelection() const { return mFrameSelection; }
|
|
// Returns a rect containing the selection region, and frame that that
|
|
// position is relative to. For SELECTION_ANCHOR_REGION or
|
|
// SELECTION_FOCUS_REGION the rect is a zero-width rectangle. For
|
|
// SELECTION_WHOLE_SELECTION the rect contains both the anchor and focus
|
|
// region rects.
|
|
nsIFrame* GetSelectionAnchorGeometry(SelectionRegion aRegion, nsRect *aRect);
|
|
// Returns the position of the region (SELECTION_ANCHOR_REGION or
|
|
// SELECTION_FOCUS_REGION only), and frame that that position is relative to.
|
|
// The 'position' is a zero-width rectangle.
|
|
nsIFrame* GetSelectionEndPointGeometry(SelectionRegion aRegion, nsRect *aRect);
|
|
|
|
nsresult PostScrollSelectionIntoViewEvent(
|
|
SelectionRegion aRegion,
|
|
int32_t aFlags,
|
|
nsIPresShell::ScrollAxis aVertical,
|
|
nsIPresShell::ScrollAxis aHorizontal);
|
|
enum {
|
|
SCROLL_SYNCHRONOUS = 1<<1,
|
|
SCROLL_FIRST_ANCESTOR_ONLY = 1<<2,
|
|
SCROLL_DO_FLUSH = 1<<3, // only matters if SCROLL_SYNCHRONOUS is passed too
|
|
SCROLL_OVERFLOW_HIDDEN = 1<<5,
|
|
SCROLL_FOR_CARET_MOVE = 1<<6
|
|
};
|
|
// If aFlags doesn't contain SCROLL_SYNCHRONOUS, then we'll flush when
|
|
// the scroll event fires so we make sure to scroll to the right place.
|
|
// Otherwise, if SCROLL_DO_FLUSH is also in aFlags, then this method will
|
|
// flush layout and you MUST hold a strong ref on 'this' for the duration
|
|
// of this call. This might destroy arbitrary layout objects.
|
|
nsresult ScrollIntoView(SelectionRegion aRegion,
|
|
nsIPresShell::ScrollAxis aVertical =
|
|
nsIPresShell::ScrollAxis(),
|
|
nsIPresShell::ScrollAxis aHorizontal =
|
|
nsIPresShell::ScrollAxis(),
|
|
int32_t aFlags = 0);
|
|
nsresult SubtractRange(RangeData* aRange, nsRange* aSubtract,
|
|
nsTArray<RangeData>* aOutput);
|
|
/**
|
|
* AddItem adds aRange to this Selection. If mUserInitiated is true,
|
|
* then aRange is first scanned for -moz-user-select:none nodes and split up
|
|
* into multiple ranges to exclude those before adding the resulting ranges
|
|
* to this Selection.
|
|
*/
|
|
nsresult AddItem(nsRange* aRange, int32_t* aOutIndex, bool aNoStartSelect = false);
|
|
nsresult RemoveItem(nsRange* aRange);
|
|
nsresult RemoveCollapsedRanges();
|
|
nsresult Clear(nsPresContext* aPresContext);
|
|
nsresult Collapse(nsINode* aParentNode, int32_t aOffset);
|
|
nsresult Extend(nsINode* aParentNode, int32_t aOffset);
|
|
nsRange* GetRangeAt(int32_t aIndex) const;
|
|
|
|
// Get the anchor-to-focus range if we don't care which end is
|
|
// anchor and which end is focus.
|
|
const nsRange* GetAnchorFocusRange() const {
|
|
return mAnchorFocusRange;
|
|
}
|
|
|
|
nsDirection GetDirection(){return mDirection;}
|
|
void SetDirection(nsDirection aDir){mDirection = aDir;}
|
|
nsresult SetAnchorFocusToRange(nsRange *aRange);
|
|
void ReplaceAnchorFocusRange(nsRange *aRange);
|
|
void AdjustAnchorFocusForMultiRange(nsDirection aDirection);
|
|
|
|
// NS_IMETHOD GetPrimaryFrameForRangeEndpoint(nsIDOMNode *aNode, int32_t aOffset, bool aIsEndNode, nsIFrame **aResultFrame);
|
|
NS_IMETHOD GetPrimaryFrameForAnchorNode(nsIFrame **aResultFrame);
|
|
NS_IMETHOD GetPrimaryFrameForFocusNode(nsIFrame **aResultFrame, int32_t *aOffset, bool aVisual);
|
|
NS_IMETHOD LookUpSelection(nsIContent *aContent,
|
|
int32_t aContentOffset,
|
|
int32_t aContentLength,
|
|
SelectionDetails** aReturnDetails,
|
|
SelectionType aSelectionType,
|
|
bool aSlowCheck);
|
|
NS_IMETHOD Repaint(nsPresContext* aPresContext);
|
|
|
|
// Note: StartAutoScrollTimer might destroy arbitrary frames etc.
|
|
nsresult StartAutoScrollTimer(nsIFrame *aFrame,
|
|
nsPoint& aPoint,
|
|
uint32_t aDelay);
|
|
|
|
nsresult StopAutoScrollTimer();
|
|
|
|
JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
|
|
|
|
// WebIDL methods
|
|
nsINode* GetAnchorNode();
|
|
uint32_t AnchorOffset();
|
|
nsINode* GetFocusNode();
|
|
uint32_t FocusOffset();
|
|
|
|
bool IsCollapsed() const;
|
|
void Collapse(nsINode& aNode, uint32_t aOffset, mozilla::ErrorResult& aRv);
|
|
void CollapseToStart(mozilla::ErrorResult& aRv);
|
|
void CollapseToEnd(mozilla::ErrorResult& aRv);
|
|
|
|
void Extend(nsINode& aNode, uint32_t aOffset, mozilla::ErrorResult& aRv);
|
|
|
|
void SelectAllChildren(nsINode& aNode, mozilla::ErrorResult& aRv);
|
|
void DeleteFromDocument(mozilla::ErrorResult& aRv);
|
|
|
|
uint32_t RangeCount() const
|
|
{
|
|
return mRanges.Length();
|
|
}
|
|
|
|
void GetType(nsAString& aOutType) const;
|
|
|
|
nsRange* GetRangeAt(uint32_t aIndex, mozilla::ErrorResult& aRv);
|
|
void AddRange(nsRange& aRange, mozilla::ErrorResult& aRv);
|
|
void RemoveRange(nsRange& aRange, mozilla::ErrorResult& aRv);
|
|
void RemoveAllRanges(mozilla::ErrorResult& aRv);
|
|
|
|
void Stringify(nsAString& aResult);
|
|
|
|
bool ContainsNode(nsINode& aNode, bool aPartlyContained, mozilla::ErrorResult& aRv);
|
|
|
|
/**
|
|
* Check to see if the given point is contained within the selection area. In
|
|
* particular, this iterates through all the rects that make up the selection,
|
|
* not just the bounding box, and checks to see if the given point is contained
|
|
* in any one of them.
|
|
* @param aPoint The point to check, relative to the root frame.
|
|
*/
|
|
bool ContainsPoint(const nsPoint& aPoint);
|
|
|
|
void Modify(const nsAString& aAlter, const nsAString& aDirection,
|
|
const nsAString& aGranularity, mozilla::ErrorResult& aRv);
|
|
|
|
bool GetInterlinePosition(mozilla::ErrorResult& aRv);
|
|
void SetInterlinePosition(bool aValue, mozilla::ErrorResult& aRv);
|
|
|
|
Nullable<int16_t> GetCaretBidiLevel(mozilla::ErrorResult& aRv) const;
|
|
void SetCaretBidiLevel(const Nullable<int16_t>& aCaretBidiLevel, mozilla::ErrorResult& aRv);
|
|
|
|
void ToStringWithFormat(const nsAString& aFormatType,
|
|
uint32_t aFlags,
|
|
int32_t aWrapColumn,
|
|
nsAString& aReturn,
|
|
mozilla::ErrorResult& aRv);
|
|
void AddSelectionListener(nsISelectionListener* aListener,
|
|
mozilla::ErrorResult& aRv);
|
|
void RemoveSelectionListener(nsISelectionListener* aListener,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
RawSelectionType RawType() const
|
|
{
|
|
return ToRawSelectionType(mSelectionType);
|
|
}
|
|
SelectionType Type() const { return mSelectionType; }
|
|
|
|
void GetRangesForInterval(nsINode& aBeginNode, int32_t aBeginOffset,
|
|
nsINode& aEndNode, int32_t aEndOffset,
|
|
bool aAllowAdjacent,
|
|
nsTArray<RefPtr<nsRange>>& aReturn,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
void ScrollIntoView(int16_t aRegion, bool aIsSynchronous,
|
|
int16_t aVPercent, int16_t aHPercent,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
void AddSelectionChangeBlocker();
|
|
void RemoveSelectionChangeBlocker();
|
|
bool IsBlockingSelectionChangeEvents() const;
|
|
private:
|
|
friend class ::nsAutoScrollTimer;
|
|
|
|
// Note: DoAutoScroll might destroy arbitrary frames etc.
|
|
nsresult DoAutoScroll(nsIFrame *aFrame, nsPoint& aPoint);
|
|
|
|
// XXX Please don't add additional uses of this method, it's only for
|
|
// XXX supporting broken code (bug 1245883) in the following classes:
|
|
friend class ::nsCopySupport;
|
|
friend class ::nsHTMLCopyEncoder;
|
|
void AddRangeInternal(nsRange& aRange, nsIDocument* aDocument, ErrorResult&);
|
|
|
|
public:
|
|
SelectionType GetType() const { return mSelectionType; }
|
|
void SetType(SelectionType aSelectionType)
|
|
{
|
|
mSelectionType = aSelectionType;
|
|
}
|
|
|
|
nsresult NotifySelectionListeners();
|
|
|
|
friend struct AutoUserInitiated;
|
|
struct MOZ_RAII AutoUserInitiated
|
|
{
|
|
explicit AutoUserInitiated(Selection* aSelection
|
|
MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
|
|
: mSavedValue(aSelection->mUserInitiated)
|
|
{
|
|
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
|
aSelection->mUserInitiated = true;
|
|
}
|
|
AutoRestore<bool> mSavedValue;
|
|
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
|
|
};
|
|
|
|
private:
|
|
friend struct mozilla::AutoPrepareFocusRange;
|
|
class ScrollSelectionIntoViewEvent;
|
|
friend class ScrollSelectionIntoViewEvent;
|
|
|
|
class ScrollSelectionIntoViewEvent : public Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
ScrollSelectionIntoViewEvent(Selection* aSelection,
|
|
SelectionRegion aRegion,
|
|
nsIPresShell::ScrollAxis aVertical,
|
|
nsIPresShell::ScrollAxis aHorizontal,
|
|
int32_t aFlags)
|
|
: mSelection(aSelection),
|
|
mRegion(aRegion),
|
|
mVerticalScroll(aVertical),
|
|
mHorizontalScroll(aHorizontal),
|
|
mFlags(aFlags) {
|
|
NS_ASSERTION(aSelection, "null parameter");
|
|
}
|
|
void Revoke() { mSelection = nullptr; }
|
|
private:
|
|
Selection *mSelection;
|
|
SelectionRegion mRegion;
|
|
nsIPresShell::ScrollAxis mVerticalScroll;
|
|
nsIPresShell::ScrollAxis mHorizontalScroll;
|
|
int32_t mFlags;
|
|
};
|
|
|
|
void setAnchorFocusRange(int32_t aIndex); // pass in index into mRanges;
|
|
// negative value clears
|
|
// mAnchorFocusRange
|
|
nsresult SelectAllFramesForContent(nsIContentIterator *aInnerIter,
|
|
nsIContent *aContent,
|
|
bool aSelected);
|
|
nsresult selectFrames(nsPresContext* aPresContext, nsRange *aRange, bool aSelect);
|
|
nsresult getTableCellLocationFromRange(nsRange *aRange, int32_t *aSelectionType, int32_t *aRow, int32_t *aCol);
|
|
nsresult addTableCellRange(nsRange *aRange, bool *aDidAddRange, int32_t *aOutIndex);
|
|
|
|
nsresult FindInsertionPoint(
|
|
nsTArray<RangeData>* aElementArray,
|
|
nsINode* aPointNode, int32_t aPointOffset,
|
|
nsresult (*aComparator)(nsINode*,int32_t,nsRange*,int32_t*),
|
|
int32_t* aPoint);
|
|
bool EqualsRangeAtPoint(nsINode* aBeginNode, int32_t aBeginOffset,
|
|
nsINode* aEndNode, int32_t aEndOffset,
|
|
int32_t aRangeIndex);
|
|
nsresult GetIndicesForInterval(nsINode* aBeginNode, int32_t aBeginOffset,
|
|
nsINode* aEndNode, int32_t aEndOffset,
|
|
bool aAllowAdjacent,
|
|
int32_t* aStartIndex, int32_t* aEndIndex);
|
|
RangeData* FindRangeData(nsIDOMRange* aRange);
|
|
|
|
void UserSelectRangesToAdd(nsRange* aItem, nsTArray<RefPtr<nsRange> >& rangesToAdd);
|
|
|
|
/**
|
|
* Helper method for AddItem.
|
|
*/
|
|
nsresult AddItemInternal(nsRange* aRange, int32_t* aOutIndex);
|
|
|
|
// These are the ranges inside this selection. They are kept sorted in order
|
|
// of DOM start position.
|
|
//
|
|
// This data structure is sorted by the range beginnings. As the ranges are
|
|
// disjoint, it is also implicitly sorted by the range endings. This allows
|
|
// us to perform binary searches when searching for existence of a range,
|
|
// giving us O(log n) search time.
|
|
//
|
|
// Inserting a new range requires finding the overlapping interval, requiring
|
|
// two binary searches plus up to an additional 6 DOM comparisons. If this
|
|
// proves to be a performance concern, then an interval tree may be a
|
|
// possible solution, allowing the calculation of the overlap interval in
|
|
// O(log n) time, though this would require rebalancing and other overhead.
|
|
nsTArray<RangeData> mRanges;
|
|
|
|
RefPtr<nsRange> mAnchorFocusRange;
|
|
RefPtr<nsFrameSelection> mFrameSelection;
|
|
RefPtr<nsAutoScrollTimer> mAutoScrollTimer;
|
|
nsCOMArray<nsISelectionListener> mSelectionListeners;
|
|
nsRevocableEventPtr<ScrollSelectionIntoViewEvent> mScrollEvent;
|
|
CachedOffsetForFrame *mCachedOffsetForFrame;
|
|
nsDirection mDirection;
|
|
SelectionType mSelectionType;
|
|
/**
|
|
* True if the current selection operation was initiated by user action.
|
|
* It determines whether we exclude -moz-user-select:none nodes or not,
|
|
* as well as whether selectstart events will be fired.
|
|
*/
|
|
bool mUserInitiated;
|
|
|
|
// Non-zero if we don't want any changes we make to the selection to be
|
|
// visible to content. If non-zero, content won't be notified about changes.
|
|
uint32_t mSelectionChangeBlockerCount;
|
|
};
|
|
|
|
// Stack-class to turn on/off selection batching.
|
|
class MOZ_STACK_CLASS SelectionBatcher final
|
|
{
|
|
private:
|
|
RefPtr<Selection> mSelection;
|
|
public:
|
|
explicit SelectionBatcher(Selection* aSelection)
|
|
{
|
|
mSelection = aSelection;
|
|
if (mSelection) {
|
|
mSelection->StartBatchChanges();
|
|
}
|
|
}
|
|
|
|
~SelectionBatcher()
|
|
{
|
|
if (mSelection) {
|
|
mSelection->EndBatchChangesInternal();
|
|
}
|
|
}
|
|
};
|
|
|
|
class MOZ_RAII AutoHideSelectionChanges final
|
|
{
|
|
private:
|
|
RefPtr<Selection> mSelection;
|
|
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
|
|
public:
|
|
explicit AutoHideSelectionChanges(const nsFrameSelection* aFrame);
|
|
|
|
explicit AutoHideSelectionChanges(Selection* aSelection
|
|
MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
|
|
: mSelection(aSelection)
|
|
{
|
|
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
|
mSelection = aSelection;
|
|
if (mSelection) {
|
|
mSelection->AddSelectionChangeBlocker();
|
|
}
|
|
}
|
|
|
|
~AutoHideSelectionChanges()
|
|
{
|
|
if (mSelection) {
|
|
mSelection->RemoveSelectionChangeBlocker();
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_Selection_h__
|