mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 00:05:36 +00:00
2651346286
Selection caches an nsRange instance for saving re-allocation cost and AddMutationObserver() and RemoveMutationObserver()'s cost when its RemoveAllRangesTemporarily() is called. Then, the instance is detached from the Selection but still referring editing point. E.g., the only text node in TextEditor when its value is set. Therefore, it'll receive character data change notification and need to check whether the point is still valid with new text. However, the range will be always set new position later, i.e., immediately before going back to a part of Selection. Therefore, even if the point becomes invalid, nobody must not have any problems. This patch makes Selection make the cached range not positioned, and makes nsRange ignore any mutations when it's not positioned. Differential Revision: https://phabricator.services.mozilla.com/D2587 --HG-- extra : moz-landing-system : lando
790 lines
29 KiB
C++
790 lines
29 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/RangeBoundary.h"
|
|
#include "mozilla/TextRange.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/WeakPtr.h"
|
|
#include "nsDirection.h"
|
|
#include "nsIPresShell.h" // For ScrollAxis
|
|
#include "nsISelectionController.h"
|
|
#include "nsISelectionListener.h"
|
|
#include "nsRange.h"
|
|
#include "nsTArrayForwardDeclare.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsWrapperCache.h"
|
|
|
|
struct CachedOffsetForFrame;
|
|
class nsAutoScrollTimer;
|
|
class nsIContentIterator;
|
|
class nsIDocument;
|
|
class nsIFrame;
|
|
class nsFrameSelection;
|
|
class nsPIDOMWindowOuter;
|
|
struct SelectionDetails;
|
|
struct SelectionCustomColors;
|
|
class nsCopySupport;
|
|
class nsHTMLCopyEncoder;
|
|
|
|
namespace mozilla {
|
|
class ErrorResult;
|
|
class HTMLEditor;
|
|
enum class TableSelection : uint32_t;
|
|
struct AutoPrepareFocusRange;
|
|
namespace dom {
|
|
class DocGroup;
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
struct RangeData
|
|
{
|
|
explicit RangeData(nsRange* aRange)
|
|
: mRange(aRange)
|
|
{}
|
|
|
|
RefPtr<nsRange> mRange;
|
|
mozilla::TextRangeStyle mTextRangeStyle;
|
|
};
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
// 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.
|
|
class Selection final : public nsSupportsWeakReference,
|
|
public nsWrapperCache,
|
|
public SupportsWeakPtr<Selection>
|
|
{
|
|
protected:
|
|
virtual ~Selection();
|
|
|
|
public:
|
|
Selection();
|
|
explicit Selection(nsFrameSelection *aList);
|
|
|
|
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(Selection)
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Selection)
|
|
|
|
// match this up with EndbatchChanges. will stop ui updates while multiple
|
|
// selection methods are called
|
|
void StartBatchChanges();
|
|
|
|
// match this up with StartBatchChanges
|
|
void EndBatchChanges(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* aContainer, int32_t aOffset)
|
|
{
|
|
if (!aContainer) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return Collapse(RawRangeBoundary(aContainer, aOffset));
|
|
}
|
|
nsresult Collapse(const RawRangeBoundary& aPoint)
|
|
{
|
|
ErrorResult result;
|
|
Collapse(aPoint, result);
|
|
return result.StealNSResult();
|
|
}
|
|
nsresult Extend(nsINode* aContainer, 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);
|
|
|
|
nsresult GetPrimaryFrameForAnchorNode(nsIFrame** aReturnFrame);
|
|
nsresult GetPrimaryFrameForFocusNode(nsIFrame** aReturnFrame,
|
|
int32_t* aOffset, bool aVisual);
|
|
|
|
UniquePtr<SelectionDetails> LookUpSelection(
|
|
nsIContent* aContent,
|
|
int32_t aContentOffset,
|
|
int32_t aContentLength,
|
|
UniquePtr<SelectionDetails> aDetailsHead,
|
|
SelectionType aSelectionType,
|
|
bool aSlowCheck);
|
|
|
|
NS_IMETHOD Repaint(nsPresContext* aPresContext);
|
|
|
|
// Note: StartAutoScrollTimer might destroy arbitrary frames etc.
|
|
nsresult StartAutoScrollTimer(nsIFrame* aFrame,
|
|
const nsPoint& aPoint,
|
|
uint32_t aDelay);
|
|
|
|
nsresult StopAutoScrollTimer();
|
|
|
|
JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
|
|
|
|
// WebIDL methods
|
|
nsINode* GetAnchorNode()
|
|
{
|
|
const RangeBoundary& anchor = AnchorRef();
|
|
return anchor.IsSet() ? anchor.Container() : nullptr;
|
|
}
|
|
uint32_t AnchorOffset()
|
|
{
|
|
const RangeBoundary& anchor = AnchorRef();
|
|
return anchor.IsSet() ? anchor.Offset() : 0;
|
|
}
|
|
nsINode* GetFocusNode()
|
|
{
|
|
const RangeBoundary& focus = FocusRef();
|
|
return focus.IsSet() ? focus.Container() : nullptr;
|
|
}
|
|
uint32_t FocusOffset()
|
|
{
|
|
const RangeBoundary& focus = FocusRef();
|
|
return focus.IsSet() ? focus.Offset() : 0;
|
|
}
|
|
|
|
nsIContent* GetChildAtAnchorOffset()
|
|
{
|
|
const RangeBoundary& anchor = AnchorRef();
|
|
return anchor.IsSet() ? anchor.GetChildAtOffset() : nullptr;
|
|
}
|
|
nsIContent* GetChildAtFocusOffset()
|
|
{
|
|
const RangeBoundary& focus = FocusRef();
|
|
return focus.IsSet() ? focus.GetChildAtOffset() : nullptr;
|
|
}
|
|
|
|
const RangeBoundary& AnchorRef();
|
|
const RangeBoundary& FocusRef();
|
|
|
|
/*
|
|
* IsCollapsed -- is the whole selection just one point, or unset?
|
|
*/
|
|
bool IsCollapsed() const
|
|
{
|
|
uint32_t cnt = mRanges.Length();
|
|
if (cnt == 0) {
|
|
return true;
|
|
}
|
|
|
|
if (cnt != 1) {
|
|
return false;
|
|
}
|
|
|
|
return mRanges[0].mRange->Collapsed();
|
|
}
|
|
|
|
// *JS() methods are mapped to Selection.*().
|
|
// They may move focus only when the range represents normal selection.
|
|
// These methods shouldn't be used by non-JS callers.
|
|
void CollapseJS(nsINode* aContainer, uint32_t aOffset,
|
|
mozilla::ErrorResult& aRv);
|
|
void CollapseToStartJS(mozilla::ErrorResult& aRv);
|
|
void CollapseToEndJS(mozilla::ErrorResult& aRv);
|
|
|
|
void ExtendJS(nsINode& aContainer, uint32_t aOffset,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
void SelectAllChildrenJS(nsINode& aNode, mozilla::ErrorResult& aRv);
|
|
|
|
/**
|
|
* Deletes this selection from document the nodes belong to.
|
|
*/
|
|
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 AddRangeJS(nsRange& aRange, mozilla::ErrorResult& aRv);
|
|
void RemoveRange(nsRange& aRange, mozilla::ErrorResult& aRv);
|
|
void RemoveAllRanges(mozilla::ErrorResult& aRv);
|
|
|
|
/**
|
|
* RemoveAllRangesTemporarily() is useful if the caller will add one or more
|
|
* ranges later. This tries to cache a removing range if it's possible.
|
|
* If a range is not referred by anything else this selection, the range
|
|
* can be reused later. Otherwise, this works as same as RemoveAllRanges().
|
|
*/
|
|
nsresult RemoveAllRangesTemporarily();
|
|
|
|
void Stringify(nsAString& aResult);
|
|
|
|
/**
|
|
* Indicates whether the node is part of the selection. If partlyContained
|
|
* is true, the function returns true when some part of the node
|
|
* is part of the selection. If partlyContained is false, the
|
|
* function only returns true when the entire node is part of the selection.
|
|
*/
|
|
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);
|
|
|
|
/**
|
|
* Modifies the selection. Note that the parameters are case-insensitive.
|
|
*
|
|
* @param alter can be one of { "move", "extend" }
|
|
* - "move" collapses the selection to the end of the selection and
|
|
* applies the movement direction/granularity to the collapsed
|
|
* selection.
|
|
* - "extend" leaves the start of the selection unchanged, and applies
|
|
* movement direction/granularity to the end of the selection.
|
|
* @param direction can be one of { "forward", "backward", "left", "right" }
|
|
* @param granularity can be one of { "character", "word",
|
|
* "line", "lineboundary" }
|
|
*
|
|
* @throws NS_ERROR_NOT_IMPLEMENTED if the granularity is "sentence",
|
|
* "sentenceboundary", "paragraph", "paragraphboundary", or
|
|
* "documentboundary". Throws NS_ERROR_INVALID_ARG if alter, direction,
|
|
* or granularity has an unrecognized value.
|
|
*/
|
|
void Modify(const nsAString& aAlter, const nsAString& aDirection,
|
|
const nsAString& aGranularity, mozilla::ErrorResult& aRv);
|
|
|
|
void SetBaseAndExtentJS(nsINode& aAnchorNode, uint32_t aAnchorOffset,
|
|
nsINode& aFocusNode, uint32_t aFocusOffset,
|
|
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);
|
|
void RemoveSelectionListener(nsISelectionListener* aListener);
|
|
|
|
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 SetColors(const nsAString& aForeColor, const nsAString& aBackColor,
|
|
const nsAString& aAltForeColor, const nsAString& aAltBackColor,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
void ResetColors(mozilla::ErrorResult& aRv);
|
|
|
|
/**
|
|
* Non-JS callers should use the following
|
|
* collapse/collapseToStart/extend/etc methods, instead of the *JS
|
|
* versions that bindings call.
|
|
*/
|
|
|
|
/**
|
|
* Collapses the selection to a single point, at the specified offset
|
|
* in the given node. When the selection is collapsed, and the content
|
|
* is focused and editable, the caret will blink there.
|
|
* @param aContainer The given node where the selection will be set
|
|
* @param offset Where in given dom node to place the selection (the offset into the given node)
|
|
*/
|
|
void Collapse(nsINode& aContainer, uint32_t aOffset, ErrorResult& aRv)
|
|
{
|
|
Collapse(RawRangeBoundary(&aContainer, aOffset), aRv);
|
|
}
|
|
void Collapse(const RawRangeBoundary& aPoint, ErrorResult& aRv);
|
|
/**
|
|
* Collapses the whole selection to a single point at the start
|
|
* of the current selection (irrespective of direction). If content
|
|
* is focused and editable, the caret will blink there.
|
|
*/
|
|
void CollapseToStart(mozilla::ErrorResult& aRv);
|
|
/**
|
|
* Collapses the whole selection to a single point at the end
|
|
* of the current selection (irrespective of direction). If content
|
|
* is focused and editable, the caret will blink there.
|
|
*/
|
|
void CollapseToEnd(mozilla::ErrorResult& aRv);
|
|
|
|
/**
|
|
* Extends the selection by moving the selection end to the specified node and
|
|
* offset, preserving the selection begin position. The new selection end
|
|
* result will always be from the anchorNode to the new focusNode, regardless
|
|
* of direction.
|
|
*
|
|
* @param aContainer The node where the selection will be extended to
|
|
* @param aOffset Where in aContainer to place the offset of the new selection end.
|
|
*/
|
|
void Extend(nsINode& aContainer, uint32_t aOffset, ErrorResult& aRv);
|
|
void AddRange(nsRange& aRange, mozilla::ErrorResult& aRv);
|
|
/**
|
|
* Adds all children of the specified node to the selection.
|
|
* @param aNode the parent of the children to be added to the selection.
|
|
*/
|
|
void SelectAllChildren(nsINode& aNode, mozilla::ErrorResult& aRv);
|
|
void SetBaseAndExtent(nsINode& aAnchorNode, uint32_t aAnchorOffset,
|
|
nsINode& aFocusNode, uint32_t aFocusOffset,
|
|
mozilla::ErrorResult& aRv);
|
|
|
|
void AddSelectionChangeBlocker();
|
|
void RemoveSelectionChangeBlocker();
|
|
bool IsBlockingSelectionChangeEvents() const;
|
|
|
|
/**
|
|
* Set the painting style for the range. The range must be a range in
|
|
* the selection. The textRangeStyle will be used by text frame
|
|
* when it is painting the selection.
|
|
*/
|
|
nsresult SetTextRangeStyle(nsRange* aRange,
|
|
const TextRangeStyle& aTextRangeStyle);
|
|
|
|
// Methods to manipulate our mFrameSelection's ancestor limiter.
|
|
nsIContent* GetAncestorLimiter() const;
|
|
void SetAncestorLimiter(nsIContent* aLimiter);
|
|
|
|
/*
|
|
* Frame Offset cache can be used just during calling nsEditor::EndPlaceHolderTransaction.
|
|
* EndPlaceHolderTransaction will give rise to reflow/refreshing view/scroll, and call times
|
|
* of nsTextFrame::GetPointFromOffset whose return value is to be cached.
|
|
* see bugs 35296 and 199412
|
|
*/
|
|
void SetCanCacheFrameOffset(bool aCanCacheFrameOffset);
|
|
|
|
// 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
|
|
GetRangesForIntervalArray(nsINode* aBeginNode, int32_t aBeginOffset,
|
|
nsINode* aEndNode, int32_t aEndOffset,
|
|
bool aAllowAdjacent,
|
|
nsTArray<nsRange*>* aRanges);
|
|
|
|
/**
|
|
* Modifies the cursor Bidi level after a change in keyboard direction
|
|
* @param langRTL is true if the new language is right-to-left or
|
|
* false if the new language is left-to-right.
|
|
*/
|
|
nsresult SelectionLanguageChange(bool aLangRTL);
|
|
|
|
private:
|
|
friend class ::nsAutoScrollTimer;
|
|
|
|
// Note: DoAutoScroll might destroy arbitrary frames etc.
|
|
nsresult DoAutoScroll(nsIFrame* aFrame, nsPoint aPoint);
|
|
|
|
// We are not allowed to be in nodes whose root is not our document
|
|
bool HasSameRoot(nsINode& aNode);
|
|
|
|
// 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&);
|
|
|
|
// This is helper method for GetPrimaryFrameForFocusNode.
|
|
// If aVisual is true, this returns caret frame.
|
|
// If false, this returns primary frame.
|
|
nsresult GetPrimaryOrCaretFrameForNodeOffset(nsIContent* aContent,
|
|
uint32_t aOffset,
|
|
nsIFrame** aReturnFrame,
|
|
int32_t* aOffsetUsed,
|
|
bool aVisual) const;
|
|
|
|
// Get the cached value for nsTextFrame::GetPointFromOffset.
|
|
nsresult GetCachedFrameOffset(nsIFrame* aFrame, int32_t inOffset,
|
|
nsPoint& aPoint);
|
|
|
|
public:
|
|
SelectionType GetType() const { return mSelectionType; }
|
|
void SetType(SelectionType aSelectionType)
|
|
{
|
|
mSelectionType = aSelectionType;
|
|
}
|
|
|
|
SelectionCustomColors* GetCustomColors() const { return mCustomColors.get(); }
|
|
|
|
nsresult NotifySelectionListeners(bool aCalledByJS);
|
|
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)
|
|
: Runnable("dom::Selection::ScrollSelectionIntoViewEvent")
|
|
, 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;
|
|
};
|
|
|
|
/**
|
|
* Set mAnchorFocusRange to mRanges[aIndex] if aIndex is a valid index.
|
|
* Set mAnchorFocusRange to nullptr if aIndex is negative.
|
|
* Otherwise, i.e., if aIndex is positive but out of bounds of mRanges, do
|
|
* nothing.
|
|
*/
|
|
void SetAnchorFocusRange(int32_t aIndex);
|
|
void SelectFramesForContent(nsIContent* aContent, bool aSelected);
|
|
nsresult SelectAllFramesForContent(nsIContentIterator* aInnerIter,
|
|
nsIContent *aContent,
|
|
bool aSelected);
|
|
nsresult SelectFrames(nsPresContext* aPresContext,
|
|
nsRange* aRange,
|
|
bool aSelect);
|
|
|
|
/**
|
|
* Test whether the supplied range points to a single table element.
|
|
* Result is one of the TableSelection constants. "None" means
|
|
* a table element isn't selected.
|
|
*/
|
|
nsresult GetTableSelectionType(nsRange* aRange,
|
|
TableSelection* aTableSelectionType);
|
|
nsresult GetTableCellLocationFromRange(nsRange* aRange,
|
|
TableSelection* 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(nsRange* aRange);
|
|
|
|
void UserSelectRangesToAdd(nsRange* aItem, nsTArray<RefPtr<nsRange> >& rangesToAdd);
|
|
|
|
/**
|
|
* Helper method for AddItem.
|
|
*/
|
|
nsresult AddItemInternal(nsRange* aRange, int32_t* aOutIndex);
|
|
|
|
nsIDocument* GetDocument() const;
|
|
nsPIDOMWindowOuter* GetWindow() const;
|
|
HTMLEditor* GetHTMLEditor() const;
|
|
|
|
/**
|
|
* GetCommonEditingHostForAllRanges() returns common editing host of all
|
|
* ranges if there is. If at least one of the ranges is in non-editable
|
|
* element, returns nullptr. See following examples for the detail:
|
|
*
|
|
* <div id="a" contenteditable>
|
|
* an[cestor
|
|
* <div id="b" contenteditable="false">
|
|
* non-editable
|
|
* <div id="c" contenteditable>
|
|
* desc]endant
|
|
* in this case, this returns div#a because div#c is also in div#a.
|
|
*
|
|
* <div id="a" contenteditable>
|
|
* an[ce]stor
|
|
* <div id="b" contenteditable="false">
|
|
* non-editable
|
|
* <div id="c" contenteditable>
|
|
* de[sc]endant
|
|
* in this case, this returns div#a because second range is also in div#a
|
|
* and common ancestor of the range (i.e., div#c) is editable.
|
|
*
|
|
* <div id="a" contenteditable>
|
|
* an[ce]stor
|
|
* <div id="b" contenteditable="false">
|
|
* [non]-editable
|
|
* <div id="c" contenteditable>
|
|
* de[sc]endant
|
|
* in this case, this returns nullptr because the second range is in
|
|
* non-editable area.
|
|
*/
|
|
Element* GetCommonEditingHostForAllRanges();
|
|
|
|
// 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.
|
|
AutoTArray<RangeData, 1> mRanges;
|
|
|
|
RefPtr<nsRange> mAnchorFocusRange;
|
|
// mCachedRange is set by RemoveAllRangesTemporarily() and used by
|
|
// Collapse() and SetBaseAndExtent(). If there is a range which will be
|
|
// released by Clear(), RemoveAllRangesTemporarily() stores it with this.
|
|
// If Collapse() is called without existing ranges, it'll reuse this range
|
|
// for saving the creation cost.
|
|
// Note that while the range is cached by this, we keep the range being
|
|
// a mutation observer because it is not so cheap to register the range
|
|
// as a mutation observer again. On the other hand, we make it not
|
|
// positioned because it is not so cheap to keep valid DOM point against
|
|
// mutations. This does not cause any problems because we will set new
|
|
// DOM point when we treat it as a range of Selection again.
|
|
RefPtr<nsRange> mCachedRange;
|
|
RefPtr<nsFrameSelection> mFrameSelection;
|
|
RefPtr<nsAutoScrollTimer> mAutoScrollTimer;
|
|
nsTArray<nsCOMPtr<nsISelectionListener>> mSelectionListeners;
|
|
nsRevocableEventPtr<ScrollSelectionIntoViewEvent> mScrollEvent;
|
|
CachedOffsetForFrame* mCachedOffsetForFrame;
|
|
nsDirection mDirection;
|
|
SelectionType mSelectionType;
|
|
UniquePtr<SelectionCustomColors> mCustomColors;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* When the selection change is caused by a call of Selection API,
|
|
* mCalledByJS is true. Otherwise, false.
|
|
*/
|
|
bool mCalledByJS;
|
|
|
|
// 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->EndBatchChanges();
|
|
}
|
|
}
|
|
};
|
|
|
|
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
|
|
|
|
inline bool
|
|
IsValidRawSelectionType(RawSelectionType aRawSelectionType)
|
|
{
|
|
return aRawSelectionType >= nsISelectionController::SELECTION_NONE &&
|
|
aRawSelectionType <= nsISelectionController::SELECTION_URLSTRIKEOUT;
|
|
}
|
|
|
|
inline SelectionType
|
|
ToSelectionType(RawSelectionType aRawSelectionType)
|
|
{
|
|
if (!IsValidRawSelectionType(aRawSelectionType)) {
|
|
return SelectionType::eInvalid;
|
|
}
|
|
return static_cast<SelectionType>(aRawSelectionType);
|
|
}
|
|
|
|
inline RawSelectionType
|
|
ToRawSelectionType(SelectionType aSelectionType)
|
|
{
|
|
MOZ_ASSERT(aSelectionType != SelectionType::eInvalid);
|
|
return static_cast<RawSelectionType>(aSelectionType);
|
|
}
|
|
|
|
inline RawSelectionType
|
|
ToRawSelectionType(TextRangeType aTextRangeType)
|
|
{
|
|
return ToRawSelectionType(ToSelectionType(aTextRangeType));
|
|
}
|
|
|
|
inline SelectionTypeMask
|
|
ToSelectionTypeMask(SelectionType aSelectionType)
|
|
{
|
|
MOZ_ASSERT(aSelectionType != SelectionType::eInvalid);
|
|
return aSelectionType == SelectionType::eNone ? 0 :
|
|
(1 << (static_cast<uint8_t>(aSelectionType) - 1));
|
|
}
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_Selection_h__
|