Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-02 20:42:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 571294 - Part 1: Implement selection events behind the dom.select_events.enabled pref, r=smaug

Browse Source
This commit is contained in:
Michael Layzell 2015-08-12 13:26:01 -04:00
parent 7b2f24f27d
commit fe31896607
15 changed files with 435 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dom/base/FragmentOrElement.cpp
View File

@ -814,6 +814,7 @@ nsIContent::PreHandleEvent(EventChainPreVisitor& aVisitor)
case eFormReset:
case eResize:
case eScroll:
case NS_SELECT_START:
stopEvent = true;
break;
case eUnidentifiedEvent:
@ -827,8 +828,7 @@ nsIContent::PreHandleEvent(EventChainPreVisitor& aVisitor)
eventType.EqualsLiteral("load") ||
eventType.EqualsLiteral("reset") ||
eventType.EqualsLiteral("resize") ||
eventType.EqualsLiteral("scroll") ||
eventType.EqualsLiteral("selectstart")) {
eventType.EqualsLiteral("scroll")) {
stopEvent = true;
}
}

2
dom/base/nsGkAtomList.h
View File

@ -882,6 +882,8 @@ GK_ATOM(onscanningstatechanged, "onscanningstatechanged")
GK_ATOM(onscostatuschanged, "onscostatuschanged")
GK_ATOM(onscroll, "onscroll")
GK_ATOM(onselect, "onselect")
GK_ATOM(onselectionchange, "onselectionchange")
GK_ATOM(onselectstart, "onselectstart")
GK_ATOM(onsending, "onsending")
GK_ATOM(onsent, "onsent")
GK_ATOM(onset, "onset")

60
dom/base/nsRange.cpp
View File

