mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
94d9cb25a3
This removes the bulk of core/editing/*. The following files remain, because they might be useful yet: EditingBoundary.h FindOptions.h htmlediting.cpp htmlediting.h PlainTextRange.cpp PlainTextRange.h PositionWithAffinity.cpp PositionWithAffinity.h RenderedPosition.cpp RenderedPosition.h TextAffinity.h TextGranularity.h TextIterator.cpp TextIterator.h VisiblePosition.cpp VisiblePosition.h VisibleSelection.cpp VisibleSelection.h VisibleUnits.cpp VisibleUnits.h In addition to remove obviously editing-related stuff like "ApplyBlockElementCommand.cpp" and "InsertLineBreakCommand.cpp", this also removes the DOM side of selection, all the caret management and painting code, composition support (IME) including the relevant events, spelling checker support, and the undo stack. Outside the core/editing/* directory, I also deleted the EditorClient, SpellCheckerClient, and EmptyClients classes. The other changes outside of editing/ are mostly just about removing mentions of the selection or carets. I tried to leave the code for _painting_ selections and composition runs, though that code is mostly disconnected now.
238 lines
9.5 KiB
C++
238 lines
9.5 KiB
C++
/*
|
|
* Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef SKY_ENGINE_CORE_EDITING_HTMLEDITING_H_
|
|
#define SKY_ENGINE_CORE_EDITING_HTMLEDITING_H_
|
|
|
|
#include "sky/engine/core/dom/Position.h"
|
|
#include "sky/engine/core/editing/EditingBoundary.h"
|
|
#include "sky/engine/platform/text/TextDirection.h"
|
|
#include "sky/engine/wtf/Forward.h"
|
|
#include "sky/engine/wtf/unicode/CharacterNames.h"
|
|
|
|
namespace blink {
|
|
|
|
class Document;
|
|
class Element;
|
|
class ExceptionState;
|
|
class HTMLElement;
|
|
class Node;
|
|
class Position;
|
|
class PositionWithAffinity;
|
|
class Range;
|
|
class VisiblePosition;
|
|
|
|
|
|
// This file contains a set of helper functions used by the editing commands
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Node
|
|
// -------------------------------------------------------------------------
|
|
|
|
// Functions returning Node
|
|
|
|
ContainerNode* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
|
|
|
|
Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*),
|
|
EditingBoundaryCrossingRule = CannotCrossEditingBoundary, Node* stayWithin = 0);
|
|
Node* highestNodeToRemoveInPruning(Node*, Node* excludeNode = 0);
|
|
Element* lowestEditableAncestor(Node*);
|
|
|
|
Element* enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
|
|
Element* enclosingBlockFlowElement(Node&); // Deprecated, use enclosingBlock instead.
|
|
bool inSameContainingBlockFlowElement(Node*, Node*);
|
|
Element* enclosingAnchorElement(const Position&);
|
|
Element* enclosingElementWithTag(const Position&, const QualifiedName&);
|
|
Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
|
|
|
|
Element* isLastPositionBeforeTable(const VisiblePosition&);
|
|
Element* isFirstPositionAfterTable(const VisiblePosition&);
|
|
|
|
// offset functions on Node
|
|
|
|
int lastOffsetForEditing(const Node*);
|
|
int caretMinOffset(const Node*);
|
|
int caretMaxOffset(const Node*);
|
|
|
|
// boolean functions on Node
|
|
|
|
// FIXME: editingIgnoresContent, canHaveChildrenForEditing, and isAtomicNode
|
|
// should be renamed to reflect its usage.
|
|
|
|
// Returns true for nodes that either have no content, or have content that is ignored (skipped over) while editing.
|
|
// There are no VisiblePositions inside these nodes.
|
|
inline bool editingIgnoresContent(const Node* node)
|
|
{
|
|
return !node->canContainRangeEndPoint();
|
|
}
|
|
|
|
inline bool canHaveChildrenForEditing(const Node* node)
|
|
{
|
|
return !node->isTextNode() && node->canContainRangeEndPoint();
|
|
}
|
|
|
|
bool isAtomicNode(const Node*);
|
|
bool isBlock(const Node*);
|
|
bool isInline(const Node*);
|
|
bool isSpecialHTMLElement(const Node*);
|
|
bool isMailHTMLBlockquoteElement(const Node*);
|
|
bool isRenderedTableElement(const Node*);
|
|
bool isEmptyTableCell(const Node*);
|
|
bool isNodeRendered(const Node*);
|
|
bool isNodeVisiblyContainedWithin(Node&, const Range&);
|
|
bool isRenderedAsNonInlineTableImageOrHR(const Node*);
|
|
bool areIdenticalElements(const Node*, const Node*);
|
|
bool isBlockFlowElement(const Node&);
|
|
TextDirection directionOfEnclosingBlock(const Position&);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Position
|
|
// -------------------------------------------------------------------------
|
|
|
|
// Functions returning Position
|
|
|
|
Position nextCandidate(const Position&);
|
|
Position previousCandidate(const Position&);
|
|
|
|
Position nextVisuallyDistinctCandidate(const Position&);
|
|
Position previousVisuallyDistinctCandidate(const Position&);
|
|
|
|
Position positionBeforeContainingSpecialElement(const Position&, HTMLElement** containingSpecialElement = 0);
|
|
Position positionAfterContainingSpecialElement(const Position&, HTMLElement** containingSpecialElement = 0);
|
|
|
|
inline Position firstPositionInOrBeforeNode(Node* node)
|
|
{
|
|
if (!node)
|
|
return Position();
|
|
return editingIgnoresContent(node) ? positionBeforeNode(node) : firstPositionInNode(node);
|
|
}
|
|
|
|
inline Position lastPositionInOrAfterNode(Node* node)
|
|
{
|
|
if (!node)
|
|
return Position();
|
|
return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
|
|
}
|
|
|
|
Position lastEditablePositionBeforePositionInRoot(const Position&, Node*);
|
|
|
|
// comparision functions on Position
|
|
|
|
int comparePositions(const Position&, const Position&);
|
|
int comparePositions(const PositionWithAffinity&, const PositionWithAffinity&);
|
|
|
|
// boolean functions on Position
|
|
|
|
enum EUpdateStyle { UpdateStyle, DoNotUpdateStyle };
|
|
// FIXME: Both isEditablePosition and isRichlyEditablePosition rely on up-to-date
|
|
// style to give proper results. They shouldn't update style by default, but
|
|
// should make it clear that that is the contract.
|
|
// FIXME: isRichlyEditablePosition should also take EUpdateStyle.
|
|
bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
|
|
bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
|
|
bool lineBreakExistsAtPosition(const Position&);
|
|
bool isVisiblyAdjacent(const Position& first, const Position& second);
|
|
bool isAtUnsplittableElement(const Position&);
|
|
|
|
// miscellaneous functions on Position
|
|
|
|
enum WhitespacePositionOption { NotConsiderNonCollapsibleWhitespace, ConsiderNonCollapsibleWhitespace };
|
|
Position leadingWhitespacePosition(const Position&, EAffinity, WhitespacePositionOption = NotConsiderNonCollapsibleWhitespace);
|
|
Position trailingWhitespacePosition(const Position&, EAffinity, WhitespacePositionOption = NotConsiderNonCollapsibleWhitespace);
|
|
unsigned numEnclosingMailBlockquotes(const Position&);
|
|
void updatePositionForNodeRemoval(Position&, Node&);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// VisiblePosition
|
|
// -------------------------------------------------------------------------
|
|
|
|
// Functions returning VisiblePosition
|
|
|
|
VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position&, ContainerNode*);
|
|
VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position&, ContainerNode*);
|
|
VisiblePosition visiblePositionBeforeNode(Node&);
|
|
VisiblePosition visiblePositionAfterNode(Node&);
|
|
|
|
bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
|
|
|
|
int comparePositions(const VisiblePosition&, const VisiblePosition&);
|
|
|
|
int indexForVisiblePosition(const VisiblePosition&, RefPtr<ContainerNode>& scope);
|
|
VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Range
|
|
// -------------------------------------------------------------------------
|
|
|
|
// Functions returning Range
|
|
|
|
PassRefPtr<Range> createRange(Document&, const VisiblePosition& start, const VisiblePosition& end, ExceptionState&);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// HTMLElement
|
|
// -------------------------------------------------------------------------
|
|
|
|
// Functions returning HTMLElement
|
|
|
|
PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Element
|
|
// -------------------------------------------------------------------------
|
|
|
|
Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
|
|
Element* unsplittableElementForPosition(const Position&);
|
|
|
|
// Boolean functions on Element
|
|
|
|
bool canMergeLists(Element* firstList, Element* secondList);
|
|
|
|
// Miscellaneous functions on Text
|
|
inline bool isWhitespace(UChar c)
|
|
{
|
|
return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
|
|
}
|
|
|
|
// FIXME: Can't really answer this question correctly without knowing the white-space mode.
|
|
inline bool isCollapsibleWhitespace(UChar c)
|
|
{
|
|
return c == ' ' || c == '\n';
|
|
}
|
|
|
|
inline bool isAmbiguousBoundaryCharacter(UChar character)
|
|
{
|
|
// These are characters that can behave as word boundaries, but can appear within words.
|
|
// If they are just typed, i.e. if they are immediately followed by a caret, we want to delay text checking until the next character has been typed.
|
|
// FIXME: this is required until 6853027 is fixed and text checking can do this for us.
|
|
return character == '\'' || character == rightSingleQuotationMark || character == hebrewPunctuationGershayim;
|
|
}
|
|
|
|
String stringWithRebalancedWhitespace(const String&, bool startIsStartOfParagraph, bool endIsEndOfParagraph);
|
|
const String& nonBreakingSpaceString();
|
|
|
|
}
|
|
|
|
#endif // SKY_ENGINE_CORE_EDITING_HTMLEDITING_H_
|