Masayuki Nakano
12a778ff10
All selection ranges should be in the ancestor limiter when it's set. However, due to bug 2046677, we don't dispatch `eBlur` event and `HTMLEditor` cannot reset the ancestor limiter with treating itself as blurred. Fixing it requires risky changes. Therefore, this patch makes `ContentEventHandler` ignores the invalid ranges for now to avoid the assertion failures in `ContentCacheInChild`. Additionally, this fixes `nsINode::GetSelectionRootContent()` and `nsFrameSelection::SetAncestorLimiter()` which may trigger the similar situation and we can fix it safer. `nsINode::GetSelectionRootContent()`: When moving selection into `contenteditable="false"` element in an editing host may not cause `blur` event. Therefore, the ancestor limiter should be the editing host even if the target node of the examination is not editable. `nsFrameSelection::SetAncestorLimiter()`: It checks only the focus node is in the new ancestor limiter. However, non-primary ranges may be outside of the limiter and the range may have crossed the range ancestor limiter's element boundaries. Therefore, this method should check whether all ranges are valid for the new ancestor limiter. Differential Revision: https://phabricator.services.mozilla.com/D306596
1496 lines
57 KiB
C++
1496 lines
57 KiB
C++
/* 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 nsFrameSelection_h_
|
|
#define nsFrameSelection_h_
|
|
|
|
#include <fmt/format.h>
|
|
#include <stdint.h>
|
|
|
|
#include "WordMovementType.h"
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/CaretAssociationHint.h"
|
|
#include "mozilla/CompactPair.h"
|
|
#include "mozilla/EnumSet.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/Result.h"
|
|
#include "mozilla/TextRange.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/Highlight.h"
|
|
#include "mozilla/dom/Selection.h"
|
|
#include "mozilla/intl/BidiEmbeddingLevel.h"
|
|
#include "nsBidiPresUtils.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsISelectionController.h"
|
|
#include "nsISelectionListener.h"
|
|
#include "nsITableCellLayout.h"
|
|
|
|
class nsRange;
|
|
|
|
#define BIDI_LEVEL_UNDEFINED mozilla::intl::BidiEmbeddingLevel(0x80)
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Selection interface
|
|
|
|
struct SelectionDetails {
|
|
SelectionDetails()
|
|
: mStart(), mEnd(), mSelectionType(mozilla::SelectionType::eInvalid) {
|
|
MOZ_COUNT_CTOR(SelectionDetails);
|
|
}
|
|
~SelectionDetails() {
|
|
MOZ_COUNT_DTOR(SelectionDetails);
|
|
// Destroy the linked list without recursion.
|
|
auto next = std::move(mNext);
|
|
while (next) {
|
|
next = std::move(next->mNext);
|
|
}
|
|
}
|
|
|
|
int32_t mStart;
|
|
int32_t mEnd;
|
|
mozilla::SelectionType mSelectionType;
|
|
mozilla::dom::HighlightSelectionData mHighlightData;
|
|
mozilla::TextRangeStyle mTextRangeStyle;
|
|
mozilla::UniquePtr<SelectionDetails> mNext;
|
|
};
|
|
|
|
struct SelectionCustomColors {
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
MOZ_COUNTED_DEFAULT_CTOR(SelectionCustomColors)
|
|
MOZ_COUNTED_DTOR(SelectionCustomColors)
|
|
#endif
|
|
mozilla::Maybe<nscolor> mForegroundColor;
|
|
mozilla::Maybe<nscolor> mBackgroundColor;
|
|
mozilla::Maybe<nscolor> mAltForegroundColor;
|
|
mozilla::Maybe<nscolor> mAltBackgroundColor;
|
|
};
|
|
|
|
namespace mozilla {
|
|
class PresShell;
|
|
|
|
/** PeekOffsetStruct is used to group various arguments (both input and output)
|
|
* that are passed to nsIFrame::PeekOffset(). See below for the description of
|
|
* individual arguments.
|
|
*/
|
|
enum class PeekOffsetOption : uint16_t {
|
|
// Whether to allow jumping across line boundaries.
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord.
|
|
JumpLines,
|
|
|
|
// Whether we should preserve or trim spaces at begin/end of content
|
|
PreserveSpaces,
|
|
|
|
// Whether to stop when reaching a scroll view boundary.
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord, eSelectLine.
|
|
StopAtScroller,
|
|
|
|
// Whether to stop when reaching a placeholder frame.
|
|
StopAtPlaceholder,
|
|
|
|
// Whether the peeking is done in response to a keyboard action.
|
|
//
|
|
// Used with: eSelectWord.
|
|
IsKeyboardSelect,
|
|
|
|
// Whether bidi caret behavior is visual (set) or logical (unset).
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord, eSelectBeginLine, eSelectEndLine.
|
|
Visual,
|
|
|
|
// Whether the selection is being extended or moved.
|
|
Extend,
|
|
|
|
// If true, the offset has to end up in an editable node, otherwise we'll keep
|
|
// searching.
|
|
ForceEditableRegion,
|
|
|
|
// Whether the peeking is done for a caret move rather than a selection.
|
|
//
|
|
// Currently this only affects eSelectParagraph: when paragraph movement
|
|
// reaches a block boundary without finding a "stop frame", the result is
|
|
// resolved to the leaf frame at that edge (typically a text frame) rather
|
|
// than to the block container element. This gives a caret a precise text
|
|
// position so that scrolling-into-view works for horizontally overflowing
|
|
// content (bug 2041228). Selection (e.g. triple-click paragraph selection)
|
|
// intentionally does not set this, because it expects the block container
|
|
// itself as the boundary.
|
|
//
|
|
// Set for all caret moves; currently only takes effect with eSelectParagraph.
|
|
ForCaretMove,
|
|
};
|
|
|
|
using PeekOffsetOptions = EnumSet<PeekOffsetOption>;
|
|
|
|
struct MOZ_STACK_CLASS PeekOffsetStruct {
|
|
PeekOffsetStruct(nsSelectionAmount aAmount, nsDirection aDirection,
|
|
int32_t aStartOffset, nsPoint aDesiredCaretPos,
|
|
// Passing by value here is intentional because EnumSet
|
|
// is optimized as uint*_t in opt builds.
|
|
const PeekOffsetOptions aOptions,
|
|
EWordMovementType aWordMovementType = eDefaultBehavior,
|
|
const dom::Element* aAncestorLimiter = nullptr);
|
|
|
|
/**
|
|
* Return true if the ancestor limiter is not specified or if the content for
|
|
* aFrame is an inclusive descendant of mAncestorLimiter.
|
|
*/
|
|
[[nodiscard]] bool FrameContentIsInAncestorLimiter(
|
|
const nsIFrame* aFrame) const {
|
|
return !mAncestorLimiter ||
|
|
(aFrame->GetContent() &&
|
|
aFrame->GetContent()->IsInclusiveDescendantOf(mAncestorLimiter));
|
|
}
|
|
|
|
// Note: Most arguments (input and output) are only used with certain values
|
|
// of mAmount. These values are indicated for each argument below.
|
|
// Arguments with no such indication are used with all values of mAmount.
|
|
|
|
/*** Input arguments ***/
|
|
// Note: The value of some of the input arguments may be changed upon exit.
|
|
|
|
// The type of movement requested (by character, word, line, etc.)
|
|
nsSelectionAmount mAmount;
|
|
|
|
// eDirPrevious or eDirNext.
|
|
//
|
|
// Note for visual bidi movement:
|
|
// * eDirPrevious means 'left-then-up' if the containing block is LTR,
|
|
// 'right-then-up' if it is RTL.
|
|
// * eDirNext means 'right-then-down' if the containing block is LTR,
|
|
// 'left-then-down' if it is RTL.
|
|
// * Between paragraphs, eDirPrevious means "go to the visual end of
|
|
// the previous paragraph", and eDirNext means "go to the visual
|
|
// beginning of the next paragraph".
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord, eSelectLine, eSelectParagraph.
|
|
const nsDirection mDirection;
|
|
|
|
// Offset into the content of the current frame where the peek starts.
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord
|
|
int32_t mStartOffset;
|
|
|
|
// The desired inline coordinate for the caret (one of .x or .y will be used,
|
|
// depending on line's writing mode)
|
|
//
|
|
// Used with: eSelectLine.
|
|
const nsPoint mDesiredCaretPos;
|
|
|
|
// An enum that determines whether to prefer the start or end of a word or to
|
|
// use the default behavior, which is a combination of direction and the
|
|
// platform-based pref "layout.word_select.eat_space_to_next_word"
|
|
EWordMovementType mWordMovementType;
|
|
|
|
PeekOffsetOptions mOptions;
|
|
|
|
// The ancestor limiter element to peek offset.
|
|
const dom::Element* const mAncestorLimiter;
|
|
|
|
/*** Output arguments ***/
|
|
|
|
// Content reached as a result of the peek.
|
|
nsCOMPtr<nsIContent> mResultContent;
|
|
|
|
// Frame reached as a result of the peek.
|
|
//
|
|
// Used with: eSelectCharacter, eSelectWord.
|
|
nsIFrame* mResultFrame;
|
|
|
|
// Offset into content reached as a result of the peek.
|
|
int32_t mContentOffset;
|
|
|
|
// When the result position is between two frames, indicates which of the two
|
|
// frames the caret should be painted in. false means "the end of the frame
|
|
// logically before the caret", true means "the beginning of the frame
|
|
// logically after the caret".
|
|
//
|
|
// Used with: eSelectLine, eSelectBeginLine, eSelectEndLine.
|
|
CaretAssociationHint mAttach;
|
|
};
|
|
|
|
struct LimitersAndCaretData;
|
|
|
|
} // namespace mozilla
|
|
|
|
struct nsPrevNextBidiLevels {
|
|
void SetData(nsIFrame* aFrameBefore, nsIFrame* aFrameAfter,
|
|
mozilla::intl::BidiEmbeddingLevel aLevelBefore,
|
|
mozilla::intl::BidiEmbeddingLevel aLevelAfter) {
|
|
mFrameBefore = aFrameBefore;
|
|
mFrameAfter = aFrameAfter;
|
|
mLevelBefore = aLevelBefore;
|
|
mLevelAfter = aLevelAfter;
|
|
}
|
|
nsIFrame* mFrameBefore;
|
|
nsIFrame* mFrameAfter;
|
|
mozilla::intl::BidiEmbeddingLevel mLevelBefore;
|
|
mozilla::intl::BidiEmbeddingLevel mLevelAfter;
|
|
};
|
|
|
|
namespace mozilla {
|
|
class SelectionChangeEventDispatcher;
|
|
namespace dom {
|
|
class Highlight;
|
|
class Selection;
|
|
enum class ClickSelectionType { NotApplicable, Double, Triple };
|
|
} // namespace dom
|
|
|
|
/**
|
|
* Constants for places that want to handle table selections. These
|
|
* indicate what part of a table is being selected.
|
|
*/
|
|
enum class TableSelectionMode : uint32_t {
|
|
None, /* Nothing being selected; not valid in all cases. */
|
|
Cell, /* A cell is being selected. */
|
|
Row, /* A row is being selected. */
|
|
Column, /* A column is being selected. */
|
|
Table, /* A table (including cells and captions) is being selected. */
|
|
AllCells, /* All the cells in a table are being selected. */
|
|
};
|
|
|
|
struct SelectionLimiters {
|
|
/**
|
|
* Return true if aContainerNode is in the limiters if one of them is set.
|
|
*
|
|
* Note that this returns true when aContainerNode may be in the scope of
|
|
* an independent selection. Therefore, even if this returns `true`,
|
|
* aContainerNode may not be valid container node for a selection managed
|
|
* by this owner.
|
|
*/
|
|
[[nodiscard]] bool NodeIsInLimiters(const nsINode* aContainerNode) const;
|
|
|
|
/**
|
|
* Return true if aRange is completely in the limiters if one of them is set.
|
|
*
|
|
* Note that this returns true when aContainerNode may be in the scope of
|
|
* an independent selection. Therefore, even if this returns `true`,
|
|
* aRange may not be a valid range for a selection managed by this owner.
|
|
*/
|
|
[[nodiscard]] bool RangeInLimiters(const dom::AbstractRange& aRange) const {
|
|
return NodeIsInLimiters(aRange.GetStartContainer()) &&
|
|
(aRange.GetStartContainer() == aRange.GetEndContainer() ||
|
|
NodeIsInLimiters(aRange.GetEndContainer()));
|
|
}
|
|
|
|
[[nodiscard]] bool HasLimiters() const {
|
|
return mIndependentSelectionRootElement || mAncestorLimiter;
|
|
}
|
|
|
|
friend inline std::string format_as(const SelectionLimiters& aLimiters) {
|
|
return fmt::format(
|
|
"{{ mIndependentSelectionRootElement={}, mAncestorLimiter={} }}",
|
|
ToString(aLimiters.mIndependentSelectionRootElement),
|
|
ToString(aLimiters.mAncestorLimiter));
|
|
}
|
|
|
|
friend inline std::ostream& operator<<(std::ostream& aStream,
|
|
const SelectionLimiters& aLimiters) {
|
|
return aStream << format_as(aLimiters);
|
|
}
|
|
|
|
// The independent selection root element if and only if the
|
|
// nsFrameSelection instance is for an independent selection.
|
|
RefPtr<dom::Element> mIndependentSelectionRootElement;
|
|
// Limit selection navigation to a descendant of this element.
|
|
// This is typically the focused editing host if set unless it's the root
|
|
// element of the document.
|
|
RefPtr<dom::Element> mAncestorLimiter;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
class nsFrameSelection final {
|
|
public:
|
|
friend std::ostream& operator<<(std::ostream&, const nsFrameSelection&);
|
|
|
|
using AllowRangeCrossShadowBoundary =
|
|
mozilla::dom::AllowRangeCrossShadowBoundary;
|
|
using CaretAssociationHint = mozilla::CaretAssociationHint;
|
|
using Element = mozilla::dom::Element;
|
|
|
|
/*interfaces for addref and release and queryinterface*/
|
|
|
|
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(nsFrameSelection)
|
|
NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(nsFrameSelection)
|
|
|
|
enum class FocusMode {
|
|
kExtendSelection, /** Keep old anchor point. */
|
|
kCollapseToNewPoint, /** Collapses the Selection to the new point. */
|
|
kMultiRangeSelection, /** Keeps existing non-collapsed ranges and marks them
|
|
as generated. */
|
|
};
|
|
|
|
/**
|
|
* HandleClick will take the focus to the new frame at the new offset and
|
|
* will either extend the selection from the old anchor, or replace the old
|
|
* anchor. the old anchor and focus position may also be used to deselect
|
|
* things
|
|
*
|
|
* @param aNewfocus is the content that wants the focus
|
|
*
|
|
* @param aContentOffset is the content offset of the parent aNewFocus
|
|
*
|
|
* @param aContentOffsetEnd is the content offset of the parent aNewFocus and
|
|
* is specified different when you need to select to and include both start
|
|
* and end points
|
|
*
|
|
* @param aHint will tell the selection which direction geometrically to
|
|
* actually show the caret on. 1 = end of this line 0 = beginning of this line
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleClick(nsIContent* aNewFocus,
|
|
uint32_t aContentOffset,
|
|
uint32_t aContentEndOffset,
|
|
FocusMode aFocusMode,
|
|
CaretAssociationHint aHint);
|
|
|
|
[[nodiscard]] bool IsAvailable() const {
|
|
// mDomSelections is initialized at construction and cleared if the cycle
|
|
// collector unlink them so that if the first selection is available, the
|
|
// others should be fine.
|
|
return !!mDomSelections[0];
|
|
}
|
|
|
|
/**
|
|
* Sets the type of the selection based on whether a selection is created
|
|
* by doubleclick, long tapping a word or tripleclick.
|
|
*
|
|
* @param aClickSelectionType ClickSelectionType::Double if the selection
|
|
* is created by doubleclick,
|
|
* ClickSelectionType::Triple if the selection
|
|
* is created by tripleclick.
|
|
*/
|
|
void SetClickSelectionType(
|
|
mozilla::dom::ClickSelectionType aClickSelectionType) {
|
|
mClickSelectionType = aClickSelectionType;
|
|
}
|
|
|
|
/**
|
|
* Return true if this is an instance for an independent selection.
|
|
* Currently, independent selection is created only in the text controls
|
|
* to manage selections in their native anonymous subtree.
|
|
*/
|
|
[[nodiscard]] bool IsIndependentSelection() const {
|
|
return !!GetIndependentSelectionRootElement();
|
|
}
|
|
|
|
/**
|
|
* Returns true if the selection was created by doubleclick or
|
|
* long tap over a word.
|
|
*/
|
|
[[nodiscard]] bool IsDoubleClickSelection() const {
|
|
return mClickSelectionType == mozilla::dom::ClickSelectionType::Double;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the selection was created by triple click
|
|
*/
|
|
[[nodiscard]] bool IsTripleClickSelection() const {
|
|
return mClickSelectionType == mozilla::dom::ClickSelectionType::Triple;
|
|
}
|
|
|
|
/**
|
|
* HandleDrag extends the selection to contain the frame closest to aPoint.
|
|
*
|
|
* @param aPresContext is the context to use when figuring out what frame
|
|
* contains the point.
|
|
*
|
|
* @param aFrame is the parent of all frames to use when searching for the
|
|
* closest frame to the point.
|
|
*
|
|
* @param aPoint is relative to aFrame
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void HandleDrag(nsIFrame* aFrame, const nsPoint& aPoint);
|
|
|
|
/**
|
|
* HandleTableSelection will set selection to a table, cell, etc
|
|
* depending on information contained in aFlags
|
|
*
|
|
* @param aParentContent is the paretent of either a table or cell that user
|
|
* clicked or dragged the mouse in
|
|
*
|
|
* @param aContentOffset is the offset of the table or cell
|
|
*
|
|
* @param aTarget indicates what to select
|
|
* * TableSelectionMode::Cell
|
|
* We should select a cell (content points to the cell)
|
|
* * TableSelectionMode::Row
|
|
* We should select a row (content points to any cell in row)
|
|
* * TableSelectionMode::Column
|
|
* We should select a row (content points to any cell in column)
|
|
* * TableSelectionMode::Table
|
|
* We should select a table (content points to the table)
|
|
* * TableSelectionMode::AllCells
|
|
* We should select all cells (content points to any cell in table)
|
|
*
|
|
* @param aMouseEvent passed in so we can get where event occurred
|
|
* and what keys are pressed
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
HandleTableSelection(nsINode* aParentContent, int32_t aContentOffset,
|
|
mozilla::TableSelectionMode aTarget,
|
|
mozilla::WidgetMouseEvent* aMouseEvent);
|
|
|
|
/**
|
|
* Add cell to the selection with `SelectionType::eNormal`.
|
|
*
|
|
* @param aCell [in] HTML td element.
|
|
*/
|
|
nsresult SelectCellElement(nsIContent* aCell);
|
|
|
|
/**
|
|
* Remove cells from selection inside of the given cell range.
|
|
*
|
|
* @param aTable [in] HTML table element
|
|
* @param aStartRowIndex [in] row index where the cells range starts
|
|
* @param aStartColumnIndex [in] column index where the cells range starts
|
|
* @param aEndRowIndex [in] row index where the cells range ends
|
|
* @param aEndColumnIndex [in] column index where the cells range ends
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult RemoveCellsFromSelection(
|
|
nsIContent* aTable, int32_t aStartRowIndex, int32_t aStartColumnIndex,
|
|
int32_t aEndRowIndex, int32_t aEndColumnIndex);
|
|
|
|
/**
|
|
* Remove cells from selection outside of the given cell range.
|
|
*
|
|
* @param aTable [in] HTML table element
|
|
* @param aStartRowIndex [in] row index where the cells range starts
|
|
* @param aStartColumnIndex [in] column index where the cells range starts
|
|
* @param aEndRowIndex [in] row index where the cells range ends
|
|
* @param aEndColumnIndex [in] column index where the cells range ends
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult RestrictCellsToSelection(
|
|
nsIContent* aTable, int32_t aStartRowIndex, int32_t aStartColumnIndex,
|
|
int32_t aEndRowIndex, int32_t aEndColumnIndex);
|
|
|
|
/**
|
|
* StartAutoScrollTimer is responsible for scrolling frames so that
|
|
* aPoint is always visible, and for selecting any frame that contains
|
|
* aPoint. The timer will also reset itself to fire again if we have
|
|
* not scrolled to the end of the document.
|
|
*
|
|
* @param aFrame is the outermost frame to use when searching for
|
|
* the closest frame for the point, i.e. the frame that is capturing
|
|
* the mouse
|
|
*
|
|
* @param aPoint is relative to aFrame.
|
|
*
|
|
* @param aDelay is the timer's interval.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult StartAutoScrollTimer(nsIFrame* aFrame,
|
|
const nsPoint& aPoint,
|
|
uint32_t aDelay);
|
|
|
|
/**
|
|
* Stops any active auto scroll timer.
|
|
*/
|
|
void StopAutoScrollTimer();
|
|
|
|
/**
|
|
* Returns in frame coordinates the selection beginning and ending with the
|
|
* type of selection given
|
|
*
|
|
* @param aContent is the content asking
|
|
* @param aContentOffset is the starting content boundary
|
|
* @param aContentLength is the length of the content piece asking
|
|
* @param aIgnoreSelection is Yes, this won't return selection details about
|
|
* the normal selection.
|
|
*/
|
|
enum class IgnoreNormalSelection : bool { No, Yes };
|
|
mozilla::UniquePtr<SelectionDetails> LookUpSelection(
|
|
nsIContent* aContent, int32_t aContentOffset, int32_t aContentLength,
|
|
IgnoreNormalSelection aIgnoreNormalSelection) const;
|
|
|
|
/**
|
|
* Sets the drag state to aState for resons of drag state.
|
|
* Note that only can run script when called with false as an argument.
|
|
*
|
|
* @param aState is the new state of drag
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void SetDragState(bool aState);
|
|
|
|
/**
|
|
* Marks us as dragging. Equivalent to SetDragState(true), but without the
|
|
* CAN_RUN_SCRIPT implications.
|
|
*/
|
|
void RestoreDragState() { mDragState = true; }
|
|
[[nodiscard]] bool GetDragState() const { return mDragState; }
|
|
|
|
/**
|
|
* If we are in table cell selection mode. aka ctrl click in table cell
|
|
*/
|
|
[[nodiscard]] bool IsInTableSelectionMode() const {
|
|
return mTableSelection.mMode != mozilla::TableSelectionMode::None;
|
|
}
|
|
void ClearTableCellSelection() {
|
|
mTableSelection.mMode = mozilla::TableSelectionMode::None;
|
|
}
|
|
|
|
/**
|
|
* No query interface for selection. must use this method now.
|
|
*
|
|
* @param aSelectionType The selection type what you want.
|
|
*/
|
|
[[nodiscard]] mozilla::dom::Selection* GetSelection(
|
|
mozilla::SelectionType aSelectionType) const;
|
|
|
|
/**
|
|
* Convenience method to access the `eNormal` Selection.
|
|
*/
|
|
[[nodiscard]] mozilla::dom::Selection& NormalSelection() const {
|
|
return *GetSelection(mozilla::SelectionType::eNormal);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of highlight selections.
|
|
*/
|
|
[[nodiscard]] size_t HighlightSelectionCount() const {
|
|
return mHighlightSelections.Length();
|
|
}
|
|
|
|
/**
|
|
* Get a highlight selection by index. The index must be valid.
|
|
*/
|
|
[[nodiscard]] RefPtr<mozilla::dom::Selection> HighlightSelection(
|
|
size_t aIndex) const {
|
|
return mHighlightSelections[aIndex].second();
|
|
}
|
|
|
|
/**
|
|
* @brief Adds a highlight selection for `aHighlight`.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void AddHighlightSelection(
|
|
nsAtom* aHighlightName, mozilla::dom::Highlight& aHighlight);
|
|
|
|
void RepaintHighlightSelection(nsAtom* aHighlightName);
|
|
|
|
/**
|
|
* @brief Removes the Highlight selection identified by `aHighlightName`.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void RemoveHighlightSelection(nsAtom* aHighlightName);
|
|
|
|
/**
|
|
* @brief Adds a new range to the highlight selection.
|
|
*
|
|
* If there is no highlight selection for the given highlight yet, it is
|
|
* created using |AddHighlightSelection|.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void AddHighlightSelectionRange(
|
|
nsAtom* aHighlightName, mozilla::dom::Highlight& aHighlight,
|
|
mozilla::dom::AbstractRange& aRange);
|
|
|
|
/**
|
|
* @brief Removes a range from a highlight selection.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void RemoveHighlightSelectionRange(
|
|
nsAtom* aHighlightName, mozilla::dom::AbstractRange& aRange);
|
|
/**
|
|
* ScrollSelectionIntoView scrolls a region of the selection,
|
|
* so that it is visible in the scrolled view.
|
|
*
|
|
* @param aSelectionType the selection to scroll into view.
|
|
*
|
|
* @param aRegion the region inside the selection to scroll into view.
|
|
*
|
|
* @param aFlags the scroll flags. Valid bits include:
|
|
* * SCROLL_SYNCHRONOUS: when set, scrolls the selection into view
|
|
* before returning. If not set, posts a request which is processed
|
|
* at some point after the method returns.
|
|
* * SCROLL_FIRST_ANCESTOR_ONLY: if set, only the first ancestor will be
|
|
* scrolled into view.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
ScrollSelectionIntoView(mozilla::SelectionType aSelectionType,
|
|
SelectionRegion aRegion, int16_t aFlags) const;
|
|
|
|
/**
|
|
* RepaintSelection repaints the selected frames that are inside the
|
|
* selection specified by aSelectionType.
|
|
*
|
|
* @param aSelectionType The selection type what you want to repaint.
|
|
*/
|
|
nsresult RepaintSelection(mozilla::SelectionType aSelectionType);
|
|
|
|
/**
|
|
* Return true if aContainerNode is in the selection limiter or the ancestor
|
|
* limiter if one of them is set.
|
|
*
|
|
* Note that this returns true when aContainerNode may be in the scope of
|
|
* an independent selection. Therefore, even if this returns `true`,
|
|
* aContainerNode may not be valid container node for a selection managed
|
|
* by this instance.
|
|
*/
|
|
[[nodiscard]] bool NodeIsInLimiters(const nsINode* aContainerNode) const {
|
|
return mLimiters.NodeIsInLimiters(aContainerNode);
|
|
}
|
|
|
|
/**
|
|
* Return true if the both start and end containers of aRange are in the
|
|
* limiters.
|
|
*
|
|
* Note that this returns true when aRange may be in the scope of an
|
|
* independent selection. Therefore, even if this returns `true`,
|
|
* aRange may not be valid editable range in the UA shadow of the text
|
|
* control element.
|
|
*/
|
|
[[nodiscard]] bool RangeInLimiters(
|
|
const mozilla::dom::AbstractRange& aRange) const {
|
|
return mLimiters.RangeInLimiters(aRange);
|
|
}
|
|
|
|
/**
|
|
* GetFrameToPageSelect() returns a frame which is ancestor limit of
|
|
* per-page selection. The frame may not be scrollable. E.g.,
|
|
* when selection ancestor limit is set to a frame of an editing host of
|
|
* contenteditable element and it's not scrollable.
|
|
*/
|
|
[[nodiscard]] nsIFrame* GetFrameToPageSelect() const;
|
|
|
|
/**
|
|
* This method moves caret (if aExtend is false) or expands selection (if
|
|
* aExtend is true). Then, scrolls aFrame one page. Finally, this may
|
|
* call ScrollSelectionIntoView() for making focus of selection visible
|
|
* but depending on aSelectionIntoView value.
|
|
*
|
|
* @param aForward if true, scroll forward if not scroll backward
|
|
* @param aExtend if true, extend selection to the new point
|
|
* @param aFrame the frame to scroll or container of per-page selection.
|
|
* if aExtend is true and selection may have ancestor limit,
|
|
* should set result of GetFrameToPageSelect().
|
|
* @param aSelectionIntoView
|
|
* If IfChanged, this makes selection into view only when
|
|
* selection is modified by the call.
|
|
* If Yes, this makes selection into view always.
|
|
*/
|
|
enum class SelectionIntoView { IfChanged, Yes };
|
|
MOZ_CAN_RUN_SCRIPT nsresult PageMove(bool aForward, bool aExtend,
|
|
nsIFrame* aFrame,
|
|
SelectionIntoView aSelectionIntoView);
|
|
|
|
void SetHint(CaretAssociationHint aHintRight) { mCaret.mHint = aHintRight; }
|
|
[[nodiscard]] CaretAssociationHint GetHint() const { return mCaret.mHint; }
|
|
|
|
void SetCaretBidiLevelAndMaybeSchedulePaint(
|
|
mozilla::intl::BidiEmbeddingLevel aLevel);
|
|
|
|
/**
|
|
* GetCaretBidiLevel gets the caret bidi level.
|
|
*/
|
|
[[nodiscard]] mozilla::intl::BidiEmbeddingLevel GetCaretBidiLevel() const;
|
|
|
|
/**
|
|
* UndefineCaretBidiLevel sets the caret bidi level to "undefined".
|
|
*/
|
|
void UndefineCaretBidiLevel();
|
|
|
|
/**
|
|
* PhysicalMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move one unit
|
|
* 'aAmount' in the given aDirection.
|
|
* @param aDirection the direction to move the selection
|
|
* @param aAmount amount of movement (char/line; word/page; eol/doc)
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult PhysicalMove(int16_t aDirection, int16_t aAmount,
|
|
bool aExtend);
|
|
|
|
/**
|
|
* CharacterMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move one character
|
|
* left or right.
|
|
* @param aForward move forward in document.
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult CharacterMove(bool aForward, bool aExtend);
|
|
|
|
/**
|
|
* WordMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move one word left or
|
|
* right.
|
|
* @param aForward move forward in document.
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult WordMove(bool aForward, bool aExtend);
|
|
|
|
/**
|
|
* LineMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move one line up or
|
|
* down.
|
|
* @param aForward move forward in document.
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult LineMove(bool aForward, bool aExtend);
|
|
|
|
/**
|
|
* IntraLineMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move to beginning or
|
|
* end of line
|
|
* @param aForward move forward in document.
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult IntraLineMove(bool aForward, bool aExtend);
|
|
|
|
/**
|
|
* ParagraphMove will generally be called from the nsiselectioncontroller
|
|
* implementations. the effect being the selection will move to beginning or
|
|
* end of paragraph
|
|
* @param aForward move forward in document.
|
|
* @param aExtend continue selection
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult ParagraphMove(bool aForward, bool aExtend);
|
|
|
|
/**
|
|
* CreateRangeExtendedToNextGraphemeClusterBoundary() returns range which is
|
|
* extended from normal selection range to start of next grapheme cluster
|
|
* boundary.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToNextGraphemeClusterBoundary(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
|
|
eSelectCluster, eLogical);
|
|
}
|
|
|
|
/**
|
|
* CreateRangeExtendedToPreviousCharacterBoundary() returns range which is
|
|
* extended from normal selection range to start of previous character
|
|
* boundary.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToPreviousCharacterBoundary(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
|
|
eDirPrevious, eSelectCharacter, eLogical);
|
|
}
|
|
|
|
/**
|
|
* CreateRangeExtendedToNextWordBoundary() returns range which is
|
|
* extended from normal selection range to start of next word boundary.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToNextWordBoundary(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
|
|
eSelectWord, eLogical);
|
|
}
|
|
|
|
/**
|
|
* CreateRangeExtendedToPreviousWordBoundary() returns range which is
|
|
* extended from normal selection range to start of previous word boundary.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToPreviousWordBoundary(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
|
|
eDirPrevious, eSelectWord, eLogical);
|
|
}
|
|
|
|
/**
|
|
* CreateRangeExtendedToPreviousHardLineBreak() returns range which is
|
|
* extended from normal selection range to previous hard line break.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToPreviousHardLineBreak(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
|
|
eDirPrevious, eSelectBeginLine, eLogical);
|
|
}
|
|
|
|
/**
|
|
* CreateRangeExtendedToNextHardLineBreak() returns range which is extended
|
|
* from normal selection range to next hard line break.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToNextHardLineBreak(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
|
|
return CreateRangeExtendedToSomewhere<RangeType>(
|
|
aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
|
|
eSelectEndLine, eLogical);
|
|
}
|
|
|
|
/** Sets/Gets The display selection enum.
|
|
*/
|
|
void SetDisplaySelection(int16_t aState) { mDisplaySelection = aState; }
|
|
[[nodiscard]] int16_t GetDisplaySelection() const {
|
|
return mDisplaySelection;
|
|
}
|
|
|
|
/**
|
|
* This method can be used to store the data received during a MouseDown
|
|
* event so that we can place the caret during the MouseUp event.
|
|
*
|
|
* @param aMouseEvent the event received by the selection MouseDown
|
|
* handling method. A nullptr value can be use to tell this method
|
|
* that any data is storing is no longer valid.
|
|
*/
|
|
void SetDelayedCaretData(mozilla::WidgetMouseEvent* aMouseEvent);
|
|
|
|
/**
|
|
* Get the delayed MouseDown event data necessary to place the
|
|
* caret during MouseUp processing.
|
|
*
|
|
* @return a pointer to the event received
|
|
* by the selection during MouseDown processing. It can be nullptr
|
|
* if the data is no longer valid.
|
|
*/
|
|
[[nodiscard]] bool HasDelayedCaretData() const {
|
|
return mDelayedMouseEvent.mIsValid;
|
|
}
|
|
[[nodiscard]] bool IsShiftDownInDelayedCaretData() const {
|
|
NS_ASSERTION(mDelayedMouseEvent.mIsValid, "No valid delayed caret data");
|
|
return mDelayedMouseEvent.mIsShift;
|
|
}
|
|
[[nodiscard]] uint32_t GetClickCountInDelayedCaretData() const {
|
|
NS_ASSERTION(mDelayedMouseEvent.mIsValid, "No valid delayed caret data");
|
|
return mDelayedMouseEvent.mClickCount;
|
|
}
|
|
|
|
[[nodiscard]] bool MouseDownRecorded() const {
|
|
return !GetDragState() && HasDelayedCaretData() &&
|
|
GetClickCountInDelayedCaretData() < 2;
|
|
}
|
|
|
|
[[nodiscard]] const mozilla::SelectionLimiters& LimitersRef() const {
|
|
return mLimiters;
|
|
}
|
|
|
|
/**
|
|
* Returns the selection root element if and only if the instance is for an
|
|
* independent selection. Currently, this is a native anonymous `<div>` for
|
|
* a text control.
|
|
*/
|
|
[[nodiscard]] Element* GetIndependentSelectionRootElement() const {
|
|
return mLimiters.mIndependentSelectionRootElement;
|
|
}
|
|
|
|
/**
|
|
* Get the independent selection root parent which is usually a text control
|
|
* element which hosts the anonymous subtree managed by this frame selection.
|
|
*/
|
|
[[nodiscard]] Element* GetIndependentSelectionRootParentElement() const {
|
|
MOZ_DIAGNOSTIC_ASSERT(IsIndependentSelection());
|
|
return Element::FromNodeOrNull(
|
|
mLimiters.mIndependentSelectionRootElement
|
|
->GetClosestNativeAnonymousSubtreeRootParentOrHost());
|
|
}
|
|
|
|
/**
|
|
* GetAncestorLimiter() returns the root of current selection ranges. This is
|
|
* typically the focused editing host unless it's the root element of the
|
|
* document.
|
|
*/
|
|
[[nodiscard]] Element* GetAncestorLimiter() const {
|
|
return mLimiters.mAncestorLimiter;
|
|
}
|
|
|
|
[[nodiscard]] Element* GetAncestorLimiterOrIndependentSelectionRootElement()
|
|
const {
|
|
return mLimiters.mAncestorLimiter
|
|
? mLimiters.mAncestorLimiter
|
|
: mLimiters.mIndependentSelectionRootElement;
|
|
}
|
|
|
|
/**
|
|
* Set ancestor limiter. If aLimiter is not nullptr, this adjusts all
|
|
* selection ranges into the limiter element. Thus, calling this may run
|
|
* the selection listeners.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void SetAncestorLimiter(Element* aLimiter);
|
|
|
|
/**
|
|
* GetPrevNextBidiLevels will return the frames and associated Bidi levels of
|
|
* the characters logically before and after a (collapsed) selection.
|
|
*
|
|
* @param aNode is the node containing the selection
|
|
* @param aContentOffset is the offset of the selection in the node
|
|
* @param aJumpLines
|
|
* If true, look across line boundaries.
|
|
* If false, behave as if there were base-level frames at line edges.
|
|
*
|
|
* @return A struct holding the before/after frame and the before/after
|
|
* level.
|
|
*
|
|
* At the beginning and end of each line there is assumed to be a frame with
|
|
* Bidi level equal to the paragraph embedding level.
|
|
*
|
|
* In these cases the before frame and after frame respectively will be
|
|
* nullptr.
|
|
*/
|
|
[[nodiscard]] nsPrevNextBidiLevels GetPrevNextBidiLevels(
|
|
nsIContent* aNode, uint32_t aContentOffset, bool aJumpLines) const;
|
|
|
|
/**
|
|
* MaintainSelection will track the normal selection as being "sticky".
|
|
* Dragging or extending selection will never allow for a subset
|
|
* (or the whole) of the maintained selection to become unselected.
|
|
* Primary use: double click selecting then dragging on second click
|
|
*
|
|
* @param aAmount the initial amount of text selected (word, line or
|
|
* paragraph). For "line", use eSelectBeginLine.
|
|
*/
|
|
nsresult MaintainSelection(nsSelectionAmount aAmount = eSelectNoAmount);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult ConstrainFrameAndPointToAnchorSubtree(
|
|
nsIFrame* aFrame, const nsPoint& aPoint, nsIFrame** aRetFrame,
|
|
nsPoint& aRetPoint) const;
|
|
|
|
/**
|
|
* @param aPresShell is the parameter to be used for most of the other calls
|
|
* for callbacks etc
|
|
*
|
|
* @param aAccessibleCaretEnabled true if we should enable the accessible
|
|
* caret.
|
|
*
|
|
* @param aEditorRootAnonymousDiv if this instance is for an independent
|
|
* selection for a text control, specify this to the anonymous <div> element
|
|
* of the text control which contains only an editable Text and/or a <br>.
|
|
*/
|
|
nsFrameSelection(mozilla::PresShell* aPresShell, bool aAccessibleCaretEnabled,
|
|
Element* aEditorRootAnonymousDiv = nullptr);
|
|
|
|
/**
|
|
* @param aRequesterFuncName function name which wants to start the batch.
|
|
* This won't be stored nor exposed to selection listeners etc, used only for
|
|
* logging.
|
|
*/
|
|
void StartBatchChanges(const char* aRequesterFuncName);
|
|
|
|
/**
|
|
* @param aRequesterFuncName function name which wants to end the batch.
|
|
* This won't be stored nor exposed to selection listeners etc, used only for
|
|
* logging.
|
|
* @param aReasons potentially multiple of the reasons defined in
|
|
* nsISelectionListener.idl
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void EndBatchChanges(
|
|
const char* aRequesterFuncName,
|
|
int16_t aReasons = nsISelectionListener::NO_REASON);
|
|
|
|
[[nodiscard]] mozilla::PresShell* GetPresShell() const { return mPresShell; }
|
|
|
|
void DisconnectFromPresShell();
|
|
MOZ_CAN_RUN_SCRIPT nsresult ClearNormalSelection();
|
|
|
|
// Table selection support.
|
|
static nsITableCellLayout* GetCellLayout(const nsIContent* aCellContent);
|
|
|
|
/**
|
|
* Called when eFocus event of aDocument will be dispatched to the DOM.
|
|
*/
|
|
static void WillFocusDocument(mozilla::PresShell& aPresShell,
|
|
mozilla::dom::Document& aDocument);
|
|
|
|
/**
|
|
* Called when eBlur event of aDocument will be dispatched to the DOM.
|
|
*/
|
|
static void WillBlurDocument(mozilla::PresShell& aPresShell,
|
|
mozilla::dom::Document& aDocument);
|
|
|
|
private:
|
|
~nsFrameSelection();
|
|
|
|
/**
|
|
* Populates an existing highlight Selection with ranges from a Highlight.
|
|
* Must be called after the Selection is registered in mHighlightSelections.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void PopulateHighlightSelection(
|
|
mozilla::dom::Selection& aSelection, mozilla::dom::Highlight& aHighlight);
|
|
|
|
// TODO: in case an error is returned, it sometimes refers to a programming
|
|
// error, in other cases to runtime errors. This deserves to be cleaned up.
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
TakeFocus(nsIContent& aNewFocus, uint32_t aContentOffset,
|
|
uint32_t aContentEndOffset, CaretAssociationHint aHint,
|
|
FocusMode aFocusMode);
|
|
|
|
/**
|
|
* 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 BidiLevelFromMove(mozilla::PresShell* aPresShell, nsIContent* aNode,
|
|
uint32_t aContentOffset, nsSelectionAmount aAmount,
|
|
CaretAssociationHint aHint);
|
|
/**
|
|
* 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 BidiLevelFromClick(nsIContent* aNewFocus, uint32_t aContentOffset);
|
|
|
|
/**
|
|
* @param aReasons potentially multiple of the reasons defined in
|
|
* nsISelectionListener.idl.
|
|
*/
|
|
void SetChangeReasons(int16_t aReasons) {
|
|
mSelectionChangeReasons = aReasons;
|
|
}
|
|
|
|
/**
|
|
* @param aReasons potentially multiple of the reasons defined in
|
|
* nsISelectionListener.idl.
|
|
*/
|
|
void AddChangeReasons(int16_t aReasons) {
|
|
mSelectionChangeReasons |= aReasons;
|
|
}
|
|
|
|
/**
|
|
* @return potentially multiple of the reasons defined in
|
|
* nsISelectionListener.idl.
|
|
*/
|
|
[[nodiscard]] int16_t PopChangeReasons() {
|
|
int16_t retval = mSelectionChangeReasons;
|
|
mSelectionChangeReasons = nsISelectionListener::NO_REASON;
|
|
return retval;
|
|
}
|
|
|
|
[[nodiscard]] nsSelectionAmount GetCaretMoveAmount() {
|
|
return mCaretMoveAmount;
|
|
}
|
|
|
|
[[nodiscard]] bool IsUserSelectionReason() const {
|
|
return (mSelectionChangeReasons &
|
|
(nsISelectionListener::DRAG_REASON |
|
|
nsISelectionListener::MOUSEDOWN_REASON |
|
|
nsISelectionListener::MOUSEUP_REASON |
|
|
nsISelectionListener::KEYPRESS_REASON)) !=
|
|
nsISelectionListener::NO_REASON;
|
|
}
|
|
|
|
friend class mozilla::dom::Selection;
|
|
friend class mozilla::SelectionChangeEventDispatcher;
|
|
friend struct mozilla::AutoPrepareFocusRange;
|
|
|
|
/*HELPER METHODS*/
|
|
// Whether MoveCaret should use logical or visual movement,
|
|
// or follow the bidi.edit.caret_movement_style preference.
|
|
enum CaretMovementStyle { eLogical, eVisual, eUsePrefStyle };
|
|
enum class ExtendSelection : bool { No, Yes };
|
|
MOZ_CAN_RUN_SCRIPT nsresult MoveCaret(nsDirection aDirection,
|
|
ExtendSelection aExtendSelection,
|
|
nsSelectionAmount aAmount,
|
|
CaretMovementStyle aMovementStyle);
|
|
|
|
/**
|
|
* @brief Creates `PeekOffsetOptions` for caret move operations.
|
|
*
|
|
* @param aSelection The selection object. Must be non-null
|
|
* @param aExtendSelection Whether the selection should be extended or not
|
|
* @param aMovementStyle The `CaretMovementStyle` (logical or visual)
|
|
* @return mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
|
|
*/
|
|
[[nodiscard]] mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
|
|
CreatePeekOffsetOptionsForCaretMove(mozilla::dom::Selection* aSelection,
|
|
ExtendSelection aExtendSelection,
|
|
CaretMovementStyle aMovementStyle) const {
|
|
MOZ_ASSERT(aSelection);
|
|
return CreatePeekOffsetOptionsForCaretMove(
|
|
mLimiters.mIndependentSelectionRootElement,
|
|
static_cast<ForceEditableRegion>(aSelection->IsEditorSelection()),
|
|
aExtendSelection, aMovementStyle);
|
|
}
|
|
|
|
enum class ForceEditableRegion : bool { No, Yes };
|
|
[[nodiscard]] static mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
|
|
CreatePeekOffsetOptionsForCaretMove(const Element* aSelectionLimiter,
|
|
ForceEditableRegion aForceEditableRegion,
|
|
ExtendSelection aExtendSelection,
|
|
CaretMovementStyle aMovementStyle);
|
|
|
|
/**
|
|
* @brief Get the Ancestor Limiter for caret move operation.
|
|
*
|
|
* If the selection is an editor selection, the correct editing host is
|
|
* identified and chosen as limiting element.
|
|
*
|
|
* @param aSelection The selection object. Must be non-null
|
|
* @return The ancestor limiter, or nullptr.
|
|
*/
|
|
[[nodiscard]] mozilla::Result<Element*, nsresult>
|
|
GetAncestorLimiterForCaretMove(mozilla::dom::Selection* aSelection) const;
|
|
|
|
/**
|
|
* CreateRangeExtendedToSomewhere() is common method to implement
|
|
* CreateRangeExtendedTo*(). This method creates a range extended from
|
|
* aRange.
|
|
*
|
|
* @param aLimitersAndCaretData The data of limiters and additional
|
|
* caret data.
|
|
* @param aRange The range which you want to extend.
|
|
* @param aRangeDirection eDirNext if the start boundary of
|
|
* aRange is focus. Otherwise, i.e., if
|
|
* the start boundary is anchor,
|
|
* eDirPrevious.
|
|
* @param aExtendDirection Whether you want to extend the range
|
|
* backward or forward.
|
|
* @param aAmount The amount which you want to extend.
|
|
* @param aMovementStyle Whether visual or logical.
|
|
*/
|
|
template <typename RangeType>
|
|
MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
|
|
CreateRangeExtendedToSomewhere(
|
|
mozilla::PresShell& aPresShell,
|
|
const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
|
|
const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection,
|
|
nsDirection aExtendDirection, const nsSelectionAmount aAmount,
|
|
CaretMovementStyle aMovementStyle);
|
|
|
|
void InvalidateDesiredCaretPos(); // do not listen to mDesiredCaretPos.mValue
|
|
// you must get another.
|
|
|
|
[[nodiscard]] bool IsBatching() const { return mBatching.mCounter > 0; }
|
|
|
|
enum class IsBatchingEnd : bool { No, Yes };
|
|
|
|
// nsFrameSelection may get deleted when calling this,
|
|
// so remember to use nsCOMPtr when needed.
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
NotifySelectionListeners(mozilla::SelectionType aSelectionType,
|
|
IsBatchingEnd aEndBatching = IsBatchingEnd::No);
|
|
|
|
static nsresult GetCellIndexes(const nsIContent* aCell, int32_t& aRowIndex,
|
|
int32_t& aColIndex);
|
|
|
|
[[nodiscard]] static nsIContent* GetFirstCellNodeInRange(
|
|
const nsRange* aRange);
|
|
// Returns non-null table if in same table, null otherwise
|
|
[[nodiscard]] static nsIContent* IsInSameTable(const nsIContent* aContent1,
|
|
const nsIContent* aContent2);
|
|
// Might return null
|
|
[[nodiscard]] static nsIContent* GetParentTable(const nsIContent* aCellNode);
|
|
|
|
////////////BEGIN nsFrameSelection members
|
|
|
|
RefPtr<mozilla::dom::Selection>
|
|
mDomSelections[sizeof(mozilla::kPresentSelectionTypes) /
|
|
sizeof(mozilla::SelectionType)];
|
|
|
|
nsTArray<
|
|
mozilla::CompactPair<RefPtr<nsAtom>, RefPtr<mozilla::dom::Selection>>>
|
|
mHighlightSelections;
|
|
|
|
struct TableSelection {
|
|
// Get our first range, if its first selected node is a cell. If this does
|
|
// not return null, then the first node in the returned range is a cell
|
|
// (according to GetFirstCellNodeInRange).
|
|
nsRange* GetFirstCellRange(const mozilla::dom::Selection& aNormalSelection);
|
|
|
|
// Get our next range, if its first selected node is a cell. If this does
|
|
// not return null, then the first node in the returned range is a cell
|
|
// (according to GetFirstCellNodeInRange).
|
|
nsRange* GetNextCellRange(const mozilla::dom::Selection& aNormalSelection);
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
HandleSelection(nsINode* aParentContent, int32_t aContentOffset,
|
|
mozilla::TableSelectionMode aTarget,
|
|
mozilla::WidgetMouseEvent* aMouseEvent, bool aDragState,
|
|
mozilla::dom::Selection& aNormalSelection);
|
|
|
|
/**
|
|
* @return the closest inclusive table cell ancestor
|
|
* (https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor) of
|
|
* aContent, if it is actively editable.
|
|
*/
|
|
[[nodiscard]] static nsINode* IsContentInActivelyEditableTableCell(
|
|
nsPresContext* aContext, nsIContent* aContent);
|
|
|
|
// TODO: annotate this with `MOZ_CAN_RUN_SCRIPT` instead.
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
SelectBlockOfCells(nsIContent* aStartCell, nsIContent* aEndCell,
|
|
mozilla::dom::Selection& aNormalSelection);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult SelectRowOrColumn(
|
|
nsIContent* aCellContent, mozilla::dom::Selection& aNormalSelection);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
UnselectCells(const nsIContent* aTable, int32_t aStartRowIndex,
|
|
int32_t aStartColumnIndex, int32_t aEndRowIndex,
|
|
int32_t aEndColumnIndex, bool aRemoveOutsideOfCellRange,
|
|
mozilla::dom::Selection& aNormalSelection);
|
|
|
|
nsCOMPtr<nsINode>
|
|
mClosestInclusiveTableCellAncestor; // used to snap to table selection
|
|
nsCOMPtr<nsIContent> mStartSelectedCell;
|
|
nsCOMPtr<nsIContent> mEndSelectedCell;
|
|
nsCOMPtr<nsIContent> mAppendStartSelectedCell;
|
|
nsCOMPtr<nsIContent> mUnselectCellOnMouseUp;
|
|
mozilla::TableSelectionMode mMode = mozilla::TableSelectionMode::None;
|
|
int32_t mSelectedCellIndex = 0;
|
|
bool mDragSelectingCells = false;
|
|
|
|
private:
|
|
struct MOZ_STACK_CLASS FirstAndLastCell {
|
|
nsCOMPtr<nsIContent> mFirst;
|
|
nsCOMPtr<nsIContent> mLast;
|
|
};
|
|
|
|
[[nodiscard]] mozilla::Result<FirstAndLastCell, nsresult>
|
|
FindFirstAndLastCellOfRowOrColumn(const nsIContent& aCellContent) const;
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleDragSelecting(
|
|
mozilla::TableSelectionMode aTarget, nsIContent* aChildContent,
|
|
const mozilla::WidgetMouseEvent* aMouseEvent,
|
|
mozilla::dom::Selection& aNormalSelection);
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleMouseUpOrDown(
|
|
mozilla::TableSelectionMode aTarget, bool aDragState,
|
|
nsIContent* aChildContent, nsINode* aParentContent,
|
|
int32_t aContentOffset, const mozilla::WidgetMouseEvent* aMouseEvent,
|
|
mozilla::dom::Selection& aNormalSelection);
|
|
|
|
class MOZ_STACK_CLASS RowAndColumnRelation;
|
|
};
|
|
|
|
TableSelection mTableSelection;
|
|
|
|
struct MaintainedRange {
|
|
/**
|
|
* Ensure anchor and focus of aNormalSelection are ordered appropriately
|
|
* relative to the maintained range.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void AdjustNormalSelection(
|
|
const nsIContent* aContent, int32_t aOffset,
|
|
mozilla::dom::Selection& aNormalSelection) const;
|
|
|
|
/**
|
|
* @param aStopAtScroller If yes, this will
|
|
* set `PeekOffsetOption::StopAtScroller`.
|
|
*/
|
|
enum class StopAtScroller : bool { No, Yes };
|
|
void AdjustContentOffsets(nsIFrame::ContentOffsets& aOffsets,
|
|
StopAtScroller aStopAtScroller) const;
|
|
|
|
void MaintainAnchorFocusRange(
|
|
const mozilla::dom::Selection& aNormalSelection,
|
|
nsSelectionAmount aAmount);
|
|
|
|
RefPtr<nsRange> mRange;
|
|
nsSelectionAmount mAmount = eSelectNoAmount;
|
|
};
|
|
|
|
MaintainedRange mMaintainedRange;
|
|
|
|
struct Batching {
|
|
uint32_t mCounter = 0;
|
|
};
|
|
|
|
Batching mBatching;
|
|
|
|
mozilla::SelectionLimiters mLimiters;
|
|
|
|
mozilla::PresShell* mPresShell = nullptr;
|
|
// Reasons for notifications of selection changing.
|
|
// Can be multiple of the reasons defined in nsISelectionListener.idl.
|
|
int16_t mSelectionChangeReasons = nsISelectionListener::NO_REASON;
|
|
// For visual display purposes.
|
|
int16_t mDisplaySelection = nsISelectionController::SELECTION_OFF;
|
|
nsSelectionAmount mCaretMoveAmount = eSelectNoAmount;
|
|
|
|
struct Caret {
|
|
// Hint to tell if the selection is at the end of this line or beginning of
|
|
// next.
|
|
CaretAssociationHint mHint = CaretAssociationHint::Before;
|
|
mozilla::intl::BidiEmbeddingLevel mBidiLevel = BIDI_LEVEL_UNDEFINED;
|
|
|
|
[[nodiscard]] static bool IsVisualMovement(
|
|
ExtendSelection aExtendSelection, CaretMovementStyle aMovementStyle);
|
|
};
|
|
|
|
Caret mCaret;
|
|
|
|
mozilla::intl::BidiEmbeddingLevel mKbdBidiLevel =
|
|
mozilla::intl::BidiEmbeddingLevel::LTR();
|
|
|
|
class DesiredCaretPos {
|
|
public:
|
|
// the position requested by the Key Handling for up down
|
|
nsresult FetchPos(nsPoint& aDesiredCaretPos,
|
|
const mozilla::PresShell& aPresShell,
|
|
mozilla::dom::Selection& aNormalSelection) const;
|
|
|
|
void Set(const nsPoint& aPos);
|
|
|
|
void Invalidate();
|
|
|
|
bool mIsSet = false;
|
|
|
|
private:
|
|
nsPoint mValue;
|
|
};
|
|
|
|
DesiredCaretPos mDesiredCaretPos;
|
|
|
|
struct DelayedMouseEvent {
|
|
bool mIsValid = false;
|
|
// These values are not used since they are only valid when mIsValid is
|
|
// true, and setting mIsValid always overrides these values.
|
|
bool mIsShift = false;
|
|
uint32_t mClickCount = 0;
|
|
};
|
|
|
|
DelayedMouseEvent mDelayedMouseEvent;
|
|
|
|
bool mDragState = false; // for drag purposes
|
|
bool mAccessibleCaretEnabled = false;
|
|
|
|
// Records if a selection was created by doubleclicking or tripleclicking
|
|
// a word. This information is needed later on to determine if a leading
|
|
// or trailing whitespace needs to be removed as well to achieve
|
|
// native behaviour on macOS.
|
|
mozilla::dom::ClickSelectionType mClickSelectionType =
|
|
mozilla::dom::ClickSelectionType::NotApplicable;
|
|
};
|
|
|
|
/**
|
|
* Selection Batcher class that supports multiple FrameSelections.
|
|
*/
|
|
class MOZ_RAII AutoFrameSelectionBatcher final {
|
|
public:
|
|
MOZ_CAN_RUN_SCRIPT explicit AutoFrameSelectionBatcher(
|
|
const char* aFunctionName, size_t aEstimatedSize = 1)
|
|
: mFunctionName(aFunctionName) {
|
|
mFrameSelections.SetCapacity(aEstimatedSize);
|
|
}
|
|
MOZ_CAN_RUN_SCRIPT ~AutoFrameSelectionBatcher() {
|
|
for (const auto& frameSelection : mFrameSelections) {
|
|
MOZ_KnownLive(frameSelection)->EndBatchChanges(mFunctionName);
|
|
}
|
|
}
|
|
void AddFrameSelection(nsFrameSelection* aFrameSelection) {
|
|
if (!aFrameSelection) {
|
|
return;
|
|
}
|
|
aFrameSelection->StartBatchChanges(mFunctionName);
|
|
mFrameSelections.AppendElement(aFrameSelection);
|
|
}
|
|
|
|
private:
|
|
const char* mFunctionName;
|
|
AutoTArray<RefPtr<nsFrameSelection>, 1> mFrameSelections;
|
|
};
|
|
|
|
namespace mozilla {
|
|
|
|
/**
|
|
* A struct for sharing nsFrameSelection outside of its instance.
|
|
*/
|
|
struct LimitersAndCaretData : public SelectionLimiters {
|
|
using Element = dom::Element;
|
|
|
|
LimitersAndCaretData() = default;
|
|
MOZ_IMPLICIT LimitersAndCaretData(const LimitersAndCaretData&) = default;
|
|
LimitersAndCaretData(LimitersAndCaretData&&) = default;
|
|
LimitersAndCaretData& operator=(const LimitersAndCaretData&) = default;
|
|
LimitersAndCaretData& operator=(LimitersAndCaretData&&) = default;
|
|
explicit LimitersAndCaretData(const nsFrameSelection& aFrameSelection)
|
|
: SelectionLimiters(aFrameSelection.LimitersRef()),
|
|
mCaretAssociationHint(aFrameSelection.GetHint()),
|
|
mCaretBidiLevel(aFrameSelection.GetCaretBidiLevel()) {}
|
|
|
|
// nsFrameSelection::GetHint
|
|
CaretAssociationHint mCaretAssociationHint = CaretAssociationHint::Before;
|
|
// nsFrameSelection::GetCaretBidiLevel
|
|
intl::BidiEmbeddingLevel mCaretBidiLevel;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif /* nsFrameSelection_h_ */
|