diff options
Diffstat (limited to '')
| -rw-r--r-- | layout/base/AccessibleCaretManager.cpp | 1506 |
1 files changed, 1506 insertions, 0 deletions
diff --git a/layout/base/AccessibleCaretManager.cpp b/layout/base/AccessibleCaretManager.cpp new file mode 100644 index 0000000000..17597d287d --- /dev/null +++ b/layout/base/AccessibleCaretManager.cpp @@ -0,0 +1,1506 @@ +/* -*- 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/. */ + +#include "AccessibleCaretManager.h" + +#include <utility> + +#include "AccessibleCaret.h" +#include "AccessibleCaretEventHub.h" +#include "AccessibleCaretLogger.h" +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/CaretAssociationHint.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/MouseEventBinding.h" +#include "mozilla/dom/NodeFilterBinding.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/dom/TreeWalker.h" +#include "mozilla/IMEStateManager.h" +#include "mozilla/IntegerPrintfMacros.h" +#include "mozilla/PresShell.h" +#include "mozilla/SelectionMovementUtils.h" +#include "mozilla/StaticAnalysisFunctions.h" +#include "mozilla/StaticPrefs_layout.h" +#include "nsCaret.h" +#include "nsContainerFrame.h" +#include "nsContentUtils.h" +#include "nsDebug.h" +#include "nsFocusManager.h" +#include "nsIFrame.h" +#include "nsFrameSelection.h" +#include "nsGenericHTMLElement.h" +#include "nsIHapticFeedback.h" +#include "nsIScrollableFrame.h" +#include "nsLayoutUtils.h" +#include "nsServiceManagerUtils.h" + +namespace mozilla { + +#undef AC_LOG +#define AC_LOG(message, ...) \ + AC_LOG_BASE("AccessibleCaretManager (%p): " message, this, ##__VA_ARGS__); + +#undef AC_LOGV +#define AC_LOGV(message, ...) \ + AC_LOGV_BASE("AccessibleCaretManager (%p): " message, this, ##__VA_ARGS__); + +using namespace dom; +using Appearance = AccessibleCaret::Appearance; +using PositionChangedResult = AccessibleCaret::PositionChangedResult; + +#define AC_PROCESS_ENUM_TO_STREAM(e) \ + case (e): \ + aStream << #e; \ + break; +std::ostream& operator<<(std::ostream& aStream, + const AccessibleCaretManager::CaretMode& aCaretMode) { + using CaretMode = AccessibleCaretManager::CaretMode; + switch (aCaretMode) { + AC_PROCESS_ENUM_TO_STREAM(CaretMode::None); + AC_PROCESS_ENUM_TO_STREAM(CaretMode::Cursor); + AC_PROCESS_ENUM_TO_STREAM(CaretMode::Selection); + } + return aStream; +} + +std::ostream& operator<<( + std::ostream& aStream, + const AccessibleCaretManager::UpdateCaretsHint& aHint) { + using UpdateCaretsHint = AccessibleCaretManager::UpdateCaretsHint; + switch (aHint) { + AC_PROCESS_ENUM_TO_STREAM(UpdateCaretsHint::Default); + AC_PROCESS_ENUM_TO_STREAM(UpdateCaretsHint::RespectOldAppearance); + AC_PROCESS_ENUM_TO_STREAM(UpdateCaretsHint::DispatchNoEvent); + } + return aStream; +} +#undef AC_PROCESS_ENUM_TO_STREAM + +AccessibleCaretManager::AccessibleCaretManager(PresShell* aPresShell) + : AccessibleCaretManager{ + aPresShell, + Carets{aPresShell ? MakeUnique<AccessibleCaret>(aPresShell) : nullptr, + aPresShell ? MakeUnique<AccessibleCaret>(aPresShell) + : nullptr}} {} + +AccessibleCaretManager::AccessibleCaretManager(PresShell* aPresShell, + Carets aCarets) + : mPresShell{aPresShell}, mCarets{std::move(aCarets)} {} + +AccessibleCaretManager::LayoutFlusher::~LayoutFlusher() { + MOZ_RELEASE_ASSERT(!mFlushing, "Going away in MaybeFlush? Bad!"); +} + +void AccessibleCaretManager::Terminate() { + mCarets.Terminate(); + mActiveCaret = nullptr; + mPresShell = nullptr; +} + +nsresult AccessibleCaretManager::OnSelectionChanged(Document* aDoc, + Selection* aSel, + int16_t aReason) { + Selection* selection = GetSelection(); + AC_LOG("%s: aSel: %p, GetSelection(): %p, aReason: %d", __FUNCTION__, aSel, + selection, aReason); + if (aSel != selection) { + return NS_OK; + } + + // eSetSelection events from the Fennec widget IME can be generated + // by autoSuggest / autoCorrect composition changes, or by TYPE_REPLACE_TEXT + // actions, either positioning cursor for text insert, or selecting + // text-to-be-replaced. None should affect AccessibleCaret visibility. + if (aReason & nsISelectionListener::IME_REASON) { + return NS_OK; + } + + // Move the cursor by JavaScript or unknown internal call. + if (aReason == nsISelectionListener::NO_REASON || + aReason == nsISelectionListener::JS_REASON) { + auto mode = static_cast<ScriptUpdateMode>( + StaticPrefs::layout_accessiblecaret_script_change_update_mode()); + if (mode == kScriptAlwaysShow || + (mode == kScriptUpdateVisible && mCarets.HasLogicallyVisibleCaret())) { + UpdateCarets(); + return NS_OK; + } + // Default for NO_REASON is to make hidden. + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + // Move cursor by keyboard. + if (aReason & nsISelectionListener::KEYPRESS_REASON) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + // OnBlur() might be called between mouse down and mouse up, so we hide carets + // upon mouse down anyway, and update carets upon mouse up. + if (aReason & nsISelectionListener::MOUSEDOWN_REASON) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + // Range will collapse after cutting or copying text. + if (aReason & (nsISelectionListener::COLLAPSETOSTART_REASON | + nsISelectionListener::COLLAPSETOEND_REASON)) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + // For mouse input we don't want to show the carets. + if (StaticPrefs::layout_accessiblecaret_hide_carets_for_mouse_input() && + mLastInputSource == MouseEvent_Binding::MOZ_SOURCE_MOUSE) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + // When we want to hide the carets for mouse input, hide them for select + // all action fired by keyboard as well. + if (StaticPrefs::layout_accessiblecaret_hide_carets_for_mouse_input() && + mLastInputSource == MouseEvent_Binding::MOZ_SOURCE_KEYBOARD && + (aReason & nsISelectionListener::SELECTALL_REASON)) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return NS_OK; + } + + UpdateCarets(); + return NS_OK; +} + +void AccessibleCaretManager::HideCaretsAndDispatchCaretStateChangedEvent() { + if (mCarets.HasLogicallyVisibleCaret()) { + AC_LOG("%s", __FUNCTION__); + mCarets.GetFirst()->SetAppearance(Appearance::None); + mCarets.GetSecond()->SetAppearance(Appearance::None); + mIsCaretPositionChanged = false; + DispatchCaretStateChangedEvent(CaretChangedReason::Visibilitychange); + } +} + +auto AccessibleCaretManager::MaybeFlushLayout() -> Terminated { + if (mPresShell) { + // `MaybeFlush` doesn't access the PresShell after flushing, so it's OK to + // mark it as live. + mLayoutFlusher.MaybeFlush(MOZ_KnownLive(*mPresShell)); + } + + return IsTerminated(); +} + +void AccessibleCaretManager::UpdateCarets(const UpdateCaretsHintSet& aHint) { + if (MaybeFlushLayout() == Terminated::Yes) { + return; + } + + mLastUpdateCaretMode = GetCaretMode(); + + switch (mLastUpdateCaretMode) { + case CaretMode::None: + HideCaretsAndDispatchCaretStateChangedEvent(); + break; + case CaretMode::Cursor: + UpdateCaretsForCursorMode(aHint); + break; + case CaretMode::Selection: + UpdateCaretsForSelectionMode(aHint); + break; + } + + mDesiredAsyncPanZoomState.Update(*this); +} + +bool AccessibleCaretManager::IsCaretDisplayableInCursorMode( + nsIFrame** aOutFrame, int32_t* aOutOffset) const { + RefPtr<nsCaret> caret = mPresShell->GetCaret(); + if (!caret || !caret->IsVisible()) { + return false; + } + + int32_t offset = 0; + nsIFrame* frame = + nsCaret::GetFrameAndOffset(GetSelection(), nullptr, 0, &offset); + + if (!frame) { + return false; + } + + if (!GetEditingHostForFrame(frame)) { + return false; + } + + if (aOutFrame) { + *aOutFrame = frame; + } + + if (aOutOffset) { + *aOutOffset = offset; + } + + return true; +} + +bool AccessibleCaretManager::HasNonEmptyTextContent(nsINode* aNode) const { + return nsContentUtils::HasNonEmptyTextContent( + aNode, nsContentUtils::eRecurseIntoChildren); +} + +void AccessibleCaretManager::UpdateCaretsForCursorMode( + const UpdateCaretsHintSet& aHints) { + AC_LOG("%s, selection: %p", __FUNCTION__, GetSelection()); + + int32_t offset = 0; + nsIFrame* frame = nullptr; + if (!IsCaretDisplayableInCursorMode(&frame, &offset)) { + HideCaretsAndDispatchCaretStateChangedEvent(); + return; + } + + PositionChangedResult result = mCarets.GetFirst()->SetPosition(frame, offset); + + switch (result) { + case PositionChangedResult::NotChanged: + case PositionChangedResult::Position: + case PositionChangedResult::Zoom: + if (!aHints.contains(UpdateCaretsHint::RespectOldAppearance)) { + if (HasNonEmptyTextContent(GetEditingHostForFrame(frame))) { + mCarets.GetFirst()->SetAppearance(Appearance::Normal); + } else if ( + StaticPrefs:: + layout_accessiblecaret_caret_shown_when_long_tapping_on_empty_content()) { + if (mCarets.GetFirst()->IsLogicallyVisible()) { + // Possible cases are: 1) SelectWordOrShortcut() sets the + // appearance to Normal. 2) When the caret is out of viewport and + // now scrolling into viewport, it has appearance NormalNotShown. + mCarets.GetFirst()->SetAppearance(Appearance::Normal); + } else { + // Possible cases are: a) Single tap on current empty content; + // OnSelectionChanged() sets the appearance to None due to + // MOUSEDOWN_REASON. b) Single tap on other empty content; + // OnBlur() sets the appearance to None. + // + // Do nothing to make the appearance remains None so that it can + // be distinguished from case 2). Also do not set the appearance + // to NormalNotShown here like the default update behavior. + } + } else { + mCarets.GetFirst()->SetAppearance(Appearance::NormalNotShown); + } + } + break; + + case PositionChangedResult::Invisible: + mCarets.GetFirst()->SetAppearance(Appearance::NormalNotShown); + break; + } + + mCarets.GetSecond()->SetAppearance(Appearance::None); + + mIsCaretPositionChanged = (result == PositionChangedResult::Position); + + if (!aHints.contains(UpdateCaretsHint::DispatchNoEvent) && !mActiveCaret) { + DispatchCaretStateChangedEvent(CaretChangedReason::Updateposition); + } +} + +void AccessibleCaretManager::UpdateCaretsForSelectionMode( + const UpdateCaretsHintSet& aHints) { + AC_LOG("%s: selection: %p", __FUNCTION__, GetSelection()); + + int32_t startOffset = 0; + nsIFrame* startFrame = + GetFrameForFirstRangeStartOrLastRangeEnd(eDirNext, &startOffset); + + int32_t endOffset = 0; + nsIFrame* endFrame = + GetFrameForFirstRangeStartOrLastRangeEnd(eDirPrevious, &endOffset); + + if (!CompareTreePosition(startFrame, endFrame)) { + // XXX: Do we really have to hide carets if this condition isn't satisfied? + HideCaretsAndDispatchCaretStateChangedEvent(); + return; + } + + auto updateSingleCaret = [aHints](AccessibleCaret* aCaret, nsIFrame* aFrame, + int32_t aOffset) -> PositionChangedResult { + PositionChangedResult result = aCaret->SetPosition(aFrame, aOffset); + + switch (result) { + case PositionChangedResult::NotChanged: + case PositionChangedResult::Position: + case PositionChangedResult::Zoom: + if (!aHints.contains(UpdateCaretsHint::RespectOldAppearance)) { + aCaret->SetAppearance(Appearance::Normal); + } + break; + + case PositionChangedResult::Invisible: + aCaret->SetAppearance(Appearance::NormalNotShown); + break; + } + return result; + }; + + PositionChangedResult firstCaretResult = + updateSingleCaret(mCarets.GetFirst(), startFrame, startOffset); + PositionChangedResult secondCaretResult = + updateSingleCaret(mCarets.GetSecond(), endFrame, endOffset); + + mIsCaretPositionChanged = + firstCaretResult == PositionChangedResult::Position || + secondCaretResult == PositionChangedResult::Position; + + if (mIsCaretPositionChanged) { + // Flush layout to make the carets intersection correct. + if (MaybeFlushLayout() == Terminated::Yes) { + return; + } + } + + if (!aHints.contains(UpdateCaretsHint::RespectOldAppearance)) { + // Only check for tilt carets when the caller doesn't ask us to preserve + // old appearance. Otherwise we might override the appearance set by the + // caller. + if (StaticPrefs::layout_accessiblecaret_always_tilt()) { + UpdateCaretsForAlwaysTilt(startFrame, endFrame); + } else { + UpdateCaretsForOverlappingTilt(); + } + } + + if (!aHints.contains(UpdateCaretsHint::DispatchNoEvent) && !mActiveCaret) { + DispatchCaretStateChangedEvent(CaretChangedReason::Updateposition); + } +} + +void AccessibleCaretManager::DesiredAsyncPanZoomState::Update( + const AccessibleCaretManager& aAccessibleCaretManager) { + if (aAccessibleCaretManager.mActiveCaret) { + // No need to disable APZ when dragging the caret. + mValue = Value::Enabled; + return; + } + + if (aAccessibleCaretManager.mIsScrollStarted) { + // During scrolling, the caret's position is changed only if it is in a + // position:fixed or a "stuck" position:sticky frame subtree. + mValue = aAccessibleCaretManager.mIsCaretPositionChanged ? Value::Disabled + : Value::Enabled; + return; + } + + // For other cases, we can only reliably detect whether the caret is in a + // position:fixed frame subtree. + switch (aAccessibleCaretManager.mLastUpdateCaretMode) { + case CaretMode::None: + mValue = Value::Enabled; + break; + case CaretMode::Cursor: + mValue = + (aAccessibleCaretManager.mCarets.GetFirst()->IsVisuallyVisible() && + aAccessibleCaretManager.mCarets.GetFirst() + ->IsInPositionFixedSubtree()) + ? Value::Disabled + : Value::Enabled; + break; + case CaretMode::Selection: + mValue = + ((aAccessibleCaretManager.mCarets.GetFirst()->IsVisuallyVisible() && + aAccessibleCaretManager.mCarets.GetFirst() + ->IsInPositionFixedSubtree()) || + (aAccessibleCaretManager.mCarets.GetSecond()->IsVisuallyVisible() && + aAccessibleCaretManager.mCarets.GetSecond() + ->IsInPositionFixedSubtree())) + ? Value::Disabled + : Value::Enabled; + break; + } +} + +bool AccessibleCaretManager::UpdateCaretsForOverlappingTilt() { + if (!mCarets.GetFirst()->IsVisuallyVisible() || + !mCarets.GetSecond()->IsVisuallyVisible()) { + return false; + } + + if (!mCarets.GetFirst()->Intersects(*mCarets.GetSecond())) { + mCarets.GetFirst()->SetAppearance(Appearance::Normal); + mCarets.GetSecond()->SetAppearance(Appearance::Normal); + return false; + } + + if (mCarets.GetFirst()->LogicalPosition().x <= + mCarets.GetSecond()->LogicalPosition().x) { + mCarets.GetFirst()->SetAppearance(Appearance::Left); + mCarets.GetSecond()->SetAppearance(Appearance::Right); + } else { + mCarets.GetFirst()->SetAppearance(Appearance::Right); + mCarets.GetSecond()->SetAppearance(Appearance::Left); + } + + return true; +} + +void AccessibleCaretManager::UpdateCaretsForAlwaysTilt( + const nsIFrame* aStartFrame, const nsIFrame* aEndFrame) { + // When a short LTR word in RTL environment is selected, the two carets + // tilted inward might be overlapped. Make them tilt outward. + if (UpdateCaretsForOverlappingTilt()) { + return; + } + + if (mCarets.GetFirst()->IsVisuallyVisible()) { + auto startFrameWritingMode = aStartFrame->GetWritingMode(); + mCarets.GetFirst()->SetAppearance(startFrameWritingMode.IsBidiLTR() + ? Appearance::Left + : Appearance::Right); + } + if (mCarets.GetSecond()->IsVisuallyVisible()) { + auto endFrameWritingMode = aEndFrame->GetWritingMode(); + mCarets.GetSecond()->SetAppearance( + endFrameWritingMode.IsBidiLTR() ? Appearance::Right : Appearance::Left); + } +} + +void AccessibleCaretManager::ProvideHapticFeedback() { + if (StaticPrefs::layout_accessiblecaret_hapticfeedback()) { + if (nsCOMPtr<nsIHapticFeedback> haptic = + do_GetService("@mozilla.org/widget/hapticfeedback;1")) { + haptic->PerformSimpleAction(haptic->LongPress); + } + } +} + +nsresult AccessibleCaretManager::PressCaret(const nsPoint& aPoint, + EventClassID aEventClass) { + nsresult rv = NS_ERROR_FAILURE; + + MOZ_ASSERT(aEventClass == eMouseEventClass || aEventClass == eTouchEventClass, + "Unexpected event class!"); + + using TouchArea = AccessibleCaret::TouchArea; + TouchArea touchArea = + aEventClass == eMouseEventClass ? TouchArea::CaretImage : TouchArea::Full; + + if (mCarets.GetFirst()->Contains(aPoint, touchArea)) { + mActiveCaret = mCarets.GetFirst(); + SetSelectionDirection(eDirPrevious); + } else if (mCarets.GetSecond()->Contains(aPoint, touchArea)) { + mActiveCaret = mCarets.GetSecond(); + SetSelectionDirection(eDirNext); + } + + if (mActiveCaret) { + mOffsetYToCaretLogicalPosition = + mActiveCaret->LogicalPosition().y - aPoint.y; + SetSelectionDragState(true); + DispatchCaretStateChangedEvent(CaretChangedReason::Presscaret, &aPoint); + rv = NS_OK; + } + + return rv; +} + +nsresult AccessibleCaretManager::DragCaret(const nsPoint& aPoint) { + MOZ_ASSERT(mActiveCaret); + MOZ_ASSERT(GetCaretMode() != CaretMode::None); + + if (!mPresShell || !mPresShell->GetRootFrame() || !GetSelection()) { + return NS_ERROR_NULL_POINTER; + } + + StopSelectionAutoScrollTimer(); + DragCaretInternal(aPoint); + + // We want to scroll the page even if we failed to drag the caret. + StartSelectionAutoScrollTimer(aPoint); + UpdateCarets(); + + if (StaticPrefs::layout_accessiblecaret_magnifier_enabled()) { + DispatchCaretStateChangedEvent(CaretChangedReason::Dragcaret, &aPoint); + } + return NS_OK; +} + +nsresult AccessibleCaretManager::ReleaseCaret() { + MOZ_ASSERT(mActiveCaret); + + mActiveCaret = nullptr; + SetSelectionDragState(false); + mDesiredAsyncPanZoomState.Update(*this); + DispatchCaretStateChangedEvent(CaretChangedReason::Releasecaret); + return NS_OK; +} + +nsresult AccessibleCaretManager::TapCaret(const nsPoint& aPoint) { + MOZ_ASSERT(GetCaretMode() != CaretMode::None); + + nsresult rv = NS_ERROR_FAILURE; + + if (GetCaretMode() == CaretMode::Cursor) { + DispatchCaretStateChangedEvent(CaretChangedReason::Taponcaret, &aPoint); + rv = NS_OK; + } + + return rv; +} + +static EnumSet<nsLayoutUtils::FrameForPointOption> GetHitTestOptions() { + EnumSet<nsLayoutUtils::FrameForPointOption> options = { + nsLayoutUtils::FrameForPointOption::IgnorePaintSuppression, + nsLayoutUtils::FrameForPointOption::IgnoreCrossDoc}; + return options; +} + +nsresult AccessibleCaretManager::SelectWordOrShortcut(const nsPoint& aPoint) { + // If the long-tap is landing on a pre-existing selection, don't replace + // it with a new one. Instead just return and let the context menu pop up + // on the pre-existing selection. + if (GetCaretMode() == CaretMode::Selection && + GetSelection()->ContainsPoint(aPoint)) { + AC_LOG("%s: UpdateCarets() for current selection", __FUNCTION__); + UpdateCarets(); + ProvideHapticFeedback(); + return NS_OK; + } + + if (!mPresShell) { + return NS_ERROR_UNEXPECTED; + } + + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + if (!rootFrame) { + return NS_ERROR_NOT_AVAILABLE; + } + + // Find the frame under point. + AutoWeakFrame ptFrame = nsLayoutUtils::GetFrameForPoint( + RelativeTo{rootFrame}, aPoint, GetHitTestOptions()); + if (!ptFrame.GetFrame()) { + return NS_ERROR_FAILURE; + } + + nsIFrame* focusableFrame = GetFocusableFrame(ptFrame); + +#ifdef DEBUG_FRAME_DUMP + AC_LOG("%s: Found %s under (%d, %d)", __FUNCTION__, ptFrame->ListTag().get(), + aPoint.x, aPoint.y); + AC_LOG("%s: Found %s focusable", __FUNCTION__, + focusableFrame ? focusableFrame->ListTag().get() : "no frame"); +#endif + + // Get ptInFrame here so that we don't need to check whether rootFrame is + // alive later. Note that if ptFrame is being moved by + // IMEStateManager::NotifyIME() or ChangeFocusToOrClearOldFocus() below, + // something under the original point will be selected, which may not be the + // original text the user wants to select. + nsPoint ptInFrame = aPoint; + nsLayoutUtils::TransformPoint(RelativeTo{rootFrame}, RelativeTo{ptFrame}, + ptInFrame); + + // Firstly check long press on an empty editable content. + Element* newFocusEditingHost = GetEditingHostForFrame(ptFrame); + if (focusableFrame && newFocusEditingHost && + !HasNonEmptyTextContent(newFocusEditingHost)) { + ChangeFocusToOrClearOldFocus(focusableFrame); + + if (StaticPrefs:: + layout_accessiblecaret_caret_shown_when_long_tapping_on_empty_content()) { + mCarets.GetFirst()->SetAppearance(Appearance::Normal); + } + // We need to update carets to get correct information before dispatching + // CaretStateChangedEvent. + UpdateCarets(); + ProvideHapticFeedback(); + DispatchCaretStateChangedEvent(CaretChangedReason::Longpressonemptycontent); + return NS_OK; + } + + bool selectable = ptFrame->IsSelectable(nullptr); + +#ifdef DEBUG_FRAME_DUMP + AC_LOG("%s: %s %s selectable.", __FUNCTION__, ptFrame->ListTag().get(), + selectable ? "is" : "is NOT"); +#endif + + if (!selectable) { + return NS_ERROR_FAILURE; + } + + // Commit the composition string of the old editable focus element (if there + // is any) before changing the focus. + IMEStateManager::NotifyIME(widget::REQUEST_TO_COMMIT_COMPOSITION, + mPresShell->GetPresContext()); + if (!ptFrame.IsAlive()) { + // Cannot continue because ptFrame died. + return NS_ERROR_FAILURE; + } + + // ptFrame is selectable. Now change the focus. + ChangeFocusToOrClearOldFocus(focusableFrame); + if (!ptFrame.IsAlive()) { + // Cannot continue because ptFrame died. + return NS_ERROR_FAILURE; + } + + // If long tap point isn't selectable frame for caret and frame selection + // can find a better frame for caret, we don't select a word. + // See https://webcompat.com/issues/15953 + nsIFrame::ContentOffsets offsets = ptFrame->GetContentOffsetsFromPoint( + ptInFrame, + nsIFrame::SKIP_HIDDEN | nsIFrame::IGNORE_NATIVE_ANONYMOUS_SUBTREE); + if (offsets.content) { + RefPtr<nsFrameSelection> frameSelection = GetFrameSelection(); + if (frameSelection) { + nsIFrame* theFrame = SelectionMovementUtils::GetFrameForNodeOffset( + offsets.content, offsets.offset, offsets.associate); + if (theFrame && theFrame != ptFrame) { + SetSelectionDragState(true); + frameSelection->HandleClick( + MOZ_KnownLive(offsets.content) /* bug 1636889 */, + offsets.StartOffset(), offsets.EndOffset(), + nsFrameSelection::FocusMode::kCollapseToNewPoint, + offsets.associate); + SetSelectionDragState(false); + ClearMaintainedSelection(); + + if (StaticPrefs:: + layout_accessiblecaret_caret_shown_when_long_tapping_on_empty_content()) { + mCarets.GetFirst()->SetAppearance(Appearance::Normal); + } + + UpdateCarets(); + ProvideHapticFeedback(); + DispatchCaretStateChangedEvent( + CaretChangedReason::Longpressonemptycontent); + + return NS_OK; + } + } + } + + // Then try select a word under point. + nsresult rv = SelectWord(ptFrame, ptInFrame); + UpdateCarets(); + ProvideHapticFeedback(); + + return rv; +} + +void AccessibleCaretManager::OnScrollStart() { + AC_LOG("%s", __FUNCTION__); + + nsAutoScriptBlocker scriptBlocker; + AutoRestore<bool> saveAllowFlushingLayout(mLayoutFlusher.mAllowFlushing); + mLayoutFlusher.mAllowFlushing = false; + + Maybe<PresShell::AutoAssertNoFlush> assert; + if (mPresShell) { + assert.emplace(*mPresShell); + } + + mIsScrollStarted = true; + + if (mCarets.HasLogicallyVisibleCaret()) { + // Dispatch the event only if one of the carets is logically visible like in + // HideCaretsAndDispatchCaretStateChangedEvent(). + DispatchCaretStateChangedEvent(CaretChangedReason::Scroll); + } +} + +void AccessibleCaretManager::OnScrollEnd() { + nsAutoScriptBlocker scriptBlocker; + AutoRestore<bool> saveAllowFlushingLayout(mLayoutFlusher.mAllowFlushing); + mLayoutFlusher.mAllowFlushing = false; + + Maybe<PresShell::AutoAssertNoFlush> assert; + if (mPresShell) { + assert.emplace(*mPresShell); + } + + mIsScrollStarted = false; + + if (GetCaretMode() == CaretMode::Cursor) { + if (!mCarets.GetFirst()->IsLogicallyVisible()) { + // If the caret is hidden (Appearance::None) due to blur, no + // need to update it. + return; + } + } + + // For mouse and keyboard input, we don't want to show the carets. + if (StaticPrefs::layout_accessiblecaret_hide_carets_for_mouse_input() && + (mLastInputSource == MouseEvent_Binding::MOZ_SOURCE_MOUSE || + mLastInputSource == MouseEvent_Binding::MOZ_SOURCE_KEYBOARD)) { + AC_LOG("%s: HideCaretsAndDispatchCaretStateChangedEvent()", __FUNCTION__); + HideCaretsAndDispatchCaretStateChangedEvent(); + return; + } + + AC_LOG("%s: UpdateCarets()", __FUNCTION__); + UpdateCarets(); +} + +void AccessibleCaretManager::OnScrollPositionChanged() { + nsAutoScriptBlocker scriptBlocker; + AutoRestore<bool> saveAllowFlushingLayout(mLayoutFlusher.mAllowFlushing); + mLayoutFlusher.mAllowFlushing = false; + + Maybe<PresShell::AutoAssertNoFlush> assert; + if (mPresShell) { + assert.emplace(*mPresShell); + } + + if (mCarets.HasLogicallyVisibleCaret()) { + if (mIsScrollStarted) { + // We don't want extra CaretStateChangedEvents dispatched when user is + // scrolling the page. + AC_LOG("%s: UpdateCarets(RespectOldAppearance | DispatchNoEvent)", + __FUNCTION__); + UpdateCarets({UpdateCaretsHint::RespectOldAppearance, + UpdateCaretsHint::DispatchNoEvent}); + } else { + AC_LOG("%s: UpdateCarets(RespectOldAppearance)", __FUNCTION__); + UpdateCarets(UpdateCaretsHint::RespectOldAppearance); + } + } +} + +void AccessibleCaretManager::OnReflow() { + nsAutoScriptBlocker scriptBlocker; + AutoRestore<bool> saveAllowFlushingLayout(mLayoutFlusher.mAllowFlushing); + mLayoutFlusher.mAllowFlushing = false; + + Maybe<PresShell::AutoAssertNoFlush> assert; + if (mPresShell) { + assert.emplace(*mPresShell); + } + + if (mCarets.HasLogicallyVisibleCaret()) { + AC_LOG("%s: UpdateCarets(RespectOldAppearance)", __FUNCTION__); + UpdateCarets(UpdateCaretsHint::RespectOldAppearance); + } +} + +void AccessibleCaretManager::OnBlur() { + AC_LOG("%s: HideCaretsAndDispatchCaretStateChangedEvent()", __FUNCTION__); + HideCaretsAndDispatchCaretStateChangedEvent(); +} + +void AccessibleCaretManager::OnKeyboardEvent() { + if (GetCaretMode() == CaretMode::Cursor) { + AC_LOG("%s: HideCaretsAndDispatchCaretStateChangedEvent()", __FUNCTION__); + HideCaretsAndDispatchCaretStateChangedEvent(); + } +} + +void AccessibleCaretManager::SetLastInputSource(uint16_t aInputSource) { + mLastInputSource = aInputSource; +} + +bool AccessibleCaretManager::ShouldDisableApz() const { + return mDesiredAsyncPanZoomState.Get() == + DesiredAsyncPanZoomState::Value::Disabled; +} + +Selection* AccessibleCaretManager::GetSelection() const { + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (!fs) { + return nullptr; + } + return fs->GetSelection(SelectionType::eNormal); +} + +already_AddRefed<nsFrameSelection> AccessibleCaretManager::GetFrameSelection() + const { + if (!mPresShell) { + return nullptr; + } + + // Prevent us from touching the nsFrameSelection associated with other + // PresShell. + RefPtr<nsFrameSelection> fs = mPresShell->GetLastFocusedFrameSelection(); + if (!fs || fs->GetPresShell() != mPresShell) { + return nullptr; + } + + return fs.forget(); +} + +nsAutoString AccessibleCaretManager::StringifiedSelection() const { + nsAutoString str; + RefPtr<Selection> selection = GetSelection(); + if (selection) { + selection->Stringify(str, mLayoutFlusher.mAllowFlushing + ? Selection::FlushFrames::Yes + : Selection::FlushFrames::No); + } + return str; +} + +// static +Element* AccessibleCaretManager::GetEditingHostForFrame( + const nsIFrame* aFrame) { + if (!aFrame) { + return nullptr; + } + + auto content = aFrame->GetContent(); + if (!content) { + return nullptr; + } + + return content->GetEditingHost(); +} + +AccessibleCaretManager::CaretMode AccessibleCaretManager::GetCaretMode() const { + const Selection* selection = GetSelection(); + if (!selection) { + return CaretMode::None; + } + + const uint32_t rangeCount = selection->RangeCount(); + if (rangeCount <= 0) { + return CaretMode::None; + } + + const nsFocusManager* fm = nsFocusManager::GetFocusManager(); + MOZ_ASSERT(fm); + if (fm->GetFocusedWindow() != mPresShell->GetDocument()->GetWindow()) { + // Hide carets if the window is not focused. + return CaretMode::None; + } + + if (selection->IsCollapsed()) { + return CaretMode::Cursor; + } + + return CaretMode::Selection; +} + +nsIFrame* AccessibleCaretManager::GetFocusableFrame(nsIFrame* aFrame) const { + // This implementation is similar to EventStateManager::PostHandleEvent(). + // Look for the nearest enclosing focusable frame. + nsIFrame* focusableFrame = aFrame; + while (focusableFrame) { + if (focusableFrame->IsFocusable(/* aWithMouse = */ true)) { + break; + } + focusableFrame = focusableFrame->GetParent(); + } + return focusableFrame; +} + +void AccessibleCaretManager::ChangeFocusToOrClearOldFocus( + nsIFrame* aFrame) const { + RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager(); + MOZ_ASSERT(fm); + + if (aFrame) { + nsIContent* focusableContent = aFrame->GetContent(); + MOZ_ASSERT(focusableContent, "Focusable frame must have content!"); + RefPtr<Element> focusableElement = Element::FromNode(focusableContent); + fm->SetFocus(focusableElement, nsIFocusManager::FLAG_BYLONGPRESS); + } else if (nsCOMPtr<nsPIDOMWindowOuter> win = + mPresShell->GetDocument()->GetWindow()) { + fm->ClearFocus(win); + fm->SetFocusedWindow(win); + } +} + +nsresult AccessibleCaretManager::SelectWord(nsIFrame* aFrame, + const nsPoint& aPoint) const { + AC_LOGV("%s", __FUNCTION__); + + SetSelectionDragState(true); + const RefPtr<nsPresContext> pinnedPresContext{mPresShell->GetPresContext()}; + nsresult rs = aFrame->SelectByTypeAtPoint(pinnedPresContext, aPoint, + eSelectWord, eSelectWord, 0); + + SetSelectionDragState(false); + ClearMaintainedSelection(); + + // Smart-select phone numbers if possible. + if (StaticPrefs::layout_accessiblecaret_extend_selection_for_phone_number()) { + SelectMoreIfPhoneNumber(); + } + + return rs; +} + +void AccessibleCaretManager::SetSelectionDragState(bool aState) const { + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (fs) { + fs->SetDragState(aState); + } +} + +bool AccessibleCaretManager::IsPhoneNumber(const nsAString& aCandidate) const { + RefPtr<Document> doc = mPresShell->GetDocument(); + nsAutoString phoneNumberRegex(u"(^\\+)?[0-9 ,\\-.\\(\\)*#pw]{1,30}$"_ns); + return nsContentUtils::IsPatternMatching(aCandidate, + std::move(phoneNumberRegex), doc) + .valueOr(false); +} + +void AccessibleCaretManager::SelectMoreIfPhoneNumber() const { + if (IsPhoneNumber(StringifiedSelection())) { + SetSelectionDirection(eDirNext); + ExtendPhoneNumberSelection(u"forward"_ns); + + SetSelectionDirection(eDirPrevious); + ExtendPhoneNumberSelection(u"backward"_ns); + + SetSelectionDirection(eDirNext); + } +} + +void AccessibleCaretManager::ExtendPhoneNumberSelection( + const nsAString& aDirection) const { + if (!mPresShell) { + return; + } + + // Extend the phone number selection until we find a boundary. + RefPtr<Selection> selection = GetSelection(); + + while (selection) { + const nsRange* anchorFocusRange = selection->GetAnchorFocusRange(); + if (!anchorFocusRange) { + return; + } + + // Backup the anchor focus range since both anchor node and focus node might + // be changed after calling Selection::Modify(). + RefPtr<nsRange> oldAnchorFocusRange = anchorFocusRange->CloneRange(); + + // Save current focus node, focus offset and the selected text so that + // we can compare them with the modified ones later. + nsINode* oldFocusNode = selection->GetFocusNode(); + uint32_t oldFocusOffset = selection->FocusOffset(); + nsAutoString oldSelectedText = StringifiedSelection(); + + // Extend the selection by one char. + selection->Modify(u"extend"_ns, aDirection, u"character"_ns, + IgnoreErrors()); + if (IsTerminated() == Terminated::Yes) { + return; + } + + // If the selection didn't change, (can't extend further), we're done. + if (selection->GetFocusNode() == oldFocusNode && + selection->FocusOffset() == oldFocusOffset) { + return; + } + + // If the changed selection isn't a valid phone number, we're done. + // Also, if the selection was extended to a new block node, the string + // returned by stringify() won't have a new line at the beginning or the + // end of the string. Therefore, if either focus node or offset is + // changed, but selected text is not changed, we're done, too. + nsAutoString selectedText = StringifiedSelection(); + + if (!IsPhoneNumber(selectedText) || oldSelectedText == selectedText) { + // Backout the undesired selection extend, restore the old anchor focus + // range before exit. + selection->SetAnchorFocusToRange(oldAnchorFocusRange); + return; + } + } +} + +void AccessibleCaretManager::SetSelectionDirection(nsDirection aDir) const { + Selection* selection = GetSelection(); + if (selection) { + selection->AdjustAnchorFocusForMultiRange(aDir); + } +} + +void AccessibleCaretManager::ClearMaintainedSelection() const { + // Selection made by double-clicking for example will maintain the original + // word selection. We should clear it so that we can drag caret freely. + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + if (fs) { + fs->MaintainSelection(eSelectNoAmount); + } +} + +void AccessibleCaretManager::LayoutFlusher::MaybeFlush( + const PresShell& aPresShell) { + if (mAllowFlushing) { + AutoRestore<bool> flushing(mFlushing); + mFlushing = true; + + if (Document* doc = aPresShell.GetDocument()) { + doc->FlushPendingNotifications(FlushType::Layout); + // Don't access the PresShell after flushing, it could've become invalid. + } + } +} + +nsIFrame* AccessibleCaretManager::GetFrameForFirstRangeStartOrLastRangeEnd( + nsDirection aDirection, int32_t* aOutOffset, nsIContent** aOutContent, + int32_t* aOutContentOffset) const { + if (!mPresShell) { + return nullptr; + } + + MOZ_ASSERT(GetCaretMode() == CaretMode::Selection); + MOZ_ASSERT(aOutOffset, "aOutOffset shouldn't be nullptr!"); + + const nsRange* range = nullptr; + RefPtr<nsINode> startNode; + RefPtr<nsINode> endNode; + int32_t nodeOffset = 0; + CaretAssociationHint hint; + + RefPtr<Selection> selection = GetSelection(); + bool findInFirstRangeStart = aDirection == eDirNext; + + if (findInFirstRangeStart) { + range = selection->GetRangeAt(0); + startNode = range->GetStartContainer(); + endNode = range->GetEndContainer(); + nodeOffset = range->StartOffset(); + hint = CaretAssociationHint::After; + } else { + MOZ_ASSERT(selection->RangeCount() > 0); + range = selection->GetRangeAt(selection->RangeCount() - 1); + startNode = range->GetEndContainer(); + endNode = range->GetStartContainer(); + nodeOffset = range->EndOffset(); + hint = CaretAssociationHint::Before; + } + + nsCOMPtr<nsIContent> startContent = nsIContent::FromNodeOrNull(startNode); + uint32_t outOffset = 0; + nsIFrame* startFrame = SelectionMovementUtils::GetFrameForNodeOffset( + startContent, nodeOffset, hint, &outOffset); + *aOutOffset = static_cast<int32_t>(outOffset); + + if (!startFrame) { + ErrorResult err; + RefPtr<TreeWalker> walker = mPresShell->GetDocument()->CreateTreeWalker( + *startNode, dom::NodeFilter_Binding::SHOW_ALL, nullptr, err); + + if (!walker) { + return nullptr; + } + + startFrame = startContent ? startContent->GetPrimaryFrame() : nullptr; + while (!startFrame && startNode != endNode) { + startNode = findInFirstRangeStart ? walker->NextNode(err) + : walker->PreviousNode(err); + + if (!startNode) { + break; + } + + startContent = startNode->AsContent(); + startFrame = startContent ? startContent->GetPrimaryFrame() : nullptr; + } + + // We are walking among the nodes in the content tree, so the node offset + // relative to startNode should be set to 0. + nodeOffset = 0; + *aOutOffset = 0; + } + + if (startFrame) { + if (aOutContent) { + startContent.forget(aOutContent); + } + if (aOutContentOffset) { + *aOutContentOffset = nodeOffset; + } + } + + return startFrame; +} + +bool AccessibleCaretManager::RestrictCaretDraggingOffsets( + nsIFrame::ContentOffsets& aOffsets) { + if (!mPresShell) { + return false; + } + + MOZ_ASSERT(GetCaretMode() == CaretMode::Selection); + + nsDirection dir = + mActiveCaret == mCarets.GetFirst() ? eDirPrevious : eDirNext; + int32_t offset = 0; + nsCOMPtr<nsIContent> content; + int32_t contentOffset = 0; + nsIFrame* frame = GetFrameForFirstRangeStartOrLastRangeEnd( + dir, &offset, getter_AddRefs(content), &contentOffset); + + if (!frame) { + return false; + } + + // Compare the active caret's new position (aOffsets) to the inactive caret's + // position. + NS_ASSERTION(contentOffset >= 0, "contentOffset should not be negative"); + const Maybe<int32_t> cmpToInactiveCaretPos = + nsContentUtils::ComparePoints_AllowNegativeOffsets( + aOffsets.content, aOffsets.StartOffset(), content, contentOffset); + if (NS_WARN_IF(!cmpToInactiveCaretPos)) { + // Potentially handle this properly when Selection across Shadow DOM + // boundary is implemented + // (https://bugzilla.mozilla.org/show_bug.cgi?id=1607497). + return false; + } + + // Move one character (in the direction of dir) from the inactive caret's + // position. This is the limit for the active caret's new position. + PeekOffsetStruct limit( + eSelectCluster, dir, offset, nsPoint(0, 0), + {PeekOffsetOption::JumpLines, PeekOffsetOption::StopAtScroller}); + nsresult rv = frame->PeekOffset(&limit); + if (NS_FAILED(rv)) { + limit.mResultContent = content; + limit.mContentOffset = contentOffset; + } + + // Compare the active caret's new position (aOffsets) to the limit. + NS_ASSERTION(limit.mContentOffset >= 0, + "limit.mContentOffset should not be negative"); + const Maybe<int32_t> cmpToLimit = + nsContentUtils::ComparePoints_AllowNegativeOffsets( + aOffsets.content, aOffsets.StartOffset(), limit.mResultContent, + limit.mContentOffset); + if (NS_WARN_IF(!cmpToLimit)) { + // Potentially handle this properly when Selection across Shadow DOM + // boundary is implemented + // (https://bugzilla.mozilla.org/show_bug.cgi?id=1607497). + return false; + } + + auto SetOffsetsToLimit = [&aOffsets, &limit]() { + aOffsets.content = limit.mResultContent; + aOffsets.offset = limit.mContentOffset; + aOffsets.secondaryOffset = limit.mContentOffset; + }; + + if (!StaticPrefs:: + layout_accessiblecaret_allow_dragging_across_other_caret()) { + if ((mActiveCaret == mCarets.GetFirst() && *cmpToLimit == 1) || + (mActiveCaret == mCarets.GetSecond() && *cmpToLimit == -1)) { + // The active caret's position is past the limit, which we don't allow + // here. So set it to the limit, resulting in one character being + // selected. + SetOffsetsToLimit(); + } + } else { + switch (*cmpToInactiveCaretPos) { + case 0: + // The active caret's position is the same as the position of the + // inactive caret. So set it to the limit to prevent the selection from + // being collapsed, resulting in one character being selected. + SetOffsetsToLimit(); + break; + case 1: + if (mActiveCaret == mCarets.GetFirst()) { + // First caret was moved across the second caret. After making change + // to the selection, the user will drag the second caret. + mActiveCaret = mCarets.GetSecond(); + } + break; + case -1: + if (mActiveCaret == mCarets.GetSecond()) { + // Second caret was moved across the first caret. After making change + // to the selection, the user will drag the first caret. + mActiveCaret = mCarets.GetFirst(); + } + break; + } + } + + return true; +} + +bool AccessibleCaretManager::CompareTreePosition(nsIFrame* aStartFrame, + nsIFrame* aEndFrame) const { + return (aStartFrame && aEndFrame && + nsLayoutUtils::CompareTreePosition(aStartFrame, aEndFrame) <= 0); +} + +nsresult AccessibleCaretManager::DragCaretInternal(const nsPoint& aPoint) { + MOZ_ASSERT(mPresShell); + + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + MOZ_ASSERT(rootFrame, "We need root frame to compute caret dragging!"); + + nsPoint point = AdjustDragBoundary( + nsPoint(aPoint.x, aPoint.y + mOffsetYToCaretLogicalPosition)); + + // Find out which content we point to + + nsIFrame* ptFrame = nsLayoutUtils::GetFrameForPoint( + RelativeTo{rootFrame}, point, GetHitTestOptions()); + if (!ptFrame) { + return NS_ERROR_FAILURE; + } + + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + MOZ_ASSERT(fs); + + nsresult result; + nsIFrame* newFrame = nullptr; + nsPoint newPoint; + nsPoint ptInFrame = point; + nsLayoutUtils::TransformPoint(RelativeTo{rootFrame}, RelativeTo{ptFrame}, + ptInFrame); + result = fs->ConstrainFrameAndPointToAnchorSubtree(ptFrame, ptInFrame, + &newFrame, newPoint); + if (NS_FAILED(result) || !newFrame) { + return NS_ERROR_FAILURE; + } + + if (!newFrame->IsSelectable(nullptr)) { + return NS_ERROR_FAILURE; + } + + nsIFrame::ContentOffsets offsets = newFrame->GetContentOffsetsFromPoint( + newPoint, nsIFrame::IGNORE_NATIVE_ANONYMOUS_SUBTREE); + if (offsets.IsNull()) { + return NS_ERROR_FAILURE; + } + + if (GetCaretMode() == CaretMode::Selection && + !RestrictCaretDraggingOffsets(offsets)) { + return NS_ERROR_FAILURE; + } + + ClearMaintainedSelection(); + + const nsFrameSelection::FocusMode focusMode = + (GetCaretMode() == CaretMode::Selection) + ? nsFrameSelection::FocusMode::kExtendSelection + : nsFrameSelection::FocusMode::kCollapseToNewPoint; + fs->HandleClick(MOZ_KnownLive(offsets.content) /* bug 1636889 */, + offsets.StartOffset(), offsets.EndOffset(), focusMode, + offsets.associate); + return NS_OK; +} + +// static +nsRect AccessibleCaretManager::GetAllChildFrameRectsUnion(nsIFrame* aFrame) { + nsRect unionRect; + + // Drill through scroll frames, we don't want to include scrollbar child + // frames below. + for (nsIFrame* frame = aFrame->GetContentInsertionFrame(); frame; + frame = frame->GetNextContinuation()) { + nsRect frameRect; + + for (const auto& childList : frame->ChildLists()) { + // Loop all children to union their scrollable overflow rect. + for (nsIFrame* child : childList.mList) { + nsRect childRect = child->ScrollableOverflowRectRelativeToSelf(); + nsLayoutUtils::TransformRect(child, frame, childRect); + + // A TextFrame containing only '\n' has positive height and width 0, or + // positive width and height 0 if it's vertical. Need to use UnionEdges + // to add its rect. BRFrame rect should be non-empty. + if (childRect.IsEmpty()) { + frameRect = frameRect.UnionEdges(childRect); + } else { + frameRect = frameRect.Union(childRect); + } + } + } + + MOZ_ASSERT(!frameRect.IsEmpty(), + "Editable frames should have at least one BRFrame child to make " + "frameRect non-empty!"); + if (frame != aFrame) { + nsLayoutUtils::TransformRect(frame, aFrame, frameRect); + } + unionRect = unionRect.Union(frameRect); + } + + return unionRect; +} + +nsPoint AccessibleCaretManager::AdjustDragBoundary( + const nsPoint& aPoint) const { + nsPoint adjustedPoint = aPoint; + + int32_t focusOffset = 0; + nsIFrame* focusFrame = + nsCaret::GetFrameAndOffset(GetSelection(), nullptr, 0, &focusOffset); + Element* editingHost = GetEditingHostForFrame(focusFrame); + + if (editingHost) { + nsIFrame* editingHostFrame = editingHost->GetPrimaryFrame(); + if (editingHostFrame) { + nsRect boundary = + AccessibleCaretManager::GetAllChildFrameRectsUnion(editingHostFrame); + nsLayoutUtils::TransformRect(editingHostFrame, mPresShell->GetRootFrame(), + boundary); + + // Shrink the rect to make sure we never hit the boundary. + boundary.Deflate(kBoundaryAppUnits); + + adjustedPoint = boundary.ClampPoint(adjustedPoint); + } + } + + if (GetCaretMode() == CaretMode::Selection && + !StaticPrefs:: + layout_accessiblecaret_allow_dragging_across_other_caret()) { + // Bug 1068474: Adjust the Y-coordinate so that the carets won't be in tilt + // mode when a caret is being dragged surpass the other caret. + // + // For example, when dragging the second caret, the horizontal boundary + // (lower bound) of its Y-coordinate is the logical position of the first + // caret. Likewise, when dragging the first caret, the horizontal boundary + // (upper bound) of its Y-coordinate is the logical position of the second + // caret. + if (mActiveCaret == mCarets.GetFirst()) { + nscoord dragDownBoundaryY = mCarets.GetSecond()->LogicalPosition().y; + if (dragDownBoundaryY > 0 && adjustedPoint.y > dragDownBoundaryY) { + adjustedPoint.y = dragDownBoundaryY; + } + } else { + nscoord dragUpBoundaryY = mCarets.GetFirst()->LogicalPosition().y; + if (adjustedPoint.y < dragUpBoundaryY) { + adjustedPoint.y = dragUpBoundaryY; + } + } + } + + return adjustedPoint; +} + +void AccessibleCaretManager::StartSelectionAutoScrollTimer( + const nsPoint& aPoint) const { + Selection* selection = GetSelection(); + MOZ_ASSERT(selection); + + nsIFrame* anchorFrame = selection->GetPrimaryFrameForAnchorNode(); + if (!anchorFrame) { + return; + } + + nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetNearestScrollableFrame( + anchorFrame, nsLayoutUtils::SCROLLABLE_SAME_DOC | + nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN); + if (!scrollFrame) { + return; + } + + nsIFrame* capturingFrame = scrollFrame->GetScrolledFrame(); + if (!capturingFrame) { + return; + } + + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + MOZ_ASSERT(rootFrame); + nsPoint ptInScrolled = aPoint; + nsLayoutUtils::TransformPoint(RelativeTo{rootFrame}, + RelativeTo{capturingFrame}, ptInScrolled); + + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + MOZ_ASSERT(fs); + fs->StartAutoScrollTimer(capturingFrame, ptInScrolled, kAutoScrollTimerDelay); +} + +void AccessibleCaretManager::StopSelectionAutoScrollTimer() const { + RefPtr<nsFrameSelection> fs = GetFrameSelection(); + MOZ_ASSERT(fs); + fs->StopAutoScrollTimer(); +} + +void AccessibleCaretManager::DispatchCaretStateChangedEvent( + CaretChangedReason aReason, const nsPoint* aPoint) { + if (MaybeFlushLayout() == Terminated::Yes) { + return; + } + + const Selection* sel = GetSelection(); + if (!sel) { + return; + } + + Document* doc = mPresShell->GetDocument(); + MOZ_ASSERT(doc); + + CaretStateChangedEventInit init; + init.mBubbles = true; + + const nsRange* range = sel->GetAnchorFocusRange(); + nsINode* commonAncestorNode = nullptr; + if (range) { + commonAncestorNode = range->GetClosestCommonInclusiveAncestor(); + } + + if (!commonAncestorNode) { + commonAncestorNode = sel->GetFrameSelection()->GetAncestorLimiter(); + } + + RefPtr<DOMRect> domRect = new DOMRect(ToSupports(doc)); + nsRect rect = nsLayoutUtils::GetSelectionBoundingRect(sel); + + nsIFrame* commonAncestorFrame = nullptr; + nsIFrame* rootFrame = mPresShell->GetRootFrame(); + + if (commonAncestorNode && commonAncestorNode->IsContent()) { + commonAncestorFrame = commonAncestorNode->AsContent()->GetPrimaryFrame(); + } + + if (commonAncestorFrame && rootFrame) { + nsLayoutUtils::TransformRect(rootFrame, commonAncestorFrame, rect); + nsRect clampedRect = + nsLayoutUtils::ClampRectToScrollFrames(commonAncestorFrame, rect); + nsLayoutUtils::TransformRect(commonAncestorFrame, rootFrame, clampedRect); + rect = clampedRect; + init.mSelectionVisible = !clampedRect.IsEmpty(); + } else { + init.mSelectionVisible = true; + } + + domRect->SetLayoutRect(rect); + + // Send isEditable info w/ event detail. This info can help determine + // whether to show cut command on selection dialog or not. + init.mSelectionEditable = + commonAncestorFrame && GetEditingHostForFrame(commonAncestorFrame); + + init.mBoundingClientRect = domRect; + init.mReason = aReason; + init.mCollapsed = sel->IsCollapsed(); + init.mCaretVisible = mCarets.HasLogicallyVisibleCaret(); + init.mCaretVisuallyVisible = mCarets.HasVisuallyVisibleCaret(); + init.mSelectedTextContent = StringifiedSelection(); + + if (aPoint) { + CSSIntPoint pt = CSSPixel::FromAppUnitsRounded(*aPoint); + init.mClientX = pt.x; + init.mClientY = pt.y; + } + + RefPtr<CaretStateChangedEvent> event = CaretStateChangedEvent::Constructor( + doc, u"mozcaretstatechanged"_ns, init); + event->SetTrusted(true); + + AC_LOG("%s: reason %" PRIu32 ", collapsed %d, caretVisible %" PRIu32, + __FUNCTION__, static_cast<uint32_t>(init.mReason), init.mCollapsed, + static_cast<uint32_t>(init.mCaretVisible)); + + (new AsyncEventDispatcher(doc, event.forget(), ChromeOnlyDispatch::eYes)) + ->PostDOMEvent(); +} + +AccessibleCaretManager::Carets::Carets(UniquePtr<AccessibleCaret> aFirst, + UniquePtr<AccessibleCaret> aSecond) + : mFirst{std::move(aFirst)}, mSecond{std::move(aSecond)} {} + +} // namespace mozilla |