@ -31,6 +31,7 @@
#include "mozilla/dom/RangeBinding.h"
#include "mozilla/dom/DOMRect.h"
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/Telemetry.h"
#include "mozilla/Likely.h"
#include "nsCSSFrameConstructor.h"
@ -194,6 +195,26 @@ nsRange::~nsRange()
DoSetRange(nullptr, 0, nullptr, 0, nullptr);
}
nsRange::nsRange(nsINode* aNode)
: mRoot(nullptr)
, mStartOffset(0)
, mEndOffset(0)
, mIsPositioned(false)
, mIsDetached(false)
, mMaySpanAnonymousSubtrees(false)
, mIsGenerated(false)
, mStartOffsetWasIncremented(false)
, mEndOffsetWasIncremented(false)
, mEnableGravitationOnElementRemoval(true)
#ifdef DEBUG
, mAssertNextInsertOrAppendIndex(-1)
, mAssertNextInsertOrAppendNode(nullptr)
#endif
{
MOZ_ASSERT(aNode, "range isn't in a document!");
mOwner = aNode->OwnerDoc();
}
/* static */
nsresult
nsRange::CreateRange(nsINode* aStartParent, int32_t aStartOffset,
@ -269,6 +290,10 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsRange)
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner);
tmp->Reset();
// This needs to be unlinked after Reset() is called, as it controls
// the result of IsInSelection() which is used by tmp->Reset().
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelection);
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsRange)
@ -276,6 +301,7 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsRange)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStartParent)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndParent)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelection)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
@ -879,14 +905,20 @@ nsRange::DoSetRange(nsINode* aStartN, int32_t aStartOffset,
RegisterCommonAncestor(newCommonAncestor);
} else {
NS_ASSERTION(!mIsPositioned, "unexpected disconnected nodes");
mInSelection = false;
mSelection = nullptr;
}
}
}
// This needs to be the last thing this function does. See comment
// in ParentChainChanged.
// This needs to be the last thing this function does, other than notifying
// selection listeners. See comment in ParentChainChanged.
mRoot = aRoot;
// Notify any selection listeners. This has to occur last because otherwise the world
// could be observed by a selection listener while the range was in an invalid state.
if (mSelection) {
mSelection->NotifySelectionListeners();
}
}
static int32_t
@ -897,6 +929,28 @@ IndexOf(nsINode* aChild)
return parent ? parent->IndexOf(aChild) : -1;
}
void
nsRange::SetSelection(mozilla::dom::Selection* aSelection)
{
if (mSelection == aSelection) {
return;
}
// At least one of aSelection and mSelection must be null
// aSelection will be null when we are removing from a selection
// and a range can't be in more than one selection at a time,
// thus mSelection must be null too.
MOZ_ASSERT(!aSelection || !mSelection);
mSelection = aSelection;
nsINode* commonAncestor = GetCommonAncestor();
NS_ASSERTION(commonAncestor, "unexpected disconnected nodes");
if (mSelection) {
RegisterCommonAncestor(commonAncestor);
} else {
UnregisterCommonAncestor(commonAncestor);
}
}
nsINode*
nsRange::GetCommonAncestor() const
{

43
dom/base/nsRange.h
View File

@ -28,6 +28,7 @@ namespace dom {
class DocumentFragment;
class DOMRect;
class DOMRectList;
class Selection;
} // namespace dom
} // namespace mozilla
@ -42,26 +43,7 @@ class nsRange final : public nsIDOMRange,
virtual ~nsRange();
public:
explicit nsRange(nsINode* aNode)
: mRoot(nullptr)
, mStartOffset(0)
, mEndOffset(0)
, mIsPositioned(false)
, mIsDetached(false)
, mMaySpanAnonymousSubtrees(false)
, mInSelection(false)
, mIsGenerated(false)
, mStartOffsetWasIncremented(false)
, mEndOffsetWasIncremented(false)
, mEnableGravitationOnElementRemoval(true)
#ifdef DEBUG
, mAssertNextInsertOrAppendIndex(-1)
, mAssertNextInsertOrAppendNode(nullptr)
#endif
{
MOZ_ASSERT(aNode, "range isn't in a document!");
mOwner = aNode->OwnerDoc();
}
explicit nsRange(nsINode* aNode);
static nsresult CreateRange(nsIDOMNode* aStartParent, int32_t aStartOffset,
nsIDOMNode* aEndParent, int32_t aEndOffset,
@ -129,31 +111,18 @@ public:
}
/**
* Return true iff this range is part of at least one Selection object
* Return true iff this range is part of a Selection object
* and isn't detached.
*/
bool IsInSelection() const
{
return mInSelection;
return !!mSelection;
}
/**
* Called when the range is added/removed from a Selection.
*/
void SetInSelection(bool aInSelection)
{
if (mInSelection == aInSelection) {
return;
}
mInSelection = aInSelection;
nsINode* commonAncestor = GetCommonAncestor();
NS_ASSERTION(commonAncestor, "unexpected disconnected nodes");
if (mInSelection) {
RegisterCommonAncestor(commonAncestor);
} else {
UnregisterCommonAncestor(commonAncestor);
}
}
void SetSelection(mozilla::dom::Selection* aSelection);
/**
* Return true if this range was generated.
@ -349,13 +318,13 @@ protected:
nsCOMPtr<nsINode> mRoot;
nsCOMPtr<nsINode> mStartParent;
nsCOMPtr<nsINode> mEndParent;
nsRefPtr<mozilla::dom::Selection> mSelection;
int32_t mStartOffset;
int32_t mEndOffset;
bool mIsPositioned : 1;
bool mIsDetached : 1;
bool mMaySpanAnonymousSubtrees : 1;
bool mInSelection : 1;
bool mIsGenerated : 1;
bool mStartOffsetWasIncremented : 1;
bool mEndOffsetWasIncremented : 1;

8
dom/events/EventNameList.h
View File

@ -350,6 +350,10 @@ EVENT(lostpointercapture,
ePointerLostCapture,
EventNameType_All,
ePointerEventClass)
EVENT(selectstart,
NS_SELECT_START,
EventNameType_HTMLXUL,
eBasicEventClass)
// Not supported yet; probably never because "wheel" is a better idea.
// EVENT(mousewheel)
@ -584,6 +588,10 @@ DOCUMENT_ONLY_EVENT(readystatechange,
eReadyStateChange,
EventNameType_HTMLXUL,
eBasicEventClass)
DOCUMENT_ONLY_EVENT(selectionchange,
NS_SELECTION_CHANGE,
EventNameType_HTMLXUL,
eBasicEventClass)
NON_IDL_EVENT(MozMouseHittest,
eMouseHitTest,

3
dom/webidl/Document.webidl
View File

@ -151,6 +151,9 @@ partial interface Document {
attribute EventHandler onpaste;
attribute EventHandler onbeforescriptexecute;
attribute EventHandler onafterscriptexecute;
[Pref="dom.select_events.enabled"]
attribute EventHandler onselectionchange;
/**
* True if this document is synthetic : stand alone image, video, audio file,
* etc.

3
dom/webidl/EventHandler.webidl
View File

@ -89,6 +89,9 @@ interface GlobalEventHandlers {
attribute EventHandler onvolumechange;
attribute EventHandler onwaiting;
[Pref="dom.select_events.enabled"]
attribute EventHandler onselectstart;
// Pointer events handlers
[Pref="dom.w3c_pointer_events.enabled"]
attribute EventHandler onpointercancel;

8
editor/libeditor/nsTextEditRules.cpp
View File

@ -831,6 +831,14 @@ nsTextEditRules::WillDeleteSelection(Selection* aSelection,
}
nsresult res = NS_OK;
// If the current selection is empty (e.g the user presses backspace with
// a collapsed selection), then we want to avoid sending the selectstart
// event to the user, so we hide selection changes. However, we still
// want to send a single selectionchange event to the document, so we
// batch the selectionchange events, such that a single event fires after
// the AutoHideSelectionChanges destructor has been run.
SelectionBatcher selectionBatcher(aSelection);
AutoHideSelectionChanges hideSelection(aSelection);
nsAutoScriptBlocker scriptBlocker;
if (IsPasswordEditor())

9
extensions/spellcheck/src/mozInlineSpellChecker.cpp
View File

@ -946,13 +946,20 @@ mozInlineSpellChecker::ReplaceWord(nsIDOMNode *aNode, int32_t aOffset,
if (range)
{
// This range was retrieved from the spellchecker selection. As
// ranges cannot be shared between selections, we must clone it
// before adding it to the editor's selection.
nsCOMPtr<nsIDOMRange> editorRange;
res = range->CloneRange(getter_AddRefs(editorRange));
NS_ENSURE_SUCCESS(res, res);
nsAutoPlaceHolderBatch phb(editor, nullptr);
nsCOMPtr<nsISelection> selection;
res = editor->GetSelection(getter_AddRefs(selection));
NS_ENSURE_SUCCESS(res, res);
selection->RemoveAllRanges();
selection->AddRange(range);
selection->AddRange(editorRange);
editor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
nsCOMPtr<nsIPlaintextEditor> textEditor(do_QueryReferent(mEditor));

42
layout/generic/Selection.h
View File

@ -108,7 +108,7 @@ public:
* into multiple ranges to exclude those before adding the resulting ranges
* to this Selection.
*/
nsresult AddItem(nsRange* aRange, int32_t* aOutIndex);
nsresult AddItem(nsRange* aRange, int32_t* aOutIndex, bool aNoStartSelect = false);
nsresult RemoveItem(nsRange* aRange);
nsresult RemoveCollapsedRanges();
nsresult Clear(nsPresContext* aPresContext);
@ -204,6 +204,9 @@ public:
int16_t aVPercent, int16_t aHPercent,
mozilla::ErrorResult& aRv);
void AddSelectionChangeBlocker();
void RemoveSelectionChangeBlocker();
bool IsBlockingSelectionChangeEvents() const;
private:
friend class ::nsAutoScrollTimer;
@ -229,6 +232,7 @@ public:
AutoRestore<bool> mSavedValue;
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
};
private:
friend struct mozilla::AutoPrepareFocusRange;
class ScrollSelectionIntoViewEvent;
@ -282,6 +286,8 @@ private:
int32_t* aStartIndex, int32_t* aEndIndex);
RangeData* FindRangeData(nsIDOMRange* aRange);
void UserSelectRangesToAdd(nsRange* aItem, nsTArray<nsRefPtr<nsRange> >& rangesToAdd);
/**
* Helper method for AddItem.
*/
@ -312,9 +318,14 @@ private:
SelectionType mType;
/**
* True if the current selection operation was initiated by user action.
* It determines whether we exclude -moz-user-select:none nodes or not.
* It determines whether we exclude -moz-user-select:none nodes or not,
* as well as whether selectstart events will be fired.
*/
bool mApplyUserSelectStyle;
// 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.
@ -339,6 +350,33 @@ public:
}
};
class MOZ_STACK_CLASS AutoHideSelectionChanges final
{
private:
nsRefPtr<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

57
layout/generic/SelectionChangeListener.h Normal file
View File

@ -0,0 +1,57 @@
/* -*- 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_SelectionChangeListener_h_
#define mozilla_SelectionChangeListener_h_
#include "nsISelectionListener.h"
#include "nsISelectionPrivate.h"
#include "mozilla/Attributes.h"
namespace mozilla {
namespace dom {
class SelectionChangeListener final : public nsISelectionListener
{
public:
// SelectionChangeListener has to participate in cycle collection because
// it holds strong references to nsINodes in its mOldRanges array.
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(SelectionChangeListener)
NS_DECL_NSISELECTIONLISTENER
// This field is used to keep track of the ranges which were present in the
// selection when the selectionchange event was previously fired. This allows
// for the selectionchange event to only be fired when a selection is actually
// changed.
struct RawRangeData
{
// These properties are not void*s to avoid the potential situation where the
// nsINode is freed, and a new nsINode is allocated with the same address, which
// could potentially break the comparison logic. In reality, this is extremely
// unlikely to occur (potentially impossible), but these nsCOMPtrs are safer.
// They are never dereferenced.
nsCOMPtr<nsINode> mStartParent;
nsCOMPtr<nsINode> mEndParent;
// XXX These are int32_ts on nsRange, but uint32_ts in the return value
// of GetStart_, so I use uint32_ts here. See bug 1194256.
uint32_t mStartOffset;
uint32_t mEndOffset;
explicit RawRangeData(const nsRange* aRange);
bool Equals(const nsRange* aRange);
};
private:
nsTArray<RawRangeData> mOldRanges;
~SelectionChangeListener() {}
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_SelectionChangeListener_h_

2
layout/generic/nsFrameSelection.h
View File

@ -752,6 +752,8 @@ private:
bool mDesiredPosSet;
int8_t mCaretMovementStyle;
static bool sSelectionEventsEnabled;
};
#endif /* nsFrameSelection_h___ */

254
layout/generic/nsSelection.cpp
View File

@ -68,6 +68,7 @@ static NS_DEFINE_CID(kFrameTraversalCID, NS_FRAMETRAVERSAL_CID);
#include "nsISelectionController.h"//for the enums
#include "nsAutoCopyListener.h"
#include "SelectionChangeListener.h"
#include "nsCopySupport.h"
#include "nsIClipboard.h"
#include "nsIFrameInlines.h"
@ -79,6 +80,7 @@ static NS_DEFINE_CID(kFrameTraversalCID, NS_FRAMETRAVERSAL_CID);
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/SelectionBinding.h"
#include "mozilla/AsyncEventDispatcher.h"
using namespace mozilla;
using namespace mozilla::dom;
@ -412,7 +414,7 @@ struct MOZ_RAII AutoPrepareFocusRange
while (i--) {
range = aSelection->mRanges[i].mRange;
if (range->IsGenerated()) {
range->SetInSelection(false);
range->SetSelection(nullptr);
aSelection->selectFrames(presContext, range, false);
aSelection->mRanges.RemoveElementAt(i);
}
@ -814,6 +816,16 @@ nsFrameSelection::Init(nsIPresShell *aShell, nsIContent *aLimiter)
mLimiter = aLimiter;
mCaretMovementStyle =
Preferences::GetInt("bidi.edit.caret_movement_style", 2);
// This should only ever be initialized on the main thread, so we are OK here.
static bool prefCachesInitialized = false;
if (!prefCachesInitialized) {
prefCachesInitialized = true;
Preferences::AddBoolVarCache(&sSelectionEventsEnabled,
"dom.select_events.enabled", false);
}
// Set touch caret as selection listener
nsRefPtr<TouchCaret> touchCaret = mShell->GetTouchCaret();
if (touchCaret) {
@ -839,8 +851,21 @@ nsFrameSelection::Init(nsIPresShell *aShell, nsIContent *aLimiter)
mDomSelections[index]->AddSelectionListener(eventHub);
}
}
if (sSelectionEventsEnabled) {
int8_t index =
GetIndexFromSelectionType(nsISelectionController::SELECTION_NORMAL);
if (mDomSelections[index]) {
// The Selection instance will hold a strong reference to its selectionchangelistener
// so we don't have to worry about that!
nsRefPtr<SelectionChangeListener> listener = new SelectionChangeListener;
mDomSelections[index]->AddSelectionListener(listener);
}
}
}
bool nsFrameSelection::sSelectionEventsEnabled = false;
nsresult
nsFrameSelection::MoveCaret(nsDirection aDirection,
bool aContinueSelection,
@ -3307,6 +3332,7 @@ Selection::Selection()
, mDirection(eDirNext)
, mType(nsISelectionController::SELECTION_NORMAL)
, mApplyUserSelectStyle(false)
, mSelectionChangeBlockerCount(0)
{
}
@ -3316,6 +3342,7 @@ Selection::Selection(nsFrameSelection* aList)
, mDirection(eDirNext)
, mType(nsISelectionController::SELECTION_NORMAL)
, mApplyUserSelectStyle(false)
, mSelectionChangeBlockerCount(0)
{
}
@ -3325,7 +3352,7 @@ Selection::~Selection()
uint32_t count = mRanges.Length();
for (uint32_t i = 0; i < count; ++i) {
mRanges[i].mRange->SetInSelection(false);
mRanges[i].mRange->SetSelection(nullptr);
}
if (mAutoScrollTimer) {
@ -3647,8 +3674,24 @@ Selection::SubtractRange(RangeData* aRange, nsRange* aSubtract,
return NS_OK;
}
void
Selection::UserSelectRangesToAdd(nsRange* aItem, nsTArray<nsRefPtr<nsRange>>& aRangesToAdd)
{
aItem->ExcludeNonSelectableNodes(&aRangesToAdd);
if (aRangesToAdd.IsEmpty()) {
ErrorResult err;
nsINode* node = aItem->GetStartContainer(err);
if (node && node->IsContent() && node->AsContent()->GetEditingHost()) {
// A contenteditable node with user-select:none, for example.
// Allow it to have a collapsed selection (for the caret).
aItem->Collapse(GetDirection() == eDirPrevious);
aRangesToAdd.AppendElement(aItem);
}
}
}
nsresult
Selection::AddItem(nsRange* aItem, int32_t* aOutIndex)
Selection::AddItem(nsRange* aItem, int32_t* aOutIndex, bool aNoStartSelect)
{
if (!aItem)
return NS_ERROR_NULL_POINTER;
@ -3657,20 +3700,54 @@ Selection::AddItem(nsRange* aItem, int32_t* aOutIndex)
NS_ASSERTION(aOutIndex, "aOutIndex can't be null");
// XXX Rename mApplyUserSelectStyle? Not the best name (as it is also being
// used to detect here whether the event is user initiated for the purposes of
// dispatching the selectstart event).
if (mApplyUserSelectStyle) {
nsAutoTArray<nsRefPtr<nsRange>, 4> rangesToAdd;
aItem->ExcludeNonSelectableNodes(&rangesToAdd);
if (rangesToAdd.IsEmpty()) {
ErrorResult err;
nsINode* node = aItem->GetStartContainer(err);
if (node && node->IsContent() && node->AsContent()->GetEditingHost()) {
// A contenteditable node with user-select:none, for example.
// Allow it to have a collapsed selection (for the caret).
aItem->Collapse(GetDirection() == eDirPrevious);
rangesToAdd.AppendElement(aItem);
}
}
*aOutIndex = -1;
if (!aNoStartSelect && mType == nsISelectionController::SELECTION_NORMAL &&
nsFrameSelection::sSelectionEventsEnabled && Collapsed() &&
!IsBlockingSelectionChangeEvents()) {
// First, we generate the ranges to add with a scratch range, which is a
// clone of the original range passed in. We do this seperately, because the
// selectstart event could have caused the world to change, and required
// ranges to be re-generated
nsRefPtr<nsRange> scratchRange = aItem->CloneRange();
UserSelectRangesToAdd(scratchRange, rangesToAdd);
bool newRangesNonEmpty = rangesToAdd.Length() > 1 ||
(rangesToAdd.Length() == 1 && !rangesToAdd[0]->Collapsed());
MOZ_ASSERT(!newRangesNonEmpty || nsContentUtils::IsSafeToRunScript());
if (newRangesNonEmpty && nsContentUtils::IsSafeToRunScript()) {
// We consider a selection to be starting if we are currently collapsed,
// and the selection is becoming uncollapsed, and this is caused by a user
// initiated event.
bool defaultAction = true;
nsContentUtils::DispatchTrustedEvent(GetParentObject(),
aItem->GetStartParent(),
NS_LITERAL_STRING("selectstart"),
true, true, &defaultAction);
if (!defaultAction) {
return NS_OK;
}
// As we just dispatched an event to the DOM, something could have
// changed under our feet. Re-generate the rangesToAdd array, and ensure
// that the range we are about to add is still valid.
if (!aItem->IsPositioned()) {
return NS_ERROR_UNEXPECTED;
}
}
// The scratch ranges we generated may be invalid now, throw them out
rangesToAdd.ClearAndRetainStorage();
}
// Generate the ranges to add
UserSelectRangesToAdd(aItem, rangesToAdd);
size_t newAnchorFocusIndex =
GetDirection() == eDirPrevious ? 0 : rangesToAdd.Length() - 1;
for (size_t i = 0; i < rangesToAdd.Length(); ++i) {
@ -3702,7 +3779,7 @@ Selection::AddItemInternal(nsRange* aItem, int32_t* aOutIndex)
if (mRanges.Length() == 0) {
if (!mRanges.AppendElement(RangeData(aItem)))
return NS_ERROR_OUT_OF_MEMORY;
aItem->SetInSelection(true);
aItem->SetSelection(this);
*aOutIndex = 0;
return NS_OK;
@ -3742,7 +3819,7 @@ Selection::AddItemInternal(nsRange* aItem, int32_t* aOutIndex)
// The new range doesn't overlap any existing ranges
if (!mRanges.InsertElementAt(startIndex, RangeData(aItem)))
return NS_ERROR_OUT_OF_MEMORY;
aItem->SetInSelection(true);
aItem->SetSelection(this);
*aOutIndex = startIndex;
return NS_OK;
}
@ -3764,7 +3841,7 @@ Selection::AddItemInternal(nsRange* aItem, int32_t* aOutIndex)
// Remove all the overlapping ranges
for (int32_t i = startIndex; i < endIndex; ++i) {
mRanges[i].mRange->SetInSelection(false);
mRanges[i].mRange->SetSelection(nullptr);
}
mRanges.RemoveElementsAt(startIndex, endIndex - startIndex);
@ -3789,7 +3866,7 @@ Selection::AddItemInternal(nsRange* aItem, int32_t* aOutIndex)
return NS_ERROR_OUT_OF_MEMORY;
for (uint32_t i = 0; i < temp.Length(); ++i) {
temp[i].mRange->SetInSelection(true);
temp[i].mRange->SetSelection(this);
}
*aOutIndex = startIndex + insertionPoint;
@ -3818,7 +3895,7 @@ Selection::RemoveItem(nsRange* aItem)
return NS_ERROR_INVALID_ARG;
mRanges.RemoveElementAt(idx);
aItem->SetInSelection(false);
aItem->SetSelection(nullptr);
return NS_OK;
}
@ -3843,7 +3920,7 @@ Selection::Clear(nsPresContext* aPresContext)
setAnchorFocusRange(-1);
for (uint32_t i = 0; i < mRanges.Length(); ++i) {
mRanges[i].mRange->SetInSelection(false);
mRanges[i].mRange->SetSelection(nullptr);
selectFrames(aPresContext, mRanges[i].mRange, false);
}
mRanges.Clear();
@ -5064,12 +5141,14 @@ Selection::SetAnchorFocusToRange(nsRange* aRange)
{
NS_ENSURE_STATE(mAnchorFocusRange);
bool collapsed = Collapsed();
nsresult res = RemoveItem(mAnchorFocusRange);
if (NS_FAILED(res))
return res;
int32_t aOutIndex = -1;
res = AddItem(aRange, &aOutIndex);
res = AddItem(aRange, &aOutIndex, !collapsed);
if (NS_FAILED(res))
return res;
setAnchorFocusRange(aOutIndex);
@ -5471,19 +5550,16 @@ Selection::SelectAllChildren(nsIDOMNode* aParentNode)
void
Selection::SelectAllChildren(nsINode& aNode, ErrorResult& aRv)
{
if (mFrameSelection)
{
if (mFrameSelection) {
mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
}
SelectionBatcher batch(this);
Collapse(aNode, 0, aRv);
if (aRv.Failed()) {
return;
}
if (mFrameSelection)
{
mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
}
Extend(aNode, aNode.GetChildCount(), aRv);
}
@ -5926,7 +6002,26 @@ Selection::EndBatchChanges()
return NS_OK;
}
void
Selection::AddSelectionChangeBlocker()
{
mSelectionChangeBlockerCount++;
}
void
Selection::RemoveSelectionChangeBlocker()
{
MOZ_ASSERT(mSelectionChangeBlockerCount > 0,
"mSelectionChangeBlockerCount has an invalid value - "
"maybe you have a mismatched RemoveSelectionChangeBlocker?");
mSelectionChangeBlockerCount--;
}
bool
Selection::IsBlockingSelectionChangeEvents() const
{
return mSelectionChangeBlockerCount > 0;
}
NS_IMETHODIMP
Selection::DeleteFromDocument()
@ -6159,6 +6254,11 @@ Selection::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
return mozilla::dom::SelectionBinding::Wrap(aCx, this, aGivenProto);
}
// AutoHideSelectionChanges
AutoHideSelectionChanges::AutoHideSelectionChanges(const nsFrameSelection* aFrame)
: AutoHideSelectionChanges(aFrame->GetSelection(nsISelectionController::SELECTION_NORMAL))
{}
// nsAutoCopyListener
nsAutoCopyListener* nsAutoCopyListener::sInstance = nullptr;
@ -6218,3 +6318,103 @@ nsAutoCopyListener::NotifySelectionChanged(nsIDOMDocument *aDoc,
return nsCopySupport::HTMLCopy(aSel, doc,
nsIClipboard::kSelectionClipboard, false);
}
// SelectionChangeListener
SelectionChangeListener::RawRangeData::RawRangeData(const nsRange* aRange)
{
mozilla::ErrorResult rv;
mStartParent = aRange->GetStartContainer(rv);
rv.SuppressException();
mEndParent = aRange->GetEndContainer(rv);
rv.SuppressException();
mStartOffset = aRange->GetStartOffset(rv);
rv.SuppressException();
mEndOffset = aRange->GetEndOffset(rv);
rv.SuppressException();
}
bool
SelectionChangeListener::RawRangeData::Equals(const nsRange* aRange)
{
mozilla::ErrorResult rv;
bool eq = mStartParent == aRange->GetStartContainer(rv);
rv.SuppressException();
eq = eq && mEndParent == aRange->GetEndContainer(rv);
rv.SuppressException();
eq = eq && mStartOffset == aRange->GetStartOffset(rv);
rv.SuppressException();
eq = eq && mEndOffset == aRange->GetEndOffset(rv);
rv.SuppressException();
return eq;
}
inline void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
SelectionChangeListener::RawRangeData& aField,
const char* aName,
uint32_t aFlags = 0)
{
ImplCycleCollectionTraverse(aCallback, aField.mStartParent, "mStartParent", aFlags);
ImplCycleCollectionTraverse(aCallback, aField.mEndParent, "mEndParent", aFlags);
}
NS_IMPL_CYCLE_COLLECTION_CLASS(SelectionChangeListener)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SelectionChangeListener)
tmp->mOldRanges.Clear();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SelectionChangeListener)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOldRanges);
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SelectionChangeListener)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_ENTRY(nsISelectionListener)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(SelectionChangeListener)
NS_IMPL_CYCLE_COLLECTING_RELEASE(SelectionChangeListener)
NS_IMETHODIMP
SelectionChangeListener::NotifySelectionChanged(nsIDOMDocument* aDoc,
nsISelection* aSel, int16_t aReason)
{
// This cast is valid as nsISelection is a builtinclass which is only
// implemented by Selection.
nsRefPtr<Selection> sel = static_cast<Selection*>(aSel);
// Check if the ranges have actually changed
if (mOldRanges.Length() == sel->RangeCount()) {
bool changed = false;
for (size_t i = 0; i < mOldRanges.Length(); i++) {
if (!mOldRanges[i].Equals(sel->GetRangeAt(i))) {
changed = true;
break;
}
}
if (!changed) {
return NS_OK;
}
}
// The ranges have actually changed, update the mOldRanges array
mOldRanges.ClearAndRetainStorage();
for (size_t i = 0; i < sel->RangeCount(); i++) {
mOldRanges.AppendElement(RawRangeData(sel->GetRangeAt(i)));
}
// Actually fire off the event
nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
if (doc) {
nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
new AsyncEventDispatcher(doc, NS_LITERAL_STRING("selectionchange"), false);
asyncDispatcher->PostDOMEvent();
}
return NS_OK;
}

7
modules/libpref/init/all.js
View File

@ -134,6 +134,13 @@ pref("dom.permissions.enabled", true);
pref("dom.permissions.enabled", false);
#endif
// Whether or not selection events are enabled
#ifdef NIGHTLY_BUILD
pref("dom.select_events.enabled", true);
#else
pref("dom.select_events.enabled", false);
#endif
// Whether or not Web Workers are enabled.
pref("dom.workers.enabled", true);
// The number of workers per domain allowed to run concurrently.

5
widget/EventMessageList.h
View File

@ -424,3 +424,8 @@ NS_EVENT_MESSAGE(eGamepadEventLast, eGamepadDisconnected)
// input and beforeinput events.
NS_EVENT_MESSAGE(NS_EDITOR_EVENT_START, 6100)
NS_EVENT_MESSAGE(NS_EDITOR_INPUT, NS_EDITOR_EVENT_START)
// selection events
NS_EVENT_MESSAGE(NS_SELECT_EVENT_START, 6200)
NS_EVENT_MESSAGE(NS_SELECT_START, NS_SELECT_EVENT_START)
NS_EVENT_MESSAGE(NS_SELECTION_CHANGE, NS_SELECT_EVENT_START + 1)