зеркало из https://github.com/mozilla/gecko-dev.git
3081 строка
110 KiB
C++
3081 строка
110 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "ContentEventHandler.h"
|
|
#include "mozilla/IMEStateManager.h"
|
|
#include "mozilla/TextComposition.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/HTMLUnknownElement.h"
|
|
#include "mozilla/dom/Selection.h"
|
|
#include "nsCaret.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCopySupport.h"
|
|
#include "nsFocusManager.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsFrameSelection.h"
|
|
#include "nsIContentIterator.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsISelection.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsIObjectFrame.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsQueryObject.h"
|
|
#include "nsRange.h"
|
|
#include "nsTextFragment.h"
|
|
#include "nsTextFrame.h"
|
|
#include "nsView.h"
|
|
|
|
#include <algorithm>
|
|
|
|
namespace mozilla {
|
|
|
|
using namespace dom;
|
|
using namespace widget;
|
|
|
|
/******************************************************************/
|
|
/* ContentEventHandler */
|
|
/******************************************************************/
|
|
|
|
// NOTE
|
|
//
|
|
// ContentEventHandler *creates* ranges as following rules:
|
|
// 1. Start of range:
|
|
// 1.1. Cases: [textNode or text[Node or textNode[
|
|
// When text node is start of a range, start node is the text node and
|
|
// start offset is any number between 0 and the length of the text.
|
|
// 1.2. Case: [<element>:
|
|
// When start of an element node is start of a range, start node is
|
|
// parent of the element and start offset is the element's index in the
|
|
// parent.
|
|
// 1.3. Case: <element/>[
|
|
// When after an empty element node is start of a range, start node is
|
|
// parent of the element and start offset is the element's index in the
|
|
// parent + 1.
|
|
// 1.4. Case: <element>[
|
|
// When start of a non-empty element is start of a range, start node is
|
|
// the element and start offset is 0.
|
|
// 1.5. Case: <root>[
|
|
// When start of a range is 0 and there are no nodes causing text,
|
|
// start node is the root node and start offset is 0.
|
|
// 1.6. Case: [</root>
|
|
// When start of a range is out of bounds, start node is the root node
|
|
// and start offset is number of the children.
|
|
// 2. End of range:
|
|
// 2.1. Cases: ]textNode or text]Node or textNode]
|
|
// When a text node is end of a range, end node is the text node and
|
|
// end offset is any number between 0 and the length of the text.
|
|
// 2.2. Case: ]<element>
|
|
// When before an element node (meaning before the open tag of the
|
|
// element) is end of a range, end node is previous node causing text.
|
|
// Note that this case shouldn't be handled directly. If rule 2.1 and
|
|
// 2.3 are handled correctly, the loop with nsContentIterator shouldn't
|
|
// reach the element node since the loop should've finished already at
|
|
// handling the last node which caused some text.
|
|
// 2.3. Case: <element>]
|
|
// When a line break is caused before a non-empty element node and it's
|
|
// end of a range, end node is the element and end offset is 0.
|
|
// (i.e., including open tag of the element)
|
|
// 2.4. Cases: <element/>]
|
|
// When after an empty element node is end of a range, end node is
|
|
// parent of the element node and end offset is the element's index in
|
|
// the parent + 1. (i.e., including close tag of the element or empty
|
|
// element)
|
|
// 2.5. Case: ]</root>
|
|
// When end of a range is out of bounds, end node is the root node and
|
|
// end offset is number of the children.
|
|
//
|
|
// ContentEventHandler *treats* ranges as following additional rules:
|
|
// 1. When the start node is an element node which doesn't have children,
|
|
// it includes a line break caused before itself (i.e., includes its open
|
|
// tag). For example, if start position is { <br>, 0 }, the line break
|
|
// caused by <br> should be included into the flatten text.
|
|
// 2. When the end node is an element node which doesn't have children,
|
|
// it includes the end (i.e., includes its close tag except empty element).
|
|
// Although, currently, any close tags don't cause line break, this also
|
|
// includes its open tag. For example, if end position is { <br>, 0 }, the
|
|
// line break caused by the <br> should be included into the flatten text.
|
|
|
|
ContentEventHandler::ContentEventHandler(nsPresContext* aPresContext)
|
|
: mPresContext(aPresContext)
|
|
, mPresShell(aPresContext->GetPresShell())
|
|
, mSelection(nullptr)
|
|
, mFirstSelectedRange(nullptr)
|
|
, mRootContent(nullptr)
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::InitBasic()
|
|
{
|
|
NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
// If text frame which has overflowing selection underline is dirty,
|
|
// we need to flush the pending reflow here.
|
|
mPresShell->FlushPendingNotifications(FlushType::Layout);
|
|
|
|
// Flushing notifications can cause mPresShell to be destroyed (bug 577963).
|
|
NS_ENSURE_TRUE(!mPresShell->IsDestroying(), NS_ERROR_FAILURE);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::InitRootContent(Selection* aNormalSelection)
|
|
{
|
|
MOZ_ASSERT(aNormalSelection);
|
|
|
|
// Root content should be computed with normal selection because normal
|
|
// selection is typically has at least one range but the other selections
|
|
// not so. If there is a range, computing its root is easy, but if
|
|
// there are no ranges, we need to use ancestor limit instead.
|
|
MOZ_ASSERT(aNormalSelection->Type() == SelectionType::eNormal);
|
|
|
|
if (!aNormalSelection->RangeCount()) {
|
|
// If there is no selection range, we should compute the selection root
|
|
// from ancestor limiter or root content of the document.
|
|
nsresult rv =
|
|
aNormalSelection->GetAncestorLimiter(getter_AddRefs(mRootContent));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
if (!mRootContent) {
|
|
mRootContent = mPresShell->GetDocument()->GetRootElement();
|
|
if (NS_WARN_IF(!mRootContent)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
RefPtr<nsRange> range(aNormalSelection->GetRangeAt(0));
|
|
if (NS_WARN_IF(!range)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
// If there is a selection, we should retrieve the selection root from
|
|
// the range since when the window is inactivated, the ancestor limiter
|
|
// of selection was cleared by blur event handler of EditorBase but the
|
|
// selection range still keeps storing the nodes. If the active element of
|
|
// the deactive window is <input> or <textarea>, we can compute the
|
|
// selection root from them.
|
|
nsINode* startNode = range->GetStartParent();
|
|
nsINode* endNode = range->GetEndParent();
|
|
if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// See bug 537041 comment 5, the range could have removed node.
|
|
if (NS_WARN_IF(startNode->GetUncomposedDoc() != mPresShell->GetDocument())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_ASSERTION(startNode->GetUncomposedDoc() == endNode->GetUncomposedDoc(),
|
|
"firstNormalSelectionRange crosses the document boundary");
|
|
|
|
mRootContent = startNode->GetSelectionRootContent(mPresShell);
|
|
if (NS_WARN_IF(!mRootContent)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::InitCommon(SelectionType aSelectionType)
|
|
{
|
|
if (mSelection && mSelection->Type() == aSelectionType) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mSelection = nullptr;
|
|
mFirstSelectedRange = nullptr;
|
|
mRootContent = nullptr;
|
|
|
|
nsresult rv = InitBasic();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsISelectionController> selectionController =
|
|
mPresShell->GetSelectionControllerForFocusedContent();
|
|
if (NS_WARN_IF(!selectionController)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
nsCOMPtr<nsISelection> selection;
|
|
rv = selectionController->GetSelection(ToRawSelectionType(aSelectionType),
|
|
getter_AddRefs(selection));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
mSelection = static_cast<Selection*>(selection.get());
|
|
if (NS_WARN_IF(!mSelection)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
RefPtr<Selection> normalSelection;
|
|
if (mSelection->Type() == SelectionType::eNormal) {
|
|
normalSelection = mSelection;
|
|
} else {
|
|
nsCOMPtr<nsISelection> domSelection;
|
|
nsresult rv =
|
|
selectionController->GetSelection(
|
|
nsISelectionController::SELECTION_NORMAL,
|
|
getter_AddRefs(domSelection));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
if (NS_WARN_IF(!domSelection)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
normalSelection = domSelection->AsSelection();
|
|
if (NS_WARN_IF(!normalSelection)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
}
|
|
|
|
rv = InitRootContent(normalSelection);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (mSelection->RangeCount()) {
|
|
mFirstSelectedRange = mSelection->GetRangeAt(0);
|
|
if (NS_WARN_IF(!mFirstSelectedRange)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
// Even if there are no selection ranges, it's usual case if aSelectionType
|
|
// is a special selection.
|
|
if (aSelectionType != SelectionType::eNormal) {
|
|
MOZ_ASSERT(!mFirstSelectedRange);
|
|
return NS_OK;
|
|
}
|
|
|
|
// But otherwise, we need to assume that there is a selection range at the
|
|
// beginning of the root content if aSelectionType is eNormal.
|
|
rv = nsRange::CreateRange(mRootContent, 0, mRootContent, 0,
|
|
getter_AddRefs(mFirstSelectedRange));
|
|
if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!mFirstSelectedRange)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::Init(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
NS_ASSERTION(aEvent, "aEvent must not be null");
|
|
MOZ_ASSERT(aEvent->mMessage == eQuerySelectedText ||
|
|
aEvent->mInput.mSelectionType == SelectionType::eNormal);
|
|
|
|
if (NS_WARN_IF(!aEvent->mInput.IsValidOffset()) ||
|
|
NS_WARN_IF(!aEvent->mInput.IsValidEventMessage(aEvent->mMessage))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Note that we should ignore WidgetQueryContentEvent::Input::mSelectionType
|
|
// if the event isn't eQuerySelectedText.
|
|
SelectionType selectionType =
|
|
aEvent->mMessage == eQuerySelectedText ? aEvent->mInput.mSelectionType :
|
|
SelectionType::eNormal;
|
|
if (NS_WARN_IF(selectionType == SelectionType::eNone)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult rv = InitCommon(selectionType);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Be aware, WidgetQueryContentEvent::mInput::mOffset should be made absolute
|
|
// offset before sending it to ContentEventHandler because querying selection
|
|
// every time may be expensive. So, if the caller caches selection, it
|
|
// should initialize the event with the cached value.
|
|
if (aEvent->mInput.mRelativeToInsertionPoint) {
|
|
MOZ_ASSERT(selectionType == SelectionType::eNormal);
|
|
RefPtr<TextComposition> composition =
|
|
IMEStateManager::GetTextCompositionFor(aEvent->mWidget);
|
|
if (composition) {
|
|
uint32_t compositionStart = composition->NativeOffsetOfStartComposition();
|
|
if (NS_WARN_IF(!aEvent->mInput.MakeOffsetAbsolute(compositionStart))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
} else {
|
|
LineBreakType lineBreakType = GetLineBreakType(aEvent);
|
|
uint32_t selectionStart = 0;
|
|
rv = GetStartOffset(mFirstSelectedRange, &selectionStart, lineBreakType);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
if (NS_WARN_IF(!aEvent->mInput.MakeOffsetAbsolute(selectionStart))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
|
|
aEvent->mSucceeded = false;
|
|
|
|
aEvent->mReply.mContentsRoot = mRootContent.get();
|
|
|
|
aEvent->mReply.mHasSelection = !mSelection->IsCollapsed();
|
|
|
|
nsRect r;
|
|
nsIFrame* frame = nsCaret::GetGeometry(mSelection, &r);
|
|
if (!frame) {
|
|
frame = mRootContent->GetPrimaryFrame();
|
|
if (NS_WARN_IF(!frame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
aEvent->mReply.mFocusedWidget = frame->GetNearestWidget();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::Init(WidgetSelectionEvent* aEvent)
|
|
{
|
|
NS_ASSERTION(aEvent, "aEvent must not be null");
|
|
|
|
nsresult rv = InitCommon();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
aEvent->mSucceeded = false;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIContent*
|
|
ContentEventHandler::GetFocusedContent()
|
|
{
|
|
nsIDocument* doc = mPresShell->GetDocument();
|
|
if (!doc) {
|
|
return nullptr;
|
|
}
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = doc->GetWindow();
|
|
nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
|
|
return nsFocusManager::GetFocusedDescendant(window, true,
|
|
getter_AddRefs(focusedWindow));
|
|
}
|
|
|
|
bool
|
|
ContentEventHandler::IsPlugin(nsIContent* aContent)
|
|
{
|
|
return aContent &&
|
|
aContent->GetDesiredIMEState().mEnabled == IMEState::PLUGIN;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::QueryContentRect(nsIContent* aContent,
|
|
WidgetQueryContentEvent* aEvent)
|
|
{
|
|
NS_PRECONDITION(aContent, "aContent must not be null");
|
|
|
|
nsIFrame* frame = aContent->GetPrimaryFrame();
|
|
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
|
|
|
|
// get rect for first frame
|
|
nsRect resultRect(nsPoint(0, 0), frame->GetRect().Size());
|
|
nsresult rv = ConvertToRootRelativeOffset(frame, resultRect);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// account for any additional frames
|
|
while ((frame = frame->GetNextContinuation()) != nullptr) {
|
|
nsRect frameRect(nsPoint(0, 0), frame->GetRect().Size());
|
|
rv = ConvertToRootRelativeOffset(frame, frameRect);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
resultRect.UnionRect(resultRect, frameRect);
|
|
}
|
|
|
|
aEvent->mReply.mRect = LayoutDeviceIntRect::FromUnknownRect(
|
|
resultRect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel()));
|
|
// Returning empty rect may cause native IME confused, let's make sure to
|
|
// return non-empty rect.
|
|
EnsureNonEmptyRect(aEvent->mReply.mRect);
|
|
aEvent->mSucceeded = true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Editor places a bogus BR node under its root content if the editor doesn't
|
|
// have any text. This happens even for single line editors.
|
|
// When we get text content and when we change the selection,
|
|
// we don't want to include the bogus BRs at the end.
|
|
static bool IsContentBR(nsIContent* aContent)
|
|
{
|
|
return aContent->IsHTMLElement(nsGkAtoms::br) &&
|
|
!aContent->AttrValueIs(kNameSpaceID_None,
|
|
nsGkAtoms::type,
|
|
nsGkAtoms::moz,
|
|
eIgnoreCase) &&
|
|
!aContent->AttrValueIs(kNameSpaceID_None,
|
|
nsGkAtoms::mozeditorbogusnode,
|
|
nsGkAtoms::_true,
|
|
eIgnoreCase);
|
|
}
|
|
|
|
static bool IsMozBR(nsIContent* aContent)
|
|
{
|
|
return aContent->IsHTMLElement(nsGkAtoms::br) && !IsContentBR(aContent);
|
|
}
|
|
|
|
static void ConvertToNativeNewlines(nsAFlatString& aString)
|
|
{
|
|
#if defined(XP_WIN)
|
|
aString.ReplaceSubstring(NS_LITERAL_STRING("\n"), NS_LITERAL_STRING("\r\n"));
|
|
#endif
|
|
}
|
|
|
|
static void AppendString(nsAString& aString, nsIContent* aContent)
|
|
{
|
|
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
|
|
"aContent is not a text node!");
|
|
const nsTextFragment* text = aContent->GetText();
|
|
if (!text) {
|
|
return;
|
|
}
|
|
text->AppendTo(aString);
|
|
}
|
|
|
|
static void AppendSubString(nsAString& aString, nsIContent* aContent,
|
|
uint32_t aXPOffset, uint32_t aXPLength)
|
|
{
|
|
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
|
|
"aContent is not a text node!");
|
|
const nsTextFragment* text = aContent->GetText();
|
|
if (!text) {
|
|
return;
|
|
}
|
|
text->AppendTo(aString, int32_t(aXPOffset), int32_t(aXPLength));
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
static uint32_t CountNewlinesInXPLength(nsIContent* aContent,
|
|
uint32_t aXPLength)
|
|
{
|
|
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
|
|
"aContent is not a text node!");
|
|
const nsTextFragment* text = aContent->GetText();
|
|
if (!text) {
|
|
return 0;
|
|
}
|
|
// For automated tests, we should abort on debug build.
|
|
MOZ_ASSERT(aXPLength == UINT32_MAX || aXPLength <= text->GetLength(),
|
|
"aXPLength is out-of-bounds");
|
|
const uint32_t length = std::min(aXPLength, text->GetLength());
|
|
uint32_t newlines = 0;
|
|
for (uint32_t i = 0; i < length; ++i) {
|
|
if (text->CharAt(i) == '\n') {
|
|
++newlines;
|
|
}
|
|
}
|
|
return newlines;
|
|
}
|
|
|
|
static uint32_t CountNewlinesInNativeLength(nsIContent* aContent,
|
|
uint32_t aNativeLength)
|
|
{
|
|
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
|
|
"aContent is not a text node!");
|
|
const nsTextFragment* text = aContent->GetText();
|
|
if (!text) {
|
|
return 0;
|
|
}
|
|
// For automated tests, we should abort on debug build.
|
|
MOZ_ASSERT(
|
|
(aNativeLength == UINT32_MAX || aNativeLength <= text->GetLength() * 2),
|
|
"aNativeLength is unexpected value");
|
|
const uint32_t xpLength = text->GetLength();
|
|
uint32_t newlines = 0;
|
|
for (uint32_t i = 0, nativeOffset = 0;
|
|
i < xpLength && nativeOffset < aNativeLength;
|
|
++i, ++nativeOffset) {
|
|
// For automated tests, we should abort on debug build.
|
|
MOZ_ASSERT(i < text->GetLength(), "i is out-of-bounds");
|
|
if (text->CharAt(i) == '\n') {
|
|
++newlines;
|
|
++nativeOffset;
|
|
}
|
|
}
|
|
return newlines;
|
|
}
|
|
#endif
|
|
|
|
/* static */ uint32_t
|
|
ContentEventHandler::GetNativeTextLength(nsIContent* aContent,
|
|
uint32_t aStartOffset,
|
|
uint32_t aEndOffset)
|
|
{
|
|
MOZ_ASSERT(aEndOffset >= aStartOffset,
|
|
"aEndOffset must be equals or larger than aStartOffset");
|
|
if (NS_WARN_IF(!aContent->IsNodeOfType(nsINode::eTEXT))) {
|
|
return 0;
|
|
}
|
|
if (aStartOffset == aEndOffset) {
|
|
return 0;
|
|
}
|
|
return GetTextLength(aContent, LINE_BREAK_TYPE_NATIVE, aEndOffset) -
|
|
GetTextLength(aContent, LINE_BREAK_TYPE_NATIVE, aStartOffset);
|
|
}
|
|
|
|
/* static */ uint32_t
|
|
ContentEventHandler::GetNativeTextLength(nsIContent* aContent,
|
|
uint32_t aMaxLength)
|
|
{
|
|
if (NS_WARN_IF(!aContent->IsNodeOfType(nsINode::eTEXT))) {
|
|
return 0;
|
|
}
|
|
return GetTextLength(aContent, LINE_BREAK_TYPE_NATIVE, aMaxLength);
|
|
}
|
|
|
|
/* static */ uint32_t
|
|
ContentEventHandler::GetNativeTextLengthBefore(nsIContent* aContent,
|
|
nsINode* aRootNode)
|
|
{
|
|
if (NS_WARN_IF(aContent->IsNodeOfType(nsINode::eTEXT))) {
|
|
return 0;
|
|
}
|
|
return ShouldBreakLineBefore(aContent, aRootNode) ?
|
|
GetBRLength(LINE_BREAK_TYPE_NATIVE) : 0;
|
|
}
|
|
|
|
/* static inline */ uint32_t
|
|
ContentEventHandler::GetBRLength(LineBreakType aLineBreakType)
|
|
{
|
|
#if defined(XP_WIN)
|
|
// Length of \r\n
|
|
return (aLineBreakType == LINE_BREAK_TYPE_NATIVE) ? 2 : 1;
|
|
#else
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
/* static */ uint32_t
|
|
ContentEventHandler::GetTextLength(nsIContent* aContent,
|
|
LineBreakType aLineBreakType,
|
|
uint32_t aMaxLength)
|
|
{
|
|
MOZ_ASSERT(aContent->IsNodeOfType(nsINode::eTEXT));
|
|
|
|
uint32_t textLengthDifference =
|
|
#if defined(XP_WIN)
|
|
// On Windows, the length of a native newline ("\r\n") is twice the length
|
|
// of the XP newline ("\n"), so XP length is equal to the length of the
|
|
// native offset plus the number of newlines encountered in the string.
|
|
(aLineBreakType == LINE_BREAK_TYPE_NATIVE) ?
|
|
CountNewlinesInXPLength(aContent, aMaxLength) : 0;
|
|
#else
|
|
// On other platforms, the native and XP newlines are the same.
|
|
0;
|
|
#endif
|
|
|
|
const nsTextFragment* text = aContent->GetText();
|
|
if (!text) {
|
|
return 0;
|
|
}
|
|
uint32_t length = std::min(text->GetLength(), aMaxLength);
|
|
return length + textLengthDifference;
|
|
}
|
|
|
|
static uint32_t ConvertToXPOffset(nsIContent* aContent, uint32_t aNativeOffset)
|
|
{
|
|
#if defined(XP_WIN)
|
|
// On Windows, the length of a native newline ("\r\n") is twice the length of
|
|
// the XP newline ("\n"), so XP offset is equal to the length of the native
|
|
// offset minus the number of newlines encountered in the string.
|
|
return aNativeOffset - CountNewlinesInNativeLength(aContent, aNativeOffset);
|
|
#else
|
|
// On other platforms, the native and XP newlines are the same.
|
|
return aNativeOffset;
|
|
#endif
|
|
}
|
|
|
|
/* static */ bool
|
|
ContentEventHandler::ShouldBreakLineBefore(nsIContent* aContent,
|
|
nsINode* aRootNode)
|
|
{
|
|
// We don't need to append linebreak at the start of the root element.
|
|
if (aContent == aRootNode) {
|
|
return false;
|
|
}
|
|
|
|
// If it's not an HTML element (including other markup language's elements),
|
|
// we shouldn't insert like break before that for now. Becoming this is a
|
|
// problem must be edge case. E.g., when ContentEventHandler is used with
|
|
// MathML or SVG elements.
|
|
if (!aContent->IsHTMLElement()) {
|
|
return false;
|
|
}
|
|
|
|
// If the element is <br>, we need to check if the <br> is caused by web
|
|
// content. Otherwise, i.e., it's caused by internal reason of Gecko,
|
|
// it shouldn't be exposed as a line break to flatten text.
|
|
if (aContent->IsHTMLElement(nsGkAtoms::br)) {
|
|
return IsContentBR(aContent);
|
|
}
|
|
|
|
// Note that ideally, we should refer the style of the primary frame of
|
|
// aContent for deciding if it's an inline. However, it's difficult
|
|
// IMEContentObserver to notify IME of text change caused by style change.
|
|
// Therefore, currently, we should check only from the tag for now.
|
|
if (aContent->IsAnyOfHTMLElements(nsGkAtoms::a,
|
|
nsGkAtoms::abbr,
|
|
nsGkAtoms::acronym,
|
|
nsGkAtoms::b,
|
|
nsGkAtoms::bdi,
|
|
nsGkAtoms::bdo,
|
|
nsGkAtoms::big,
|
|
nsGkAtoms::cite,
|
|
nsGkAtoms::code,
|
|
nsGkAtoms::data,
|
|
nsGkAtoms::del,
|
|
nsGkAtoms::dfn,
|
|
nsGkAtoms::em,
|
|
nsGkAtoms::font,
|
|
nsGkAtoms::i,
|
|
nsGkAtoms::ins,
|
|
nsGkAtoms::kbd,
|
|
nsGkAtoms::mark,
|
|
nsGkAtoms::s,
|
|
nsGkAtoms::samp,
|
|
nsGkAtoms::small,
|
|
nsGkAtoms::span,
|
|
nsGkAtoms::strike,
|
|
nsGkAtoms::strong,
|
|
nsGkAtoms::sub,
|
|
nsGkAtoms::sup,
|
|
nsGkAtoms::time,
|
|
nsGkAtoms::tt,
|
|
nsGkAtoms::u,
|
|
nsGkAtoms::var)) {
|
|
return false;
|
|
}
|
|
|
|
// If the element is unknown element, we shouldn't insert line breaks before
|
|
// it since unknown elements should be ignored.
|
|
RefPtr<HTMLUnknownElement> unknownHTMLElement = do_QueryObject(aContent);
|
|
return !unknownHTMLElement;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::GenerateFlatTextContent(nsIContent* aContent,
|
|
nsAFlatString& aString,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aString.IsEmpty());
|
|
|
|
RefPtr<nsRange> range = new nsRange(mRootContent);
|
|
ErrorResult rv;
|
|
range->SelectNodeContents(*aContent, rv);
|
|
if (NS_WARN_IF(rv.Failed())) {
|
|
return rv.StealNSResult();
|
|
}
|
|
return GenerateFlatTextContent(range, aString, aLineBreakType);
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::GenerateFlatTextContent(nsRange* aRange,
|
|
nsAFlatString& aString,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aString.IsEmpty());
|
|
|
|
if (aRange->Collapsed()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsINode* startNode = aRange->GetStartParent();
|
|
nsINode* endNode = aRange->GetEndParent();
|
|
if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (startNode == endNode && startNode->IsNodeOfType(nsINode::eTEXT)) {
|
|
nsIContent* content = startNode->AsContent();
|
|
AppendSubString(aString, content, aRange->StartOffset(),
|
|
aRange->EndOffset() - aRange->StartOffset());
|
|
ConvertToNativeNewlines(aString);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
|
|
nsresult rv = iter->Init(aRange);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
for (; !iter->IsDone(); iter->Next()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
if (!node->IsContent()) {
|
|
continue;
|
|
}
|
|
nsIContent* content = node->AsContent();
|
|
|
|
if (content->IsNodeOfType(nsINode::eTEXT)) {
|
|
if (content == startNode) {
|
|
AppendSubString(aString, content, aRange->StartOffset(),
|
|
content->TextLength() - aRange->StartOffset());
|
|
} else if (content == endNode) {
|
|
AppendSubString(aString, content, 0, aRange->EndOffset());
|
|
} else {
|
|
AppendString(aString, content);
|
|
}
|
|
} else if (ShouldBreakLineBefore(content, mRootContent)) {
|
|
aString.Append(char16_t('\n'));
|
|
}
|
|
}
|
|
if (aLineBreakType == LINE_BREAK_TYPE_NATIVE) {
|
|
ConvertToNativeNewlines(aString);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
static FontRange*
|
|
AppendFontRange(nsTArray<FontRange>& aFontRanges, uint32_t aBaseOffset)
|
|
{
|
|
FontRange* fontRange = aFontRanges.AppendElement();
|
|
fontRange->mStartOffset = aBaseOffset;
|
|
return fontRange;
|
|
}
|
|
|
|
/* static */ uint32_t
|
|
ContentEventHandler::GetTextLengthInRange(nsIContent* aContent,
|
|
uint32_t aXPStartOffset,
|
|
uint32_t aXPEndOffset,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aContent->IsNodeOfType(nsINode::eTEXT));
|
|
|
|
return aLineBreakType == LINE_BREAK_TYPE_NATIVE ?
|
|
GetNativeTextLength(aContent, aXPStartOffset, aXPEndOffset) :
|
|
aXPEndOffset - aXPStartOffset;
|
|
}
|
|
|
|
/* static */ void
|
|
ContentEventHandler::AppendFontRanges(FontRangeArray& aFontRanges,
|
|
nsIContent* aContent,
|
|
int32_t aBaseOffset,
|
|
int32_t aXPStartOffset,
|
|
int32_t aXPEndOffset,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aContent->IsNodeOfType(nsINode::eTEXT));
|
|
|
|
nsIFrame* frame = aContent->GetPrimaryFrame();
|
|
if (!frame) {
|
|
// It is a non-rendered content, create an empty range for it.
|
|
AppendFontRange(aFontRanges, aBaseOffset);
|
|
return;
|
|
}
|
|
|
|
int32_t baseOffset = aBaseOffset;
|
|
nsTextFrame* curr = do_QueryFrame(frame);
|
|
MOZ_ASSERT(curr, "Not a text frame");
|
|
while (curr) {
|
|
int32_t frameXPStart = std::max(curr->GetContentOffset(), aXPStartOffset);
|
|
int32_t frameXPEnd = std::min(curr->GetContentEnd(), aXPEndOffset);
|
|
if (frameXPStart >= frameXPEnd) {
|
|
curr = static_cast<nsTextFrame*>(curr->GetNextContinuation());
|
|
continue;
|
|
}
|
|
|
|
gfxSkipCharsIterator iter = curr->EnsureTextRun(nsTextFrame::eInflated);
|
|
gfxTextRun* textRun = curr->GetTextRun(nsTextFrame::eInflated);
|
|
|
|
nsTextFrame* next = nullptr;
|
|
if (frameXPEnd < aXPEndOffset) {
|
|
next = static_cast<nsTextFrame*>(curr->GetNextContinuation());
|
|
while (next && next->GetTextRun(nsTextFrame::eInflated) == textRun) {
|
|
frameXPEnd = std::min(next->GetContentEnd(), aXPEndOffset);
|
|
next = frameXPEnd < aXPEndOffset ?
|
|
static_cast<nsTextFrame*>(next->GetNextContinuation()) : nullptr;
|
|
}
|
|
}
|
|
|
|
gfxTextRun::Range skipRange(iter.ConvertOriginalToSkipped(frameXPStart),
|
|
iter.ConvertOriginalToSkipped(frameXPEnd));
|
|
gfxTextRun::GlyphRunIterator runIter(textRun, skipRange);
|
|
int32_t lastXPEndOffset = frameXPStart;
|
|
while (runIter.NextRun()) {
|
|
gfxFont* font = runIter.GetGlyphRun()->mFont.get();
|
|
int32_t startXPOffset =
|
|
iter.ConvertSkippedToOriginal(runIter.GetStringStart());
|
|
// It is possible that the first glyph run has exceeded the frame,
|
|
// because the whole frame is filled by skipped chars.
|
|
if (startXPOffset >= frameXPEnd) {
|
|
break;
|
|
}
|
|
|
|
if (startXPOffset > lastXPEndOffset) {
|
|
// Create range for skipped leading chars.
|
|
AppendFontRange(aFontRanges, baseOffset);
|
|
baseOffset += GetTextLengthInRange(
|
|
aContent, lastXPEndOffset, startXPOffset, aLineBreakType);
|
|
lastXPEndOffset = startXPOffset;
|
|
}
|
|
|
|
FontRange* fontRange = AppendFontRange(aFontRanges, baseOffset);
|
|
fontRange->mFontName = font->GetName();
|
|
fontRange->mFontSize = font->GetAdjustedSize();
|
|
|
|
// The converted original offset may exceed the range,
|
|
// hence we need to clamp it.
|
|
int32_t endXPOffset =
|
|
iter.ConvertSkippedToOriginal(runIter.GetStringEnd());
|
|
endXPOffset = std::min(frameXPEnd, endXPOffset);
|
|
baseOffset += GetTextLengthInRange(aContent, startXPOffset, endXPOffset,
|
|
aLineBreakType);
|
|
lastXPEndOffset = endXPOffset;
|
|
}
|
|
if (lastXPEndOffset < frameXPEnd) {
|
|
// Create range for skipped trailing chars. It also handles case
|
|
// that the whole frame contains only skipped chars.
|
|
AppendFontRange(aFontRanges, baseOffset);
|
|
baseOffset += GetTextLengthInRange(
|
|
aContent, lastXPEndOffset, frameXPEnd, aLineBreakType);
|
|
}
|
|
|
|
curr = next;
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::GenerateFlatFontRanges(nsRange* aRange,
|
|
FontRangeArray& aFontRanges,
|
|
uint32_t& aLength,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aFontRanges.IsEmpty(), "aRanges must be empty array");
|
|
|
|
if (aRange->Collapsed()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsINode* startNode = aRange->GetStartParent();
|
|
nsINode* endNode = aRange->GetEndParent();
|
|
if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// baseOffset is the flattened offset of each content node.
|
|
int32_t baseOffset = 0;
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
|
|
nsresult rv = iter->Init(aRange);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
for (; !iter->IsDone(); iter->Next()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
if (!node->IsContent()) {
|
|
continue;
|
|
}
|
|
nsIContent* content = node->AsContent();
|
|
|
|
if (content->IsNodeOfType(nsINode::eTEXT)) {
|
|
int32_t startOffset = content != startNode ? 0 : aRange->StartOffset();
|
|
int32_t endOffset = content != endNode ?
|
|
content->TextLength() : aRange->EndOffset();
|
|
AppendFontRanges(aFontRanges, content, baseOffset,
|
|
startOffset, endOffset, aLineBreakType);
|
|
baseOffset += GetTextLengthInRange(content, startOffset, endOffset,
|
|
aLineBreakType);
|
|
} else if (ShouldBreakLineBefore(content, mRootContent)) {
|
|
if (aFontRanges.IsEmpty()) {
|
|
MOZ_ASSERT(baseOffset == 0);
|
|
FontRange* fontRange = AppendFontRange(aFontRanges, baseOffset);
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
|
if (frame) {
|
|
const nsFont& font = frame->GetParent()->StyleFont()->mFont;
|
|
const FontFamilyList& fontList = font.fontlist;
|
|
const FontFamilyName& fontName = fontList.IsEmpty() ?
|
|
FontFamilyName(fontList.GetDefaultFontType()) :
|
|
fontList.GetFontlist()[0];
|
|
fontName.AppendToString(fontRange->mFontName, false);
|
|
fontRange->mFontSize =
|
|
frame->PresContext()->AppUnitsToDevPixels(font.size);
|
|
}
|
|
}
|
|
baseOffset += GetBRLength(aLineBreakType);
|
|
}
|
|
}
|
|
|
|
aLength = baseOffset;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::ExpandToClusterBoundary(nsIContent* aContent,
|
|
bool aForward,
|
|
uint32_t* aXPOffset)
|
|
{
|
|
// XXX This method assumes that the frame boundaries must be cluster
|
|
// boundaries. It's false, but no problem now, maybe.
|
|
if (!aContent->IsNodeOfType(nsINode::eTEXT) ||
|
|
*aXPOffset == 0 || *aXPOffset == aContent->TextLength()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_ASSERTION(*aXPOffset <= aContent->TextLength(),
|
|
"offset is out of range.");
|
|
|
|
RefPtr<nsFrameSelection> fs = mPresShell->FrameSelection();
|
|
int32_t offsetInFrame;
|
|
CaretAssociationHint hint =
|
|
aForward ? CARET_ASSOCIATE_BEFORE : CARET_ASSOCIATE_AFTER;
|
|
nsIFrame* frame = fs->GetFrameForNodeOffset(aContent, int32_t(*aXPOffset),
|
|
hint, &offsetInFrame);
|
|
if (!frame) {
|
|
// This content doesn't have any frames, we only can check surrogate pair...
|
|
const nsTextFragment* text = aContent->GetText();
|
|
NS_ENSURE_TRUE(text, NS_ERROR_FAILURE);
|
|
if (NS_IS_LOW_SURROGATE(text->CharAt(*aXPOffset)) &&
|
|
NS_IS_HIGH_SURROGATE(text->CharAt(*aXPOffset - 1))) {
|
|
*aXPOffset += aForward ? 1 : -1;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
int32_t startOffset, endOffset;
|
|
nsresult rv = frame->GetOffsets(startOffset, endOffset);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (*aXPOffset == static_cast<uint32_t>(startOffset) ||
|
|
*aXPOffset == static_cast<uint32_t>(endOffset)) {
|
|
return NS_OK;
|
|
}
|
|
if (frame->GetType() != nsGkAtoms::textFrame) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
|
|
int32_t newOffsetInFrame = *aXPOffset - startOffset;
|
|
newOffsetInFrame += aForward ? -1 : 1;
|
|
textFrame->PeekOffsetCharacter(aForward, &newOffsetInFrame);
|
|
*aXPOffset = startOffset + newOffsetInFrame;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::SetRangeFromFlatTextOffset(nsRange* aRange,
|
|
uint32_t aOffset,
|
|
uint32_t aLength,
|
|
LineBreakType aLineBreakType,
|
|
bool aExpandToClusterBoundaries,
|
|
uint32_t* aNewOffset,
|
|
nsIContent** aLastTextNode)
|
|
{
|
|
if (aNewOffset) {
|
|
*aNewOffset = aOffset;
|
|
}
|
|
if (aLastTextNode) {
|
|
*aLastTextNode = nullptr;
|
|
}
|
|
|
|
// Special case like <br contenteditable>
|
|
if (!mRootContent->HasChildren()) {
|
|
nsresult rv = aRange->SetStart(mRootContent, 0);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
rv = aRange->SetEnd(mRootContent, 0);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
|
|
nsresult rv = iter->Init(mRootContent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
uint32_t offset = 0;
|
|
uint32_t endOffset = aOffset + aLength;
|
|
bool startSet = false;
|
|
for (; !iter->IsDone(); iter->Next()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
// FYI: mRootContent shouldn't cause any text. So, we can skip it simply.
|
|
if (node == mRootContent || !node->IsContent()) {
|
|
continue;
|
|
}
|
|
nsIContent* content = node->AsContent();
|
|
|
|
if (aLastTextNode && content->IsNodeOfType(nsINode::eTEXT)) {
|
|
NS_IF_RELEASE(*aLastTextNode);
|
|
NS_ADDREF(*aLastTextNode = content);
|
|
}
|
|
|
|
uint32_t textLength =
|
|
content->IsNodeOfType(nsINode::eTEXT) ?
|
|
GetTextLength(content, aLineBreakType) :
|
|
(ShouldBreakLineBefore(content, mRootContent) ?
|
|
GetBRLength(aLineBreakType) : 0);
|
|
if (!textLength) {
|
|
continue;
|
|
}
|
|
|
|
// When the start offset is in between accumulated offset and the last
|
|
// offset of the node, the node is the start node of the range.
|
|
if (!startSet && aOffset <= offset + textLength) {
|
|
nsINode* startNode = nullptr;
|
|
int32_t startNodeOffset = -1;
|
|
if (content->IsNodeOfType(nsINode::eTEXT)) {
|
|
// Rule #1.1: [textNode or text[Node or textNode[
|
|
uint32_t xpOffset = aOffset - offset;
|
|
if (aLineBreakType == LINE_BREAK_TYPE_NATIVE) {
|
|
xpOffset = ConvertToXPOffset(content, xpOffset);
|
|
}
|
|
|
|
if (aExpandToClusterBoundaries) {
|
|
uint32_t oldXPOffset = xpOffset;
|
|
rv = ExpandToClusterBoundary(content, false, &xpOffset);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (aNewOffset) {
|
|
// This is correct since a cluster shouldn't include line break.
|
|
*aNewOffset -= (oldXPOffset - xpOffset);
|
|
}
|
|
}
|
|
startNode = content;
|
|
startNodeOffset = static_cast<int32_t>(xpOffset);
|
|
} else if (aOffset < offset + textLength) {
|
|
// Rule #1.2 [<element>
|
|
startNode = content->GetParent();
|
|
if (NS_WARN_IF(!startNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
startNodeOffset = startNode->IndexOf(content);
|
|
if (NS_WARN_IF(startNodeOffset == -1)) {
|
|
// The content is being removed from the parent!
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
} else if (!content->HasChildren()) {
|
|
// Rule #1.3: <element/>[
|
|
startNode = content->GetParent();
|
|
if (NS_WARN_IF(!startNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
startNodeOffset = startNode->IndexOf(content) + 1;
|
|
if (NS_WARN_IF(startNodeOffset == 0)) {
|
|
// The content is being removed from the parent!
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
} else {
|
|
// Rule #1.4: <element>[
|
|
startNode = content;
|
|
startNodeOffset = 0;
|
|
}
|
|
NS_ASSERTION(startNode, "startNode must not be nullptr");
|
|
NS_ASSERTION(startNodeOffset >= 0,
|
|
"startNodeOffset must not be negative");
|
|
rv = aRange->SetStart(startNode, startNodeOffset);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
startSet = true;
|
|
|
|
if (!aLength) {
|
|
rv = aRange->SetEnd(startNode, startNodeOffset);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
// When the end offset is in the content, the node is the end node of the
|
|
// range.
|
|
if (endOffset <= offset + textLength) {
|
|
MOZ_ASSERT(startSet,
|
|
"The start of the range should've been set already");
|
|
if (content->IsNodeOfType(nsINode::eTEXT)) {
|
|
// Rule #2.1: ]textNode or text]Node or textNode]
|
|
uint32_t xpOffset = endOffset - offset;
|
|
if (aLineBreakType == LINE_BREAK_TYPE_NATIVE) {
|
|
uint32_t xpOffsetCurrent = ConvertToXPOffset(content, xpOffset);
|
|
if (xpOffset && GetBRLength(aLineBreakType) > 1) {
|
|
MOZ_ASSERT(GetBRLength(aLineBreakType) == 2);
|
|
uint32_t xpOffsetPre = ConvertToXPOffset(content, xpOffset - 1);
|
|
// If previous character's XP offset is same as current character's,
|
|
// it means that the end offset is between \r and \n. So, the
|
|
// range end should be after the \n.
|
|
if (xpOffsetPre == xpOffsetCurrent) {
|
|
xpOffset = xpOffsetCurrent + 1;
|
|
} else {
|
|
xpOffset = xpOffsetCurrent;
|
|
}
|
|
}
|
|
}
|
|
if (aExpandToClusterBoundaries) {
|
|
rv = ExpandToClusterBoundary(content, true, &xpOffset);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
NS_ASSERTION(xpOffset <= INT32_MAX,
|
|
"The end node offset is too large");
|
|
rv = aRange->SetEnd(content, static_cast<int32_t>(xpOffset));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (endOffset == offset) {
|
|
// Rule #2.2: ]<element>
|
|
// NOTE: Please don't crash on release builds because it must be
|
|
// overreaction but we shouldn't allow this bug when some
|
|
// automated tests find this.
|
|
MOZ_ASSERT(false, "This case should've already been handled at "
|
|
"the last node which caused some text");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (content->HasChildren() &&
|
|
ShouldBreakLineBefore(content, mRootContent)) {
|
|
// Rule #2.3: </element>]
|
|
rv = aRange->SetEnd(content, 0);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
// Rule #2.4: <element/>]
|
|
nsINode* endNode = content->GetParent();
|
|
if (NS_WARN_IF(!endNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
int32_t indexInParent = endNode->IndexOf(content);
|
|
if (NS_WARN_IF(indexInParent == -1)) {
|
|
// The content is being removed from the parent!
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
rv = aRange->SetEnd(endNode, indexInParent + 1);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
offset += textLength;
|
|
}
|
|
|
|
if (!startSet) {
|
|
MOZ_ASSERT(!mRootContent->IsNodeOfType(nsINode::eTEXT));
|
|
if (!offset) {
|
|
// Rule #1.5: <root>[</root>
|
|
// When there are no nodes causing text, the start of the DOM range
|
|
// should be start of the root node since clicking on such editor (e.g.,
|
|
// <div contenteditable><span></span></div>) sets caret to the start of
|
|
// the editor (i.e., before <span> in the example).
|
|
rv = aRange->SetStart(mRootContent, 0);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (!aLength) {
|
|
rv = aRange->SetEnd(mRootContent, 0);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
} else {
|
|
// Rule #1.5: [</root>
|
|
rv = aRange->SetStart(mRootContent,
|
|
static_cast<int32_t>(mRootContent->GetChildCount()));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
if (aNewOffset) {
|
|
*aNewOffset = offset;
|
|
}
|
|
}
|
|
// Rule #2.5: ]</root>
|
|
rv = aRange->SetEnd(mRootContent,
|
|
static_cast<int32_t>(mRootContent->GetChildCount()));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
/* static */ LineBreakType
|
|
ContentEventHandler::GetLineBreakType(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
return GetLineBreakType(aEvent->mUseNativeLineBreak);
|
|
}
|
|
|
|
/* static */ LineBreakType
|
|
ContentEventHandler::GetLineBreakType(WidgetSelectionEvent* aEvent)
|
|
{
|
|
return GetLineBreakType(aEvent->mUseNativeLineBreak);
|
|
}
|
|
|
|
/* static */ LineBreakType
|
|
ContentEventHandler::GetLineBreakType(bool aUseNativeLineBreak)
|
|
{
|
|
return aUseNativeLineBreak ?
|
|
LINE_BREAK_TYPE_NATIVE : LINE_BREAK_TYPE_XP;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::HandleQueryContentEvent(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
switch (aEvent->mMessage) {
|
|
case eQuerySelectedText:
|
|
return OnQuerySelectedText(aEvent);
|
|
case eQueryTextContent:
|
|
return OnQueryTextContent(aEvent);
|
|
case eQueryCaretRect:
|
|
return OnQueryCaretRect(aEvent);
|
|
case eQueryTextRect:
|
|
return OnQueryTextRect(aEvent);
|
|
case eQueryTextRectArray:
|
|
return OnQueryTextRectArray(aEvent);
|
|
case eQueryEditorRect:
|
|
return OnQueryEditorRect(aEvent);
|
|
case eQueryContentState:
|
|
return OnQueryContentState(aEvent);
|
|
case eQuerySelectionAsTransferable:
|
|
return OnQuerySelectionAsTransferable(aEvent);
|
|
case eQueryCharacterAtPoint:
|
|
return OnQueryCharacterAtPoint(aEvent);
|
|
case eQueryDOMWidgetHittest:
|
|
return OnQueryDOMWidgetHittest(aEvent);
|
|
default:
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
// Similar to nsFrameSelection::GetFrameForNodeOffset,
|
|
// but this is more flexible for OnQueryTextRect to use
|
|
static nsresult GetFrameForTextRect(nsINode* aNode,
|
|
int32_t aNodeOffset,
|
|
bool aHint,
|
|
nsIFrame** aReturnFrame)
|
|
{
|
|
NS_ENSURE_TRUE(aNode && aNode->IsNodeOfType(nsINode::eCONTENT),
|
|
NS_ERROR_UNEXPECTED);
|
|
nsIContent* content = static_cast<nsIContent*>(aNode);
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
|
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
|
|
int32_t childNodeOffset = 0;
|
|
return frame->GetChildFrameContainingOffset(aNodeOffset, aHint,
|
|
&childNodeOffset, aReturnFrame);
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQuerySelectedText(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
if (!mFirstSelectedRange) {
|
|
MOZ_ASSERT(aEvent->mInput.mSelectionType != SelectionType::eNormal);
|
|
MOZ_ASSERT(aEvent->mReply.mOffset == WidgetQueryContentEvent::NOT_FOUND);
|
|
MOZ_ASSERT(aEvent->mReply.mString.IsEmpty());
|
|
MOZ_ASSERT(!aEvent->mReply.mHasSelection);
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsINode* const startNode = mFirstSelectedRange->GetStartParent();
|
|
nsINode* const endNode = mFirstSelectedRange->GetEndParent();
|
|
|
|
// Make sure the selection is within the root content range.
|
|
if (!nsContentUtils::ContentIsDescendantOf(startNode, mRootContent) ||
|
|
!nsContentUtils::ContentIsDescendantOf(endNode, mRootContent)) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_ASSERTION(aEvent->mReply.mString.IsEmpty(),
|
|
"The reply string must be empty");
|
|
|
|
LineBreakType lineBreakType = GetLineBreakType(aEvent);
|
|
rv = GetStartOffset(mFirstSelectedRange,
|
|
&aEvent->mReply.mOffset, lineBreakType);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsINode> anchorNode, focusNode;
|
|
int32_t anchorOffset = 0, focusOffset = 0;
|
|
if (mSelection->RangeCount()) {
|
|
// If there is only one selection range, the anchor/focus node and offset
|
|
// are the information of the range. Therefore, we have the direction
|
|
// information.
|
|
if (mSelection->RangeCount() == 1) {
|
|
anchorNode = mSelection->GetAnchorNode();
|
|
focusNode = mSelection->GetFocusNode();
|
|
if (NS_WARN_IF(!anchorNode) || NS_WARN_IF(!focusNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
anchorOffset = static_cast<int32_t>(mSelection->AnchorOffset());
|
|
focusOffset = static_cast<int32_t>(mSelection->FocusOffset());
|
|
if (NS_WARN_IF(anchorOffset < 0) || NS_WARN_IF(focusOffset < 0)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
int16_t compare = nsContentUtils::ComparePoints(anchorNode, anchorOffset,
|
|
focusNode, focusOffset);
|
|
aEvent->mReply.mReversed = compare > 0;
|
|
}
|
|
// However, if there are 2 or more selection ranges, we have no information
|
|
// of that.
|
|
else {
|
|
aEvent->mReply.mReversed = false;
|
|
}
|
|
|
|
if (!mFirstSelectedRange->Collapsed()) {
|
|
rv = GenerateFlatTextContent(mFirstSelectedRange, aEvent->mReply.mString,
|
|
lineBreakType);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
aEvent->mReply.mString.Truncate();
|
|
}
|
|
} else {
|
|
NS_ASSERTION(mFirstSelectedRange->Collapsed(),
|
|
"When mSelection doesn't have selection, mFirstSelectedRange must be "
|
|
"collapsed");
|
|
anchorNode = focusNode = mFirstSelectedRange->GetStartParent();
|
|
if (NS_WARN_IF(!anchorNode)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
anchorOffset = focusOffset =
|
|
static_cast<int32_t>(mFirstSelectedRange->StartOffset());
|
|
if (NS_WARN_IF(anchorOffset < 0)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
aEvent->mReply.mReversed = false;
|
|
aEvent->mReply.mString.Truncate();
|
|
}
|
|
|
|
|
|
nsIFrame* frame = nullptr;
|
|
rv = GetFrameForTextRect(focusNode, focusOffset, true, &frame);
|
|
if (NS_SUCCEEDED(rv) && frame) {
|
|
aEvent->mReply.mWritingMode = frame->GetWritingMode();
|
|
} else {
|
|
aEvent->mReply.mWritingMode = WritingMode();
|
|
}
|
|
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryTextContent(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
NS_ASSERTION(aEvent->mReply.mString.IsEmpty(),
|
|
"The reply string must be empty");
|
|
|
|
LineBreakType lineBreakType = GetLineBreakType(aEvent);
|
|
|
|
RefPtr<nsRange> range = new nsRange(mRootContent);
|
|
rv = SetRangeFromFlatTextOffset(range, aEvent->mInput.mOffset,
|
|
aEvent->mInput.mLength, lineBreakType, false,
|
|
&aEvent->mReply.mOffset);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = GenerateFlatTextContent(range, aEvent->mReply.mString, lineBreakType);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (aEvent->mWithFontRanges) {
|
|
uint32_t fontRangeLength;
|
|
rv = GenerateFlatFontRanges(range, aEvent->mReply.mFontRanges,
|
|
fontRangeLength, lineBreakType);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
MOZ_ASSERT(fontRangeLength == aEvent->mReply.mString.Length(),
|
|
"Font ranges doesn't match the string");
|
|
}
|
|
|
|
aEvent->mSucceeded = true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
ContentEventHandler::EnsureNonEmptyRect(nsRect& aRect) const
|
|
{
|
|
// See the comment in ContentEventHandler.h why this doesn't set them to
|
|
// one device pixel.
|
|
aRect.height = std::max(1, aRect.height);
|
|
aRect.width = std::max(1, aRect.width);
|
|
}
|
|
|
|
void
|
|
ContentEventHandler::EnsureNonEmptyRect(LayoutDeviceIntRect& aRect) const
|
|
{
|
|
aRect.height = std::max(1, aRect.height);
|
|
aRect.width = std::max(1, aRect.width);
|
|
}
|
|
|
|
ContentEventHandler::NodePosition
|
|
ContentEventHandler::GetNodePositionHavingFlatText(
|
|
const NodePosition& aNodePosition)
|
|
{
|
|
return GetNodePositionHavingFlatText(aNodePosition.mNode,
|
|
aNodePosition.mOffset);
|
|
}
|
|
|
|
ContentEventHandler::NodePosition
|
|
ContentEventHandler::GetNodePositionHavingFlatText(nsINode* aNode,
|
|
int32_t aNodeOffset)
|
|
{
|
|
if (aNode->IsNodeOfType(nsINode::eTEXT)) {
|
|
return NodePosition(aNode, aNodeOffset);
|
|
}
|
|
|
|
int32_t childCount = static_cast<int32_t>(aNode->GetChildCount());
|
|
|
|
// If it's a empty element node, returns itself.
|
|
if (!childCount) {
|
|
MOZ_ASSERT(!aNodeOffset || aNodeOffset == 1);
|
|
return NodePosition(aNode, aNodeOffset);
|
|
}
|
|
|
|
// If there is a node at given position, return the start of it.
|
|
if (aNodeOffset < childCount) {
|
|
return NodePosition(aNode->GetChildAt(aNodeOffset), 0);
|
|
}
|
|
|
|
// If the offset represents "after" the node, we need to return the last
|
|
// child of it. For example, if a range is |<p>[<br>]</p>|, then, the
|
|
// end point is {<p>, 1}. In such case, callers need the <br> node.
|
|
if (aNodeOffset == childCount) {
|
|
NodePosition result;
|
|
result.mNode = aNode->GetChildAt(childCount - 1);
|
|
result.mOffset = result.mNode->IsNodeOfType(nsINode::eTEXT) ?
|
|
static_cast<int32_t>(result.mNode->AsContent()->TextLength()) : 1;
|
|
}
|
|
|
|
NS_WARNING("aNodeOffset is invalid value");
|
|
return NodePosition();
|
|
}
|
|
|
|
ContentEventHandler::FrameAndNodeOffset
|
|
ContentEventHandler::GetFirstFrameInRangeForTextRect(nsRange* aRange)
|
|
{
|
|
NodePosition nodePosition;
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
|
|
for (iter->Init(aRange); !iter->IsDone(); iter->Next()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
|
|
if (!node->IsContent()) {
|
|
continue;
|
|
}
|
|
|
|
if (node->IsNodeOfType(nsINode::eTEXT)) {
|
|
// If the range starts at the end of a text node, we need to find
|
|
// next node which causes text.
|
|
int32_t offsetInNode =
|
|
node == aRange->GetStartParent() ? aRange->StartOffset() : 0;
|
|
if (static_cast<uint32_t>(offsetInNode) < node->Length()) {
|
|
nodePosition.mNode = node;
|
|
nodePosition.mOffset = offsetInNode;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// If the element node causes a line break before it, it's the first
|
|
// node causing text.
|
|
if (ShouldBreakLineBefore(node->AsContent(), mRootContent) ||
|
|
IsMozBR(node->AsContent())) {
|
|
nodePosition.mNode = node;
|
|
nodePosition.mOffset = 0;
|
|
}
|
|
}
|
|
|
|
if (!nodePosition.IsValid()) {
|
|
return FrameAndNodeOffset();
|
|
}
|
|
|
|
nsIFrame* firstFrame = nullptr;
|
|
GetFrameForTextRect(nodePosition.mNode, nodePosition.mOffset,
|
|
true, &firstFrame);
|
|
return FrameAndNodeOffset(firstFrame, nodePosition.mOffset);
|
|
}
|
|
|
|
ContentEventHandler::FrameAndNodeOffset
|
|
ContentEventHandler::GetLastFrameInRangeForTextRect(nsRange* aRange)
|
|
{
|
|
NodePosition nodePosition;
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
|
|
iter->Init(aRange);
|
|
|
|
nsINode* endNode = aRange->GetEndParent();
|
|
uint32_t endOffset = static_cast<uint32_t>(aRange->EndOffset());
|
|
// If the end point is start of a text node or specified by its parent and
|
|
// index, the node shouldn't be included into the range. For example,
|
|
// with this case, |<p>abc[<br>]def</p>|, the range ends at 3rd children of
|
|
// <p> (see the range creation rules, "2.4. Cases: <element/>]"). This causes
|
|
// following frames:
|
|
// +----+-----+
|
|
// | abc|[<br>|
|
|
// +----+-----+
|
|
// +----+
|
|
// |]def|
|
|
// +----+
|
|
// So, if this method includes the 2nd text frame's rect to its result, the
|
|
// caller will return too tall rect which includes 2 lines in this case isn't
|
|
// expected by native IME (e.g., popup of IME will be positioned at bottom
|
|
// of "d" instead of right-bottom of "c"). Therefore, this method shouldn't
|
|
// include the last frame when its content isn't really in aRange.
|
|
nsINode* nextNodeOfRangeEnd = nullptr;
|
|
if (endNode->IsNodeOfType(nsINode::eTEXT)) {
|
|
// Don't set nextNodeOfRangeEnd to the start node of aRange because if
|
|
// endNode is same as start node of the range, the text node shouldn't be
|
|
// next of range end even if the offset is 0. This could occur with empty
|
|
// text node.
|
|
if (!endOffset && aRange->GetStartParent() != endNode) {
|
|
nextNodeOfRangeEnd = endNode;
|
|
}
|
|
} else if (endOffset < endNode->GetChildCount()) {
|
|
nextNodeOfRangeEnd = endNode->GetChildAt(endOffset);
|
|
}
|
|
|
|
for (iter->Last(); !iter->IsDone(); iter->Prev()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
|
|
if (!node->IsContent() || node == nextNodeOfRangeEnd) {
|
|
continue;
|
|
}
|
|
|
|
if (node->IsNodeOfType(nsINode::eTEXT)) {
|
|
nodePosition.mNode = node;
|
|
if (node == aRange->GetEndParent()) {
|
|
nodePosition.mOffset = aRange->EndOffset();
|
|
} else {
|
|
nodePosition.mOffset = node->Length();
|
|
}
|
|
// If the text node is empty or the last node of the range but the index
|
|
// is 0, we should store current position but continue looking for
|
|
// previous node (If there are no nodes before it, we should use current
|
|
// node position for returning its frame).
|
|
if (!nodePosition.mOffset) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (ShouldBreakLineBefore(node->AsContent(), mRootContent) ||
|
|
IsMozBR(node->AsContent())) {
|
|
nodePosition.mNode = node;
|
|
nodePosition.mOffset = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!nodePosition.IsValid()) {
|
|
return FrameAndNodeOffset();
|
|
}
|
|
|
|
nsIFrame* lastFrame = nullptr;
|
|
GetFrameForTextRect(nodePosition.mNode, nodePosition.mOffset,
|
|
true, &lastFrame);
|
|
if (!lastFrame) {
|
|
return FrameAndNodeOffset();
|
|
}
|
|
|
|
// If the last frame is a text frame, we need to check if the range actually
|
|
// includes at least one character in the range. Therefore, if it's not a
|
|
// text frame, we need to do nothing anymore.
|
|
if (lastFrame->GetType() != nsGkAtoms::textFrame) {
|
|
return FrameAndNodeOffset(lastFrame, nodePosition.mOffset);
|
|
}
|
|
|
|
int32_t start, end;
|
|
if (NS_WARN_IF(NS_FAILED(lastFrame->GetOffsets(start, end)))) {
|
|
return FrameAndNodeOffset();
|
|
}
|
|
|
|
// If the start offset in the node is same as the computed offset in the
|
|
// node and it's not 0, the frame shouldn't be added to the text rect. So,
|
|
// this should return previous text frame and its last offset if there is
|
|
// at least one text frame.
|
|
if (nodePosition.mOffset && nodePosition.mOffset == start) {
|
|
GetFrameForTextRect(nodePosition.mNode, --nodePosition.mOffset,
|
|
true, &lastFrame);
|
|
if (NS_WARN_IF(!lastFrame)) {
|
|
return FrameAndNodeOffset();
|
|
}
|
|
}
|
|
|
|
return FrameAndNodeOffset(lastFrame, nodePosition.mOffset);
|
|
}
|
|
|
|
ContentEventHandler::FrameRelativeRect
|
|
ContentEventHandler::GetLineBreakerRectBefore(nsIFrame* aFrame)
|
|
{
|
|
// Note that this method should be called only with an element's frame whose
|
|
// open tag causes a line break or moz-<br> for computing empty last line's
|
|
// rect.
|
|
MOZ_ASSERT(ShouldBreakLineBefore(aFrame->GetContent(), mRootContent) ||
|
|
IsMozBR(aFrame->GetContent()));
|
|
|
|
nsIFrame* frameForFontMetrics = aFrame;
|
|
|
|
// If it's not a <br> frame, this method computes the line breaker's rect
|
|
// outside the frame. Therefore, we need to compute with parent frame's
|
|
// font metrics in such case.
|
|
if (aFrame->GetType() != nsGkAtoms::brFrame && aFrame->GetParent()) {
|
|
frameForFontMetrics = aFrame->GetParent();
|
|
}
|
|
|
|
// Note that <br> element's rect is decided with line-height but we need
|
|
// a rect only with font height. Additionally, <br> frame's width and
|
|
// height are 0 in quirks mode if it's not an empty line. So, we cannot
|
|
// use frame rect information even if it's a <br> frame.
|
|
|
|
FrameRelativeRect result(aFrame);
|
|
|
|
RefPtr<nsFontMetrics> fontMetrics =
|
|
nsLayoutUtils::GetInflatedFontMetricsForFrame(frameForFontMetrics);
|
|
if (NS_WARN_IF(!fontMetrics)) {
|
|
return FrameRelativeRect();
|
|
}
|
|
|
|
const WritingMode kWritingMode = frameForFontMetrics->GetWritingMode();
|
|
nscoord baseline = aFrame->GetCaretBaseline();
|
|
if (kWritingMode.IsVertical()) {
|
|
if (kWritingMode.IsLineInverted()) {
|
|
result.mRect.x = baseline - fontMetrics->MaxDescent();
|
|
} else {
|
|
result.mRect.x = baseline - fontMetrics->MaxAscent();
|
|
}
|
|
result.mRect.width = fontMetrics->MaxHeight();
|
|
} else {
|
|
result.mRect.y = baseline - fontMetrics->MaxAscent();
|
|
result.mRect.height = fontMetrics->MaxHeight();
|
|
}
|
|
|
|
// If aFrame isn't a <br> frame, caret should be at outside of it because
|
|
// the line break is before its open tag. For example, case of
|
|
// |<div><p>some text</p></div>|, caret is before <p> element and in <div>
|
|
// element, the caret should be left of top-left corner of <p> element like:
|
|
//
|
|
// +-<div>------------------- <div>'s border box
|
|
// | I +-<p>----------------- <p>'s border box
|
|
// | I |
|
|
// | I |
|
|
// | |
|
|
// ^- caret
|
|
//
|
|
// However, this is a hack for unusual scenario. This hack shouldn't be
|
|
// used as far as possible.
|
|
if (aFrame->GetType() != nsGkAtoms::brFrame) {
|
|
if (kWritingMode.IsVertical()) {
|
|
if (kWritingMode.IsLineInverted()) {
|
|
// above of top-left corner of aFrame.
|
|
result.mRect.x = 0;
|
|
} else {
|
|
// above of top-right corner of aFrame.
|
|
result.mRect.x = aFrame->GetRect().XMost() - result.mRect.width;
|
|
}
|
|
result.mRect.y = -mPresContext->AppUnitsPerDevPixel();
|
|
} else {
|
|
// left of top-left corner of aFrame.
|
|
result.mRect.x = -mPresContext->AppUnitsPerDevPixel();
|
|
result.mRect.y = 0;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ContentEventHandler::FrameRelativeRect
|
|
ContentEventHandler::GuessLineBreakerRectAfter(nsIContent* aTextContent)
|
|
{
|
|
// aTextContent should be a text node.
|
|
MOZ_ASSERT(aTextContent->IsNodeOfType(nsINode::eTEXT));
|
|
|
|
FrameRelativeRect result;
|
|
int32_t length = static_cast<int32_t>(aTextContent->Length());
|
|
if (NS_WARN_IF(length < 0)) {
|
|
return result;
|
|
}
|
|
// Get the last nsTextFrame which is caused by aTextContent. Note that
|
|
// a text node can cause multiple text frames, e.g., the text is too long
|
|
// and wrapped by its parent block or the text has line breakers and its
|
|
// white-space property respects the line breakers (e.g., |pre|).
|
|
nsIFrame* lastTextFrame = nullptr;
|
|
nsresult rv = GetFrameForTextRect(aTextContent, length, true, &lastTextFrame);
|
|
if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!lastTextFrame)) {
|
|
return result;
|
|
}
|
|
const nsRect kLastTextFrameRect = lastTextFrame->GetRect();
|
|
if (lastTextFrame->GetWritingMode().IsVertical()) {
|
|
// Below of the last text frame.
|
|
result.mRect.SetRect(0, kLastTextFrameRect.height,
|
|
kLastTextFrameRect.width, 0);
|
|
} else {
|
|
// Right of the last text frame (not bidi-aware).
|
|
result.mRect.SetRect(kLastTextFrameRect.width, 0,
|
|
0, kLastTextFrameRect.height);
|
|
}
|
|
result.mBaseFrame = lastTextFrame;
|
|
return result;
|
|
}
|
|
|
|
ContentEventHandler::FrameRelativeRect
|
|
ContentEventHandler::GuessFirstCaretRectIn(nsIFrame* aFrame)
|
|
{
|
|
const WritingMode kWritingMode = aFrame->GetWritingMode();
|
|
|
|
// Computes the font height, but if it's not available, we should use
|
|
// default font size of Firefox. The default font size in default settings
|
|
// is 16px.
|
|
RefPtr<nsFontMetrics> fontMetrics =
|
|
nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
|
|
const nscoord kMaxHeight =
|
|
fontMetrics ? fontMetrics->MaxHeight() :
|
|
16 * mPresContext->AppUnitsPerDevPixel();
|
|
|
|
nsRect caretRect;
|
|
const nsRect kContentRect = aFrame->GetContentRect() - aFrame->GetPosition();
|
|
caretRect.y = kContentRect.y;
|
|
if (!kWritingMode.IsVertical()) {
|
|
if (kWritingMode.IsBidiLTR()) {
|
|
caretRect.x = kContentRect.x;
|
|
} else {
|
|
// Move 1px left for the space of caret itself.
|
|
const nscoord kOnePixel = mPresContext->AppUnitsPerDevPixel();
|
|
caretRect.x = kContentRect.XMost() - kOnePixel;
|
|
}
|
|
caretRect.height = kMaxHeight;
|
|
// However, don't add kOnePixel here because it may cause 2px width at
|
|
// aligning the edge to device pixels.
|
|
caretRect.width = 1;
|
|
} else {
|
|
if (kWritingMode.IsVerticalLR()) {
|
|
caretRect.x = kContentRect.x;
|
|
} else {
|
|
caretRect.x = kContentRect.XMost() - kMaxHeight;
|
|
}
|
|
caretRect.width = kMaxHeight;
|
|
// Don't add app units for a device pixel because it may cause 2px height
|
|
// at aligning the edge to device pixels.
|
|
caretRect.height = 1;
|
|
}
|
|
return FrameRelativeRect(caretRect, aFrame);
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryTextRectArray(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
LineBreakType lineBreakType = GetLineBreakType(aEvent);
|
|
const uint32_t kBRLength = GetBRLength(lineBreakType);
|
|
|
|
RefPtr<nsRange> range = new nsRange(mRootContent);
|
|
|
|
bool isVertical = false;
|
|
LayoutDeviceIntRect rect;
|
|
uint32_t offset = aEvent->mInput.mOffset;
|
|
const uint32_t kEndOffset = offset + aEvent->mInput.mLength;
|
|
bool wasLineBreaker = false;
|
|
// lastCharRect stores the last charRect value (see below for the detail of
|
|
// charRect).
|
|
nsRect lastCharRect;
|
|
// lastFrame is base frame of lastCharRect.
|
|
nsIFrame* lastFrame = nullptr;
|
|
while (offset < kEndOffset) {
|
|
nsCOMPtr<nsIContent> lastTextContent;
|
|
rv = SetRangeFromFlatTextOffset(range, offset, 1, lineBreakType, true,
|
|
nullptr, getter_AddRefs(lastTextContent));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// If the range is collapsed, offset has already reached the end of the
|
|
// contents.
|
|
if (range->Collapsed()) {
|
|
break;
|
|
}
|
|
|
|
// Get the first frame which causes some text after the offset.
|
|
FrameAndNodeOffset firstFrame = GetFirstFrameInRangeForTextRect(range);
|
|
|
|
// If GetFirstFrameInRangeForTextRect() does not return valid frame, that
|
|
// means that there are no visible frames having text or the offset reached
|
|
// the end of contents.
|
|
if (!firstFrame.IsValid()) {
|
|
nsAutoString allText;
|
|
rv = GenerateFlatTextContent(mRootContent, allText, lineBreakType);
|
|
// If the offset doesn't reach the end of contents yet but there is no
|
|
// frames for the node, that means that current offset's node is hidden
|
|
// by CSS or something. Ideally, we should handle it with the last
|
|
// visible text node's last character's rect, but it's not usual cases
|
|
// in actual web services. Therefore, currently, we should make this
|
|
// case fail.
|
|
if (NS_WARN_IF(NS_FAILED(rv)) || offset < allText.Length()) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
// Otherwise, we should append caret rect at the end of the contents
|
|
// later.
|
|
break;
|
|
}
|
|
|
|
nsIContent* firstContent = firstFrame.mFrame->GetContent();
|
|
if (NS_WARN_IF(!firstContent)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
bool startsBetweenLineBreaker = false;
|
|
nsAutoString chars;
|
|
// XXX not bidi-aware this class...
|
|
isVertical = firstFrame->GetWritingMode().IsVertical();
|
|
|
|
nsIFrame* baseFrame = firstFrame;
|
|
// charRect should have each character rect or line breaker rect relative
|
|
// to the base frame.
|
|
AutoTArray<nsRect, 16> charRects;
|
|
|
|
// If the first frame is a text frame, the result should be computed with
|
|
// the frame's API.
|
|
if (firstFrame->GetType() == nsGkAtoms::textFrame) {
|
|
rv = firstFrame->GetCharacterRectsInRange(firstFrame.mOffsetInNode,
|
|
kEndOffset - offset, charRects);
|
|
if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(charRects.IsEmpty())) {
|
|
return rv;
|
|
}
|
|
// Assign the characters whose rects are computed by the call of
|
|
// nsTextFrame::GetCharacterRectsInRange().
|
|
AppendSubString(chars, firstContent, firstFrame.mOffsetInNode,
|
|
charRects.Length());
|
|
if (NS_WARN_IF(chars.Length() != charRects.Length())) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
if (kBRLength > 1 && chars[0] == '\n' &&
|
|
offset == aEvent->mInput.mOffset && offset) {
|
|
// If start of range starting from previous offset of query range is
|
|
// same as the start of query range, the query range starts from
|
|
// between a line breaker (i.e., the range starts between "\r" and
|
|
// "\n").
|
|
RefPtr<nsRange> rangeToPrevOffset = new nsRange(mRootContent);
|
|
rv = SetRangeFromFlatTextOffset(rangeToPrevOffset,
|
|
aEvent->mInput.mOffset - 1, 1,
|
|
lineBreakType, true, nullptr);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
startsBetweenLineBreaker =
|
|
range->GetStartParent() == rangeToPrevOffset->GetStartParent() &&
|
|
range->StartOffset() == rangeToPrevOffset->StartOffset();
|
|
}
|
|
}
|
|
// Other contents should cause a line breaker rect before it.
|
|
// Note that moz-<br> element does not cause any text, however,
|
|
// it represents empty line at the last of current block. Therefore,
|
|
// we need to compute its rect too.
|
|
else if (ShouldBreakLineBefore(firstContent, mRootContent) ||
|
|
IsMozBR(firstContent)) {
|
|
nsRect brRect;
|
|
// If the frame is not a <br> frame, we need to compute the caret rect
|
|
// with last character's rect before firstContent if there is.
|
|
// For example, if caret is after "c" of |<p>abc</p><p>def</p>|, IME may
|
|
// query a line breaker's rect after "c". Then, if we compute it only
|
|
// with the 2nd <p>'s block frame, the result will be:
|
|
// +-<p>--------------------------------+
|
|
// |abc |
|
|
// +------------------------------------+
|
|
//
|
|
// I+-<p>--------------------------------+
|
|
// |def |
|
|
// +------------------------------------+
|
|
// However, users expect popup windows of IME should be positioned at
|
|
// right-bottom of "c" like this:
|
|
// +-<p>--------------------------------+
|
|
// |abcI |
|
|
// +------------------------------------+
|
|
//
|
|
// +-<p>--------------------------------+
|
|
// |def |
|
|
// +------------------------------------+
|
|
// Therefore, if the first frame isn't a <br> frame and there is a text
|
|
// node before the first node in the queried range, we should compute the
|
|
// first rect with the previous character's rect.
|
|
// If we already compute a character's rect in the queried range, we can
|
|
// compute it with the cached last character's rect. (However, don't
|
|
// use this path if it's a <br> frame because trusting <br> frame's rect
|
|
// is better than guessing the rect from the previous character.)
|
|
if (firstFrame->GetType() != nsGkAtoms::brFrame &&
|
|
aEvent->mInput.mOffset != offset) {
|
|
baseFrame = lastFrame;
|
|
brRect = lastCharRect;
|
|
if (!wasLineBreaker) {
|
|
if (isVertical) {
|
|
// Right of the last character.
|
|
brRect.y = brRect.YMost() + 1;
|
|
brRect.height = 1;
|
|
} else {
|
|
// Under the last character.
|
|
brRect.x = brRect.XMost() + 1;
|
|
brRect.width = 1;
|
|
}
|
|
}
|
|
}
|
|
// If it's not a <br> frame and it's the first character rect at the
|
|
// queried range, we need to the previous character of the start of
|
|
// the queried range if there is a text node.
|
|
else if (firstFrame->GetType() != nsGkAtoms::brFrame && lastTextContent) {
|
|
FrameRelativeRect brRectRelativeToLastTextFrame =
|
|
GuessLineBreakerRectAfter(lastTextContent);
|
|
if (NS_WARN_IF(!brRectRelativeToLastTextFrame.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
// Look for the last text frame for lastTextContent.
|
|
nsIFrame* primaryFrame = lastTextContent->GetPrimaryFrame();
|
|
if (NS_WARN_IF(!primaryFrame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
baseFrame = primaryFrame->LastContinuation();
|
|
if (NS_WARN_IF(!baseFrame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
brRect = brRectRelativeToLastTextFrame.RectRelativeTo(baseFrame);
|
|
}
|
|
// Otherwise, we need to compute the line breaker's rect only with the
|
|
// first frame's rect. But this may be unexpected. For example,
|
|
// |<div contenteditable>[<p>]abc</p></div>|. In this case, caret is
|
|
// before "a", therefore, users expect the rect left of "a". However,
|
|
// we don't have enough information about the next character here and
|
|
// this isn't usual case (e.g., IME typically tries to query the rect
|
|
// of "a" or caret rect for computing its popup position). Therefore,
|
|
// we shouldn't do more complicated hack here unless we'll get some bug
|
|
// reports actually.
|
|
else {
|
|
FrameRelativeRect relativeBRRect = GetLineBreakerRectBefore(firstFrame);
|
|
brRect = relativeBRRect.RectRelativeTo(firstFrame);
|
|
}
|
|
charRects.AppendElement(brRect);
|
|
chars.AssignLiteral("\n");
|
|
if (kBRLength > 1 && offset == aEvent->mInput.mOffset && offset) {
|
|
// If the first frame for the previous offset of the query range and
|
|
// the first frame for the start of query range are same, that means
|
|
// the start offset is between the first line breaker (i.e., the range
|
|
// starts between "\r" and "\n").
|
|
rv = SetRangeFromFlatTextOffset(range, aEvent->mInput.mOffset - 1, 1,
|
|
lineBreakType, true, nullptr);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
FrameAndNodeOffset frameForPrevious =
|
|
GetFirstFrameInRangeForTextRect(range);
|
|
startsBetweenLineBreaker = frameForPrevious.mFrame == firstFrame.mFrame;
|
|
}
|
|
} else {
|
|
NS_WARNING("The frame is neither a text frame nor a frame whose content "
|
|
"causes a line break");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
for (size_t i = 0; i < charRects.Length() && offset < kEndOffset; i++) {
|
|
nsRect charRect = charRects[i];
|
|
// Store lastCharRect before applying CSS transform because it may be
|
|
// used for computing a line breaker rect. Then, the computed line
|
|
// breaker rect will be applied CSS transform again. Therefore,
|
|
// the value of lastCharRect should be raw rect value relative to the
|
|
// base frame.
|
|
lastCharRect = charRect;
|
|
lastFrame = baseFrame;
|
|
rv = ConvertToRootRelativeOffset(baseFrame, charRect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rect = LayoutDeviceIntRect::FromUnknownRect(
|
|
charRect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel()));
|
|
// Returning empty rect may cause native IME confused, let's make sure to
|
|
// return non-empty rect.
|
|
EnsureNonEmptyRect(rect);
|
|
|
|
aEvent->mReply.mRectArray.AppendElement(rect);
|
|
offset++;
|
|
|
|
// If it's not a line breaker or the line breaker length is same as
|
|
// XP line breaker's, we need to do nothing for current character.
|
|
wasLineBreaker = chars[i] == '\n';
|
|
if (!wasLineBreaker || kBRLength == 1) {
|
|
continue;
|
|
}
|
|
|
|
MOZ_ASSERT(kBRLength == 2);
|
|
|
|
// If it's already reached the end of query range, we don't need to do
|
|
// anymore.
|
|
if (offset == kEndOffset) {
|
|
break;
|
|
}
|
|
|
|
// If the query range starts from between a line breaker, i.e., it starts
|
|
// between "\r" and "\n", the appended rect was for the "\n". Therefore,
|
|
// we don't need to append same rect anymore for current "\r\n".
|
|
if (startsBetweenLineBreaker) {
|
|
continue;
|
|
}
|
|
|
|
// The appended rect was for "\r" of "\r\n". Therefore, we need to
|
|
// append same rect for "\n" too because querying rect of "\r" and "\n"
|
|
// should return same rect. E.g., IME may query previous character's
|
|
// rect of first character of a line.
|
|
aEvent->mReply.mRectArray.AppendElement(rect);
|
|
offset++;
|
|
}
|
|
}
|
|
|
|
// If the query range is longer than actual content length, we should append
|
|
// caret rect at the end of the content as the last character rect because
|
|
// native IME may want to query character rect at the end of contents for
|
|
// deciding the position of a popup window (e.g., suggest window for next
|
|
// word). Note that when this method hasn't appended character rects, it
|
|
// means that the offset is too large or the query range is collapsed.
|
|
if (offset < kEndOffset || aEvent->mReply.mRectArray.IsEmpty()) {
|
|
// If we've already retrieved some character rects before current offset,
|
|
// we can guess the last rect from the last character's rect unless it's a
|
|
// line breaker. (If it's a line breaker, the caret rect is in next line.)
|
|
if (!aEvent->mReply.mRectArray.IsEmpty() && !wasLineBreaker) {
|
|
rect = aEvent->mReply.mRectArray.LastElement();
|
|
if (isVertical) {
|
|
rect.y = rect.YMost() + 1;
|
|
rect.height = 1;
|
|
MOZ_ASSERT(rect.width);
|
|
} else {
|
|
rect.x = rect.XMost() + 1;
|
|
rect.width = 1;
|
|
MOZ_ASSERT(rect.height);
|
|
}
|
|
aEvent->mReply.mRectArray.AppendElement(rect);
|
|
} else {
|
|
// Note that don't use eQueryCaretRect here because if caret is at the
|
|
// end of the content, it returns actual caret rect instead of computing
|
|
// the rect itself. It means that the result depends on caret position.
|
|
// So, we shouldn't use it for consistency result in automated tests.
|
|
WidgetQueryContentEvent queryTextRect(eQueryTextRect, *aEvent);
|
|
WidgetQueryContentEvent::Options options(*aEvent);
|
|
queryTextRect.InitForQueryTextRect(offset, 1, options);
|
|
rv = OnQueryTextRect(&queryTextRect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (NS_WARN_IF(!queryTextRect.mSucceeded)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
MOZ_ASSERT(!queryTextRect.mReply.mRect.IsEmpty());
|
|
if (queryTextRect.mReply.mWritingMode.IsVertical()) {
|
|
queryTextRect.mReply.mRect.height = 1;
|
|
} else {
|
|
queryTextRect.mReply.mRect.width = 1;
|
|
}
|
|
aEvent->mReply.mRectArray.AppendElement(queryTextRect.mReply.mRect);
|
|
}
|
|
}
|
|
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryTextRect(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
// If mLength is 0 (this may be caused by bug of native IME), we should
|
|
// redirect this event to OnQueryCaretRect().
|
|
if (!aEvent->mInput.mLength) {
|
|
return OnQueryCaretRect(aEvent);
|
|
}
|
|
|
|
LineBreakType lineBreakType = GetLineBreakType(aEvent);
|
|
RefPtr<nsRange> range = new nsRange(mRootContent);
|
|
nsCOMPtr<nsIContent> lastTextContent;
|
|
rv = SetRangeFromFlatTextOffset(range, aEvent->mInput.mOffset,
|
|
aEvent->mInput.mLength, lineBreakType, true,
|
|
&aEvent->mReply.mOffset,
|
|
getter_AddRefs(lastTextContent));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = GenerateFlatTextContent(range, aEvent->mReply.mString, lineBreakType);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// used to iterate over all contents and their frames
|
|
nsCOMPtr<nsIContentIterator> iter = NS_NewContentIterator();
|
|
iter->Init(range);
|
|
|
|
// Get the first frame which causes some text after the offset.
|
|
FrameAndNodeOffset firstFrame = GetFirstFrameInRangeForTextRect(range);
|
|
|
|
// If GetFirstFrameInRangeForTextRect() does not return valid frame, that
|
|
// means that there are no visible frames having text or the offset reached
|
|
// the end of contents.
|
|
if (!firstFrame.IsValid()) {
|
|
nsAutoString allText;
|
|
rv = GenerateFlatTextContent(mRootContent, allText, lineBreakType);
|
|
// If the offset doesn't reach the end of contents but there is no frames
|
|
// for the node, that means that current offset's node is hidden by CSS or
|
|
// something. Ideally, we should handle it with the last visible text
|
|
// node's last character's rect, but it's not usual cases in actual web
|
|
// services. Therefore, currently, we should make this case fail.
|
|
if (NS_WARN_IF(NS_FAILED(rv)) ||
|
|
static_cast<uint32_t>(aEvent->mInput.mOffset) < allText.Length()) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Look for the last frame which should be included text rects.
|
|
ErrorResult erv;
|
|
range->SelectNodeContents(*mRootContent, erv);
|
|
if (NS_WARN_IF(erv.Failed())) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
nsRect rect;
|
|
FrameAndNodeOffset lastFrame = GetLastFrameInRangeForTextRect(range);
|
|
// If there is at least one frame which can be used for computing a rect
|
|
// for a character or a line breaker, we should use it for guessing the
|
|
// caret rect at the end of the contents.
|
|
if (lastFrame) {
|
|
if (NS_WARN_IF(!lastFrame->GetContent())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
FrameRelativeRect relativeRect;
|
|
// If there is a <br> frame at the end, it represents an empty line at
|
|
// the end with moz-<br> or content <br> in a block level element.
|
|
if (lastFrame->GetType() == nsGkAtoms::brFrame) {
|
|
relativeRect = GetLineBreakerRectBefore(lastFrame);
|
|
}
|
|
// If there is a text frame at the end, use its information.
|
|
else if (lastFrame->GetType() == nsGkAtoms::textFrame) {
|
|
relativeRect = GuessLineBreakerRectAfter(lastFrame->GetContent());
|
|
}
|
|
// If there is an empty frame which is neither a text frame nor a <br>
|
|
// frame at the end, guess caret rect in it.
|
|
else {
|
|
relativeRect = GuessFirstCaretRectIn(lastFrame);
|
|
}
|
|
if (NS_WARN_IF(!relativeRect.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
rect = relativeRect.RectRelativeTo(lastFrame);
|
|
rv = ConvertToRootRelativeOffset(lastFrame, rect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
aEvent->mReply.mWritingMode = lastFrame->GetWritingMode();
|
|
}
|
|
// Otherwise, if there are no contents in mRootContent, guess caret rect in
|
|
// its frame (with its font height and content box).
|
|
else {
|
|
nsIFrame* rootContentFrame = mRootContent->GetPrimaryFrame();
|
|
if (NS_WARN_IF(!rootContentFrame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
FrameRelativeRect relativeRect = GuessFirstCaretRectIn(rootContentFrame);
|
|
if (NS_WARN_IF(!relativeRect.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
rect = relativeRect.RectRelativeTo(rootContentFrame);
|
|
rv = ConvertToRootRelativeOffset(rootContentFrame, rect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
aEvent->mReply.mWritingMode = rootContentFrame->GetWritingMode();
|
|
}
|
|
aEvent->mReply.mRect = LayoutDeviceIntRect::FromUnknownRect(
|
|
rect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel()));
|
|
EnsureNonEmptyRect(aEvent->mReply.mRect);
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsRect rect, frameRect;
|
|
nsPoint ptOffset;
|
|
|
|
// If the first frame is a text frame, the result should be computed with
|
|
// the frame's rect but not including the rect before start point of the
|
|
// queried range.
|
|
if (firstFrame->GetType() == nsGkAtoms::textFrame) {
|
|
rect.SetRect(nsPoint(0, 0), firstFrame->GetRect().Size());
|
|
rv = ConvertToRootRelativeOffset(firstFrame, rect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
frameRect = rect;
|
|
// Exclude the rect before start point of the queried range.
|
|
firstFrame->GetPointFromOffset(firstFrame.mOffsetInNode, &ptOffset);
|
|
if (firstFrame->GetWritingMode().IsVertical()) {
|
|
rect.y += ptOffset.y;
|
|
rect.height -= ptOffset.y;
|
|
} else {
|
|
rect.x += ptOffset.x;
|
|
rect.width -= ptOffset.x;
|
|
}
|
|
}
|
|
// If first frame causes a line breaker but it's not a <br> frame, we cannot
|
|
// compute proper rect only with the frame because typically caret is at
|
|
// right of the last character of it. For example, if caret is after "c" of
|
|
// |<p>abc</p><p>def</p>|, IME may query a line breaker's rect after "c".
|
|
// Then, if we compute it only with the 2nd <p>'s block frame, the result
|
|
// will be:
|
|
// +-<p>--------------------------------+
|
|
// |abc |
|
|
// +------------------------------------+
|
|
//
|
|
// I+-<p>--------------------------------+
|
|
// |def |
|
|
// +------------------------------------+
|
|
// However, users expect popup windows of IME should be positioned at
|
|
// right-bottom of "c" like this:
|
|
// +-<p>--------------------------------+
|
|
// |abcI |
|
|
// +------------------------------------+
|
|
//
|
|
// +-<p>--------------------------------+
|
|
// |def |
|
|
// +------------------------------------+
|
|
// Therefore, if the first frame isn't a <br> frame and there is a text
|
|
// node before the first node in the queried range, we should compute the
|
|
// first rect with the previous character's rect.
|
|
else if (firstFrame->GetType() != nsGkAtoms::brFrame && lastTextContent) {
|
|
FrameRelativeRect brRectAfterLastChar =
|
|
GuessLineBreakerRectAfter(lastTextContent);
|
|
if (NS_WARN_IF(!brRectAfterLastChar.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
rect = brRectAfterLastChar.mRect;
|
|
rv = ConvertToRootRelativeOffset(brRectAfterLastChar.mBaseFrame, rect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
frameRect = rect;
|
|
}
|
|
// Otherwise, we need to compute the line breaker's rect only with the
|
|
// first frame's rect. But this may be unexpected. For example,
|
|
// |<div contenteditable>[<p>]abc</p></div>|. In this case, caret is before
|
|
// "a", therefore, users expect the rect left of "a". However, we don't
|
|
// have enough information about the next character here and this isn't
|
|
// usual case (e.g., IME typically tries to query the rect of "a" or caret
|
|
// rect for computing its popup position). Therefore, we shouldn't do
|
|
// more complicated hack here unless we'll get some bug reports actually.
|
|
else {
|
|
FrameRelativeRect relativeRect = GetLineBreakerRectBefore(firstFrame);
|
|
if (NS_WARN_IF(!relativeRect.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
rect = relativeRect.RectRelativeTo(firstFrame);
|
|
rv = ConvertToRootRelativeOffset(firstFrame, rect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
frameRect = rect;
|
|
}
|
|
// UnionRect() requires non-empty rect. So, let's make sure to get non-emtpy
|
|
// rect from the first frame.
|
|
EnsureNonEmptyRect(rect);
|
|
|
|
// Get the last frame which causes some text in the range.
|
|
FrameAndNodeOffset lastFrame = GetLastFrameInRangeForTextRect(range);
|
|
if (NS_WARN_IF(!lastFrame.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// iterate over all covered frames
|
|
for (nsIFrame* frame = firstFrame; frame != lastFrame;) {
|
|
frame = frame->GetNextContinuation();
|
|
if (!frame) {
|
|
do {
|
|
iter->Next();
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (!node) {
|
|
break;
|
|
}
|
|
if (!node->IsNodeOfType(nsINode::eCONTENT)) {
|
|
continue;
|
|
}
|
|
nsIFrame* primaryFrame = node->AsContent()->GetPrimaryFrame();
|
|
// The node may be hidden by CSS.
|
|
if (!primaryFrame) {
|
|
continue;
|
|
}
|
|
// We should take only text frame's rect and br frame's rect. We can
|
|
// always use frame rect of text frame and GetLineBreakerRectBefore()
|
|
// can return exactly correct rect only for <br> frame for now. On the
|
|
// other hand, GetLineBreakRectBefore() returns guessed caret rect for
|
|
// the other frames. We shouldn't include such odd rect to the result.
|
|
if (primaryFrame->GetType() == nsGkAtoms::textFrame ||
|
|
primaryFrame->GetType() == nsGkAtoms::brFrame) {
|
|
frame = primaryFrame;
|
|
}
|
|
} while (!frame && !iter->IsDone());
|
|
if (!frame) {
|
|
break;
|
|
}
|
|
}
|
|
if (frame->GetType() == nsGkAtoms::textFrame) {
|
|
frameRect.SetRect(nsPoint(0, 0), frame->GetRect().Size());
|
|
} else {
|
|
MOZ_ASSERT(frame->GetType() == nsGkAtoms::brFrame);
|
|
FrameRelativeRect relativeRect = GetLineBreakerRectBefore(frame);
|
|
if (NS_WARN_IF(!relativeRect.IsValid())) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
frameRect = relativeRect.RectRelativeTo(frame);
|
|
}
|
|
rv = ConvertToRootRelativeOffset(frame, frameRect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
// UnionRect() requires non-empty rect. So, let's make sure to get
|
|
// non-emtpy rect from the frame.
|
|
EnsureNonEmptyRect(frameRect);
|
|
if (frame != lastFrame) {
|
|
// not last frame, so just add rect to previous result
|
|
rect.UnionRect(rect, frameRect);
|
|
}
|
|
}
|
|
|
|
// Get the ending frame rect.
|
|
// FYI: If first frame and last frame are same, frameRect is already set
|
|
// to the rect excluding the text before the query range.
|
|
if (firstFrame.mFrame != lastFrame.mFrame) {
|
|
frameRect.SetRect(nsPoint(0, 0), lastFrame->GetRect().Size());
|
|
rv = ConvertToRootRelativeOffset(lastFrame, frameRect);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
// Shrink the last frame for cutting off the text after the query range.
|
|
if (lastFrame->GetType() == nsGkAtoms::textFrame) {
|
|
lastFrame->GetPointFromOffset(lastFrame.mOffsetInNode, &ptOffset);
|
|
if (lastFrame->GetWritingMode().IsVertical()) {
|
|
frameRect.height -= lastFrame->GetRect().height - ptOffset.y;
|
|
} else {
|
|
frameRect.width -= lastFrame->GetRect().width - ptOffset.x;
|
|
}
|
|
// UnionRect() requires non-empty rect. So, let's make sure to get
|
|
// non-empty rect from the last frame.
|
|
EnsureNonEmptyRect(frameRect);
|
|
|
|
if (firstFrame.mFrame == lastFrame.mFrame) {
|
|
rect.IntersectRect(rect, frameRect);
|
|
} else {
|
|
rect.UnionRect(rect, frameRect);
|
|
}
|
|
}
|
|
|
|
aEvent->mReply.mRect = LayoutDeviceIntRect::FromUnknownRect(
|
|
rect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel()));
|
|
// Returning empty rect may cause native IME confused, let's make sure to
|
|
// return non-empty rect.
|
|
EnsureNonEmptyRect(aEvent->mReply.mRect);
|
|
aEvent->mReply.mWritingMode = lastFrame->GetWritingMode();
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryEditorRect(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
nsIContent* focusedContent = GetFocusedContent();
|
|
rv = QueryContentRect(IsPlugin(focusedContent) ?
|
|
focusedContent : mRootContent.get(), aEvent);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryCaretRect(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
// When the selection is collapsed and the queried offset is current caret
|
|
// position, we should return the "real" caret rect.
|
|
if (mSelection->IsCollapsed()) {
|
|
nsRect caretRect;
|
|
nsIFrame* caretFrame = nsCaret::GetGeometry(mSelection, &caretRect);
|
|
if (caretFrame) {
|
|
uint32_t offset;
|
|
rv = GetStartOffset(mFirstSelectedRange,
|
|
&offset, GetLineBreakType(aEvent));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (offset == aEvent->mInput.mOffset) {
|
|
rv = ConvertToRootRelativeOffset(caretFrame, caretRect);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
nscoord appUnitsPerDevPixel =
|
|
caretFrame->PresContext()->AppUnitsPerDevPixel();
|
|
aEvent->mReply.mRect = LayoutDeviceIntRect::FromUnknownRect(
|
|
caretRect.ToOutsidePixels(appUnitsPerDevPixel));
|
|
// Returning empty rect may cause native IME confused, let's make sure
|
|
// to return non-empty rect.
|
|
EnsureNonEmptyRect(aEvent->mReply.mRect);
|
|
aEvent->mReply.mWritingMode = caretFrame->GetWritingMode();
|
|
aEvent->mReply.mOffset = aEvent->mInput.mOffset;
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Otherwise, we should guess the caret rect from the character's rect.
|
|
WidgetQueryContentEvent queryTextRectEvent(eQueryTextRect, *aEvent);
|
|
WidgetQueryContentEvent::Options options(*aEvent);
|
|
queryTextRectEvent.InitForQueryTextRect(aEvent->mInput.mOffset, 1, options);
|
|
rv = OnQueryTextRect(&queryTextRectEvent);
|
|
if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!queryTextRectEvent.mSucceeded)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
queryTextRectEvent.mReply.mString.Truncate();
|
|
aEvent->mReply = queryTextRectEvent.mReply;
|
|
if (aEvent->GetWritingMode().IsVertical()) {
|
|
aEvent->mReply.mRect.height = 1;
|
|
} else {
|
|
aEvent->mReply.mRect.width = 1;
|
|
}
|
|
// Returning empty rect may cause native IME confused, let's make sure to
|
|
// return non-empty rect.
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryContentState(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQuerySelectionAsTransferable(
|
|
WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
if (!aEvent->mReply.mHasSelection) {
|
|
aEvent->mSucceeded = true;
|
|
aEvent->mReply.mTransferable = nullptr;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> doc = mPresShell->GetDocument();
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
rv = nsCopySupport::GetTransferableForSelection(
|
|
mSelection, doc, getter_AddRefs(aEvent->mReply.mTransferable));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryCharacterAtPoint(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
nsresult rv = Init(aEvent);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
aEvent->mReply.mOffset = aEvent->mReply.mTentativeCaretOffset =
|
|
WidgetQueryContentEvent::NOT_FOUND;
|
|
|
|
nsIFrame* rootFrame = mPresShell->GetRootFrame();
|
|
NS_ENSURE_TRUE(rootFrame, NS_ERROR_FAILURE);
|
|
nsIWidget* rootWidget = rootFrame->GetNearestWidget();
|
|
NS_ENSURE_TRUE(rootWidget, NS_ERROR_FAILURE);
|
|
|
|
// The root frame's widget might be different, e.g., the event was fired on
|
|
// a popup but the rootFrame is the document root.
|
|
if (rootWidget != aEvent->mWidget) {
|
|
NS_PRECONDITION(aEvent->mWidget, "The event must have the widget");
|
|
nsView* view = nsView::GetViewFor(aEvent->mWidget);
|
|
NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
|
|
rootFrame = view->GetFrame();
|
|
NS_ENSURE_TRUE(rootFrame, NS_ERROR_FAILURE);
|
|
rootWidget = rootFrame->GetNearestWidget();
|
|
NS_ENSURE_TRUE(rootWidget, NS_ERROR_FAILURE);
|
|
}
|
|
|
|
WidgetQueryContentEvent eventOnRoot(true, eQueryCharacterAtPoint,
|
|
rootWidget);
|
|
eventOnRoot.mUseNativeLineBreak = aEvent->mUseNativeLineBreak;
|
|
eventOnRoot.mRefPoint = aEvent->mRefPoint;
|
|
if (rootWidget != aEvent->mWidget) {
|
|
eventOnRoot.mRefPoint += aEvent->mWidget->WidgetToScreenOffset() -
|
|
rootWidget->WidgetToScreenOffset();
|
|
}
|
|
nsPoint ptInRoot =
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(&eventOnRoot, rootFrame);
|
|
|
|
nsIFrame* targetFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, ptInRoot);
|
|
if (!targetFrame || !targetFrame->GetContent() ||
|
|
!nsContentUtils::ContentIsDescendantOf(targetFrame->GetContent(),
|
|
mRootContent)) {
|
|
// There is no character at the point.
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
nsPoint ptInTarget = ptInRoot + rootFrame->GetOffsetToCrossDoc(targetFrame);
|
|
int32_t rootAPD = rootFrame->PresContext()->AppUnitsPerDevPixel();
|
|
int32_t targetAPD = targetFrame->PresContext()->AppUnitsPerDevPixel();
|
|
ptInTarget = ptInTarget.ScaleToOtherAppUnits(rootAPD, targetAPD);
|
|
|
|
nsIFrame::ContentOffsets tentativeCaretOffsets =
|
|
targetFrame->GetContentOffsetsFromPoint(ptInTarget);
|
|
if (!tentativeCaretOffsets.content ||
|
|
!nsContentUtils::ContentIsDescendantOf(tentativeCaretOffsets.content,
|
|
mRootContent)) {
|
|
// There is no character nor tentative caret point at the point.
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
rv = GetFlatTextLengthInRange(NodePosition(mRootContent, 0),
|
|
NodePosition(tentativeCaretOffsets),
|
|
mRootContent,
|
|
&aEvent->mReply.mTentativeCaretOffset,
|
|
GetLineBreakType(aEvent));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (targetFrame->GetType() != nsGkAtoms::textFrame) {
|
|
// There is no character at the point but there is tentative caret point.
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
MOZ_ASSERT(
|
|
aEvent->mReply.mTentativeCaretOffset != WidgetQueryContentEvent::NOT_FOUND,
|
|
"The point is inside a character bounding box. Why tentative caret point "
|
|
"hasn't been found?");
|
|
|
|
nsTextFrame* textframe = static_cast<nsTextFrame*>(targetFrame);
|
|
nsIFrame::ContentOffsets contentOffsets =
|
|
textframe->GetCharacterOffsetAtFramePoint(ptInTarget);
|
|
NS_ENSURE_TRUE(contentOffsets.content, NS_ERROR_FAILURE);
|
|
uint32_t offset;
|
|
rv = GetFlatTextLengthInRange(NodePosition(mRootContent, 0),
|
|
NodePosition(contentOffsets),
|
|
mRootContent, &offset,
|
|
GetLineBreakType(aEvent));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
WidgetQueryContentEvent textRect(true, eQueryTextRect, aEvent->mWidget);
|
|
WidgetQueryContentEvent::Options options(*aEvent);
|
|
textRect.InitForQueryTextRect(offset, 1, options);
|
|
rv = OnQueryTextRect(&textRect);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_TRUE(textRect.mSucceeded, NS_ERROR_FAILURE);
|
|
|
|
// currently, we don't need to get the actual text.
|
|
aEvent->mReply.mOffset = offset;
|
|
aEvent->mReply.mRect = textRect.mReply.mRect;
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnQueryDOMWidgetHittest(WidgetQueryContentEvent* aEvent)
|
|
{
|
|
NS_ASSERTION(aEvent, "aEvent must not be null");
|
|
|
|
nsresult rv = InitBasic();
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
aEvent->mSucceeded = false;
|
|
aEvent->mReply.mWidgetIsHit = false;
|
|
|
|
NS_ENSURE_TRUE(aEvent->mWidget, NS_ERROR_FAILURE);
|
|
|
|
nsIDocument* doc = mPresShell->GetDocument();
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
nsIFrame* docFrame = mPresShell->GetRootFrame();
|
|
NS_ENSURE_TRUE(docFrame, NS_ERROR_FAILURE);
|
|
|
|
LayoutDeviceIntPoint eventLoc =
|
|
aEvent->mRefPoint + aEvent->mWidget->WidgetToScreenOffset();
|
|
nsIntRect docFrameRect = docFrame->GetScreenRect(); // Returns CSS pixels
|
|
CSSIntPoint eventLocCSS(
|
|
mPresContext->DevPixelsToIntCSSPixels(eventLoc.x) - docFrameRect.x,
|
|
mPresContext->DevPixelsToIntCSSPixels(eventLoc.y) - docFrameRect.y);
|
|
|
|
Element* contentUnderMouse =
|
|
doc->ElementFromPointHelper(eventLocCSS.x, eventLocCSS.y, false, false);
|
|
if (contentUnderMouse) {
|
|
nsIWidget* targetWidget = nullptr;
|
|
nsIFrame* targetFrame = contentUnderMouse->GetPrimaryFrame();
|
|
nsIObjectFrame* pluginFrame = do_QueryFrame(targetFrame);
|
|
if (pluginFrame) {
|
|
targetWidget = pluginFrame->GetWidget();
|
|
} else if (targetFrame) {
|
|
targetWidget = targetFrame->GetNearestWidget();
|
|
}
|
|
if (aEvent->mWidget == targetWidget) {
|
|
aEvent->mReply.mWidgetIsHit = true;
|
|
}
|
|
}
|
|
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
/* static */ nsresult
|
|
ContentEventHandler::GetFlatTextLengthInRange(
|
|
const NodePosition& aStartPosition,
|
|
const NodePosition& aEndPosition,
|
|
nsIContent* aRootContent,
|
|
uint32_t* aLength,
|
|
LineBreakType aLineBreakType,
|
|
bool aIsRemovingNode /* = false */)
|
|
{
|
|
if (NS_WARN_IF(!aRootContent) || NS_WARN_IF(!aStartPosition.IsValid()) ||
|
|
NS_WARN_IF(!aEndPosition.IsValid()) || NS_WARN_IF(!aLength)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
if (aStartPosition == aEndPosition) {
|
|
*aLength = 0;
|
|
return NS_OK;
|
|
}
|
|
|
|
// Don't create nsContentIterator instance until it's really necessary since
|
|
// destroying without initializing causes unexpected NS_ASSERTION() call.
|
|
nsCOMPtr<nsIContentIterator> iter;
|
|
|
|
// Working with ContentIterator, we may need to adjust the end position for
|
|
// including it forcibly.
|
|
NodePosition endPosition(aEndPosition);
|
|
|
|
// This may be called for retrieving the text of removed nodes. Even in this
|
|
// case, the node thinks it's still in the tree because UnbindFromTree() will
|
|
// be called after here. However, the node was already removed from the
|
|
// array of children of its parent. So, be careful to handle this case.
|
|
if (aIsRemovingNode) {
|
|
DebugOnly<nsIContent*> parent = aStartPosition.mNode->GetParent();
|
|
MOZ_ASSERT(parent && parent->IndexOf(aStartPosition.mNode) == -1,
|
|
"At removing the node, the node shouldn't be in the array of children "
|
|
"of its parent");
|
|
MOZ_ASSERT(aStartPosition.mNode == endPosition.mNode,
|
|
"At removing the node, start and end node should be same");
|
|
MOZ_ASSERT(aStartPosition.mOffset == 0,
|
|
"When the node is being removed, the start offset should be 0");
|
|
MOZ_ASSERT(static_cast<uint32_t>(endPosition.mOffset) ==
|
|
endPosition.mNode->GetChildCount(),
|
|
"When the node is being removed, the end offset should be child count");
|
|
iter = NS_NewPreContentIterator();
|
|
nsresult rv = iter->Init(aStartPosition.mNode);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
RefPtr<nsRange> prev = new nsRange(aRootContent);
|
|
nsresult rv = aStartPosition.SetToRangeStart(prev);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// When the end position is immediately after non-root element's open tag,
|
|
// we need to include a line break caused by the open tag.
|
|
if (endPosition.mNode != aRootContent &&
|
|
endPosition.IsImmediatelyAfterOpenTag()) {
|
|
if (endPosition.mNode->HasChildren()) {
|
|
// When the end node has some children, move the end position to before
|
|
// the open tag of its first child.
|
|
nsINode* firstChild = endPosition.mNode->GetFirstChild();
|
|
if (NS_WARN_IF(!firstChild)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
endPosition = NodePositionBefore(firstChild, 0);
|
|
} else {
|
|
// When the end node is empty, move the end position after the node.
|
|
nsIContent* parentContent = endPosition.mNode->GetParent();
|
|
if (NS_WARN_IF(!parentContent)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
int32_t indexInParent = parentContent->IndexOf(endPosition.mNode);
|
|
if (NS_WARN_IF(indexInParent < 0)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
endPosition = NodePositionBefore(parentContent, indexInParent + 1);
|
|
}
|
|
}
|
|
|
|
if (endPosition.OffsetIsValid()) {
|
|
// Offset is within node's length; set end of range to that offset
|
|
rv = endPosition.SetToRangeEnd(prev);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
iter = NS_NewPreContentIterator();
|
|
rv = iter->Init(prev);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else if (endPosition.mNode != aRootContent) {
|
|
// Offset is past node's length; set end of range to end of node
|
|
rv = endPosition.SetToRangeEndAfter(prev);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
iter = NS_NewPreContentIterator();
|
|
rv = iter->Init(prev);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
// Offset is past the root node; set end of range to end of root node
|
|
iter = NS_NewPreContentIterator();
|
|
rv = iter->Init(aRootContent);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
|
|
*aLength = 0;
|
|
for (; !iter->IsDone(); iter->Next()) {
|
|
nsINode* node = iter->GetCurrentNode();
|
|
if (NS_WARN_IF(!node)) {
|
|
break;
|
|
}
|
|
if (!node->IsContent()) {
|
|
continue;
|
|
}
|
|
nsIContent* content = node->AsContent();
|
|
|
|
if (node->IsNodeOfType(nsINode::eTEXT)) {
|
|
// Note: our range always starts from offset 0
|
|
if (node == endPosition.mNode) {
|
|
*aLength += GetTextLength(content, aLineBreakType,
|
|
endPosition.mOffset);
|
|
} else {
|
|
*aLength += GetTextLength(content, aLineBreakType);
|
|
}
|
|
} else if (ShouldBreakLineBefore(content, aRootContent)) {
|
|
// If the start position is start of this node but doesn't include the
|
|
// open tag, don't append the line break length.
|
|
if (node == aStartPosition.mNode && !aStartPosition.IsBeforeOpenTag()) {
|
|
continue;
|
|
}
|
|
// If the end position is before the open tag, don't append the line
|
|
// break length.
|
|
if (node == endPosition.mNode && endPosition.IsBeforeOpenTag()) {
|
|
continue;
|
|
}
|
|
*aLength += GetBRLength(aLineBreakType);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::GetStartOffset(nsRange* aRange,
|
|
uint32_t* aOffset,
|
|
LineBreakType aLineBreakType)
|
|
{
|
|
MOZ_ASSERT(aRange);
|
|
return GetFlatTextLengthInRange(
|
|
NodePosition(mRootContent, 0),
|
|
NodePosition(aRange->GetStartParent(), aRange->StartOffset()),
|
|
mRootContent, aOffset, aLineBreakType);
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::AdjustCollapsedRangeMaybeIntoTextNode(nsRange* aRange)
|
|
{
|
|
MOZ_ASSERT(aRange);
|
|
MOZ_ASSERT(aRange->Collapsed());
|
|
|
|
if (!aRange || !aRange->Collapsed()) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
nsCOMPtr<nsINode> parentNode = aRange->GetStartParent();
|
|
int32_t offsetInParentNode = aRange->StartOffset();
|
|
if (NS_WARN_IF(!parentNode) || NS_WARN_IF(offsetInParentNode < 0)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
// If the node is text node, we don't need to modify aRange.
|
|
if (parentNode->IsNodeOfType(nsINode::eTEXT)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// If the parent is not a text node but it has a text node at the offset,
|
|
// we should adjust the range into the text node.
|
|
// NOTE: This is emulating similar situation of EditorBase.
|
|
nsINode* childNode = nullptr;
|
|
int32_t offsetInChildNode = -1;
|
|
if (!offsetInParentNode && parentNode->HasChildren()) {
|
|
// If the range is the start of the parent, adjusted the range to the
|
|
// start of the first child.
|
|
childNode = parentNode->GetFirstChild();
|
|
offsetInChildNode = 0;
|
|
} else if (static_cast<uint32_t>(offsetInParentNode) <
|
|
parentNode->GetChildCount()) {
|
|
// If the range is next to a child node, adjust the range to the end of
|
|
// the previous child.
|
|
childNode = parentNode->GetChildAt(offsetInParentNode - 1);
|
|
offsetInChildNode = childNode->Length();
|
|
}
|
|
|
|
// But if the found node isn't a text node, we cannot modify the range.
|
|
if (!childNode || !childNode->IsNodeOfType(nsINode::eTEXT) ||
|
|
NS_WARN_IF(offsetInChildNode < 0)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv = aRange->Set(childNode, offsetInChildNode,
|
|
childNode, offsetInChildNode);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::GetStartFrameAndOffset(const nsRange* aRange,
|
|
nsIFrame*& aFrame,
|
|
int32_t& aOffsetInFrame)
|
|
{
|
|
MOZ_ASSERT(aRange);
|
|
|
|
aFrame = nullptr;
|
|
aOffsetInFrame = -1;
|
|
|
|
nsINode* node = aRange->GetStartParent();
|
|
if (NS_WARN_IF(!node) ||
|
|
NS_WARN_IF(!node->IsNodeOfType(nsINode::eCONTENT))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
nsIContent* content = static_cast<nsIContent*>(node);
|
|
RefPtr<nsFrameSelection> fs = mPresShell->FrameSelection();
|
|
aFrame = fs->GetFrameForNodeOffset(content, aRange->StartOffset(),
|
|
fs->GetHint(), &aOffsetInFrame);
|
|
if (NS_WARN_IF(!aFrame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::ConvertToRootRelativeOffset(nsIFrame* aFrame,
|
|
nsRect& aRect)
|
|
{
|
|
NS_ASSERTION(aFrame, "aFrame must not be null");
|
|
|
|
nsPresContext* thisPC = aFrame->PresContext();
|
|
nsPresContext* rootPC = thisPC->GetRootPresContext();
|
|
if (NS_WARN_IF(!rootPC)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
nsIFrame* rootFrame = rootPC->PresShell()->GetRootFrame();
|
|
if (NS_WARN_IF(!rootFrame)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
aRect = nsLayoutUtils::TransformFrameRectToAncestor(aFrame, aRect, rootFrame);
|
|
|
|
// TransformFrameRectToAncestor returned the rect in the ancestor's appUnits,
|
|
// but we want it in aFrame's units (in case of different full-zoom factors),
|
|
// so convert back.
|
|
aRect = aRect.ScaleToOtherAppUnitsRoundOut(rootPC->AppUnitsPerDevPixel(),
|
|
thisPC->AppUnitsPerDevPixel());
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
static void AdjustRangeForSelection(nsIContent* aRoot,
|
|
nsINode** aNode,
|
|
int32_t* aNodeOffset)
|
|
{
|
|
nsINode* node = *aNode;
|
|
int32_t nodeOffset = *aNodeOffset;
|
|
if (aRoot == node || NS_WARN_IF(!node->GetParent()) ||
|
|
!node->IsNodeOfType(nsINode::eTEXT)) {
|
|
return;
|
|
}
|
|
|
|
// When the offset is at the end of the text node, set it to after the
|
|
// text node, to make sure the caret is drawn on a new line when the last
|
|
// character of the text node is '\n' in <textarea>.
|
|
int32_t textLength =
|
|
static_cast<int32_t>(static_cast<nsIContent*>(node)->TextLength());
|
|
MOZ_ASSERT(nodeOffset <= textLength, "Offset is past length of text node");
|
|
if (nodeOffset != textLength) {
|
|
return;
|
|
}
|
|
|
|
nsIContent* aRootParent = aRoot->GetParent();
|
|
if (NS_WARN_IF(!aRootParent)) {
|
|
return;
|
|
}
|
|
// If the root node is not an anonymous div of <textarea>, we don't need to
|
|
// do this hack. If you did this, ContentEventHandler couldn't distinguish
|
|
// if the range includes open tag of the next node in some cases, e.g.,
|
|
// textNode]<p></p> vs. textNode<p>]</p>
|
|
if (!aRootParent->IsHTMLElement(nsGkAtoms::textarea)) {
|
|
return;
|
|
}
|
|
|
|
*aNode = node->GetParent();
|
|
MOZ_ASSERT((*aNode)->IndexOf(node) != -1);
|
|
*aNodeOffset = (*aNode)->IndexOf(node) + 1;
|
|
}
|
|
|
|
nsresult
|
|
ContentEventHandler::OnSelectionEvent(WidgetSelectionEvent* aEvent)
|
|
{
|
|
aEvent->mSucceeded = false;
|
|
|
|
// Get selection to manipulate
|
|
// XXX why do we need to get them from ISM? This method should work fine
|
|
// without ISM.
|
|
nsCOMPtr<nsISelection> sel;
|
|
nsresult rv =
|
|
IMEStateManager::GetFocusSelectionAndRoot(getter_AddRefs(sel),
|
|
getter_AddRefs(mRootContent));
|
|
mSelection = sel ? sel->AsSelection() : nullptr;
|
|
if (rv != NS_ERROR_NOT_AVAILABLE) {
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
} else {
|
|
rv = Init(aEvent);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// Get range from offset and length
|
|
RefPtr<nsRange> range = new nsRange(mRootContent);
|
|
rv = SetRangeFromFlatTextOffset(range, aEvent->mOffset, aEvent->mLength,
|
|
GetLineBreakType(aEvent),
|
|
aEvent->mExpandToClusterBoundary);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsINode* startNode = range->GetStartParent();
|
|
nsINode* endNode = range->GetEndParent();
|
|
int32_t startNodeOffset = range->StartOffset();
|
|
int32_t endNodeOffset = range->EndOffset();
|
|
AdjustRangeForSelection(mRootContent, &startNode, &startNodeOffset);
|
|
AdjustRangeForSelection(mRootContent, &endNode, &endNodeOffset);
|
|
if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode) ||
|
|
NS_WARN_IF(startNodeOffset < 0) || NS_WARN_IF(endNodeOffset < 0)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
mSelection->StartBatchChanges();
|
|
|
|
// Clear selection first before setting
|
|
rv = mSelection->RemoveAllRanges();
|
|
// Need to call EndBatchChanges at the end even if call failed
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (aEvent->mReversed) {
|
|
rv = mSelection->Collapse(endNode, endNodeOffset);
|
|
} else {
|
|
rv = mSelection->Collapse(startNode, startNodeOffset);
|
|
}
|
|
if (NS_SUCCEEDED(rv) &&
|
|
(startNode != endNode || startNodeOffset != endNodeOffset)) {
|
|
if (aEvent->mReversed) {
|
|
rv = mSelection->Extend(startNode, startNodeOffset);
|
|
} else {
|
|
rv = mSelection->Extend(endNode, endNodeOffset);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pass the eSetSelection events reason along with the BatchChange-end
|
|
// selection change notifications.
|
|
mSelection->EndBatchChangesInternal(aEvent->mReason);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mSelection->ScrollIntoViewInternal(
|
|
nsISelectionController::SELECTION_FOCUS_REGION,
|
|
false, nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis());
|
|
aEvent->mSucceeded = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsRect
|
|
ContentEventHandler::FrameRelativeRect::RectRelativeTo(
|
|
nsIFrame* aDestFrame) const
|
|
{
|
|
if (!mBaseFrame || NS_WARN_IF(!aDestFrame)) {
|
|
return nsRect();
|
|
}
|
|
|
|
if (NS_WARN_IF(aDestFrame->PresContext() != mBaseFrame->PresContext())) {
|
|
return nsRect();
|
|
}
|
|
|
|
if (aDestFrame == mBaseFrame) {
|
|
return mRect;
|
|
}
|
|
|
|
nsIFrame* rootFrame = mBaseFrame->PresContext()->PresShell()->GetRootFrame();
|
|
nsRect baseFrameRectInRootFrame =
|
|
nsLayoutUtils::TransformFrameRectToAncestor(mBaseFrame, nsRect(),
|
|
rootFrame);
|
|
nsRect destFrameRectInRootFrame =
|
|
nsLayoutUtils::TransformFrameRectToAncestor(aDestFrame, nsRect(),
|
|
rootFrame);
|
|
nsPoint difference =
|
|
destFrameRectInRootFrame.TopLeft() - baseFrameRectInRootFrame.TopLeft();
|
|
return mRect - difference;
|
|
}
|
|
|
|
} // namespace mozilla
|