blob: 69d6059302652f672fd259152d3dcfb45ff0926f [file] [log] [blame]
/*
* Copyright (C) 2006, 2007, 2008, 2013, 2014 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 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 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.
*/
#pragma once
#include "CompositionUnderline.h"
#include "DocumentMarker.h"
#include "EditAction.h"
#include "EditingBehavior.h"
#include "EditingStyle.h"
#include "EditorInsertAction.h"
#include "FindOptions.h"
#include "Frame.h"
#include "FrameSelection.h"
#include "PasteboardWriterData.h"
#include "TextChecking.h"
#include "TextEventInputType.h"
#include "TextIteratorBehavior.h"
#include "VisibleSelection.h"
#include "WritingDirection.h"
#include <memory>
#if PLATFORM(COCOA)
OBJC_CLASS NSAttributedString;
OBJC_CLASS NSDictionary;
OBJC_CLASS NSMutableDictionary;
#endif
namespace PAL {
class KillRing;
}
namespace WebCore {
class AlternativeTextController;
class ArchiveResource;
class DataTransfer;
class CompositeEditCommand;
class CustomUndoStep;
class DeleteButtonController;
class EditCommand;
class EditCommandComposition;
class EditorClient;
class EditorInternalCommand;
class File;
class Frame;
class HTMLElement;
class HitTestResult;
class KeyboardEvent;
class KillRing;
class Pasteboard;
class PasteboardWriterData;
class RenderLayer;
class SharedBuffer;
class Font;
class SpellCheckRequest;
class SpellChecker;
class StaticRange;
class StyleProperties;
class Text;
class TextCheckerClient;
class TextEvent;
class TextPlaceholderElement;
struct CompositionHighlight;
struct DictationAlternative;
struct FontAttributes;
struct PasteboardPlainText;
struct PasteboardURL;
struct TextCheckingResult;
#if ENABLE(ATTACHMENT_ELEMENT)
struct PromisedAttachmentInfo;
struct SerializedAttachmentData;
#endif
enum EditorCommandSource { CommandFromMenuOrKeyBinding, CommandFromDOM, CommandFromDOMWithUserInterface };
enum EditorParagraphSeparator { EditorParagraphSeparatorIsDiv, EditorParagraphSeparatorIsP };
enum class MailBlockquoteHandling {
RespectBlockquote,
IgnoreBlockquote,
};
#if ENABLE(ATTACHMENT_ELEMENT)
class HTMLAttachmentElement;
#endif
enum class TemporarySelectionOption : uint8_t {
RevealSelection = 1 << 0,
DoNotSetFocus = 1 << 1,
// Don't propagate selection changes to the client layer.
IgnoreSelectionChanges = 1 << 2,
// Force the render tree to update selection state. Only respected on iOS.
EnableAppearanceUpdates = 1 << 3,
};
class TemporarySelectionChange {
public:
WEBCORE_EXPORT TemporarySelectionChange(Document&, Optional<VisibleSelection> = WTF::nullopt, OptionSet<TemporarySelectionOption> = { });
WEBCORE_EXPORT ~TemporarySelectionChange();
private:
void setSelection(const VisibleSelection&);
RefPtr<Document> m_document;
OptionSet<TemporarySelectionOption> m_options;
bool m_wasIgnoringSelectionChanges;
#if PLATFORM(IOS_FAMILY)
bool m_appearanceUpdatesWereEnabled;
#endif
Optional<VisibleSelection> m_selectionToRestore;
};
class IgnoreSelectionChangeForScope {
public:
IgnoreSelectionChangeForScope(Frame& frame)
: m_selectionChange(*frame.document(), WTF::nullopt, TemporarySelectionOption::IgnoreSelectionChanges)
{
}
~IgnoreSelectionChangeForScope() = default;
private:
TemporarySelectionChange m_selectionChange;
};
class Editor {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit Editor(Document&);
~Editor();
enum class PasteOption : uint8_t {
AllowPlainText = 1 << 0,
IgnoreMailBlockquote = 1 << 1,
AsQuotation = 1 << 2,
};
WEBCORE_EXPORT EditorClient* client() const;
WEBCORE_EXPORT TextCheckerClient* textChecker() const;
CompositeEditCommand* lastEditCommand() { return m_lastEditCommand.get(); }
void handleKeyboardEvent(KeyboardEvent&);
void handleInputMethodKeydown(KeyboardEvent&);
void didDispatchInputMethodKeydown(KeyboardEvent&);
bool handleTextEvent(TextEvent&);
WEBCORE_EXPORT bool canEdit() const;
WEBCORE_EXPORT bool canEditRichly() const;
bool canDHTMLCut();
bool canDHTMLCopy();
WEBCORE_EXPORT bool canDHTMLPaste();
bool tryDHTMLCopy();
bool tryDHTMLCut();
WEBCORE_EXPORT bool canCut() const;
WEBCORE_EXPORT bool canCopy() const;
WEBCORE_EXPORT bool canPaste() const;
WEBCORE_EXPORT bool canDelete() const;
WEBCORE_EXPORT bool canSmartCopyOrDelete();
bool shouldSmartDelete();
enum class FromMenuOrKeyBinding : bool { No, Yes };
WEBCORE_EXPORT void cut(FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
WEBCORE_EXPORT void copy(FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
WEBCORE_EXPORT void paste(FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
void paste(Pasteboard&, FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
WEBCORE_EXPORT void pasteAsPlainText(FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
void pasteAsQuotation(FromMenuOrKeyBinding = FromMenuOrKeyBinding::No);
WEBCORE_EXPORT void performDelete();
WEBCORE_EXPORT void copyURL(const URL&, const String& title);
void copyURL(const URL&, const String& title, Pasteboard&);
PasteboardWriterData::URLData pasteboardWriterURL(const URL&, const String& title);
#if !PLATFORM(IOS_FAMILY)
WEBCORE_EXPORT void copyImage(const HitTestResult&);
#endif
void renderLayerDidScroll(const RenderLayer&);
void revealSelectionIfNeededAfterLoadingImageForElement(HTMLImageElement&);
String readPlainTextFromPasteboard(Pasteboard&);
WEBCORE_EXPORT void indent();
WEBCORE_EXPORT void outdent();
void transpose();
bool shouldInsertFragment(DocumentFragment&, Range*, EditorInsertAction);
bool shouldInsertText(const String&, Range*, EditorInsertAction) const;
WEBCORE_EXPORT bool shouldDeleteRange(Range*) const;
bool shouldApplyStyle(StyleProperties*, Range*);
void respondToChangedContents(const VisibleSelection& endingSelection);
bool selectionStartHasStyle(CSSPropertyID, const String& value) const;
WEBCORE_EXPORT TriState selectionHasStyle(CSSPropertyID, const String& value) const;
String selectionStartCSSPropertyValue(CSSPropertyID);
TriState selectionUnorderedListState() const;
TriState selectionOrderedListState() const;
WEBCORE_EXPORT RefPtr<Node> insertOrderedList();
WEBCORE_EXPORT RefPtr<Node> insertUnorderedList();
WEBCORE_EXPORT bool canIncreaseSelectionListLevel();
WEBCORE_EXPORT bool canDecreaseSelectionListLevel();
WEBCORE_EXPORT RefPtr<Node> increaseSelectionListLevel();
WEBCORE_EXPORT RefPtr<Node> increaseSelectionListLevelOrdered();
WEBCORE_EXPORT RefPtr<Node> increaseSelectionListLevelUnordered();
WEBCORE_EXPORT void decreaseSelectionListLevel();
WEBCORE_EXPORT void changeSelectionListType();
void removeFormattingAndStyle();
void clearLastEditCommand();
#if PLATFORM(IOS_FAMILY)
WEBCORE_EXPORT void ensureLastEditCommandHasCurrentSelectionIfOpenForMoreTyping();
#endif
WEBCORE_EXPORT bool deleteWithDirection(SelectionDirection, TextGranularity, bool killRing, bool isTypingAction);
WEBCORE_EXPORT void deleteSelectionWithSmartDelete(bool smartDelete, EditAction = EditAction::Delete);
void clearText();
#if PLATFORM(IOS_FAMILY)
WEBCORE_EXPORT void removeUnchangeableStyles();
#endif
WEBCORE_EXPORT void applyStyle(StyleProperties*, EditAction = EditAction::Unspecified);
enum class ColorFilterMode { InvertColor, UseOriginalColor };
void applyStyle(RefPtr<EditingStyle>&&, EditAction, ColorFilterMode);
void applyParagraphStyle(StyleProperties*, EditAction = EditAction::Unspecified);
WEBCORE_EXPORT void applyStyleToSelection(StyleProperties*, EditAction);
WEBCORE_EXPORT void applyStyleToSelection(Ref<EditingStyle>&&, EditAction, ColorFilterMode);
void applyParagraphStyleToSelection(StyleProperties*, EditAction);
// Returns whether or not we should proceed with editing.
bool willApplyEditing(CompositeEditCommand&, Vector<RefPtr<StaticRange>>&&) const;
bool willUnapplyEditing(const EditCommandComposition&) const;
bool willReapplyEditing(const EditCommandComposition&) const;
void appliedEditing(CompositeEditCommand&);
void unappliedEditing(EditCommandComposition&);
void reappliedEditing(EditCommandComposition&);
void unappliedSpellCorrection(const VisibleSelection& selectionOfCorrected, const String& corrected, const String& correction);
// This is off by default, since most editors want this behavior (originally matched IE but not Firefox).
void setShouldStyleWithCSS(bool flag) { m_shouldStyleWithCSS = flag; }
bool shouldStyleWithCSS() const { return m_shouldStyleWithCSS; }
class Command {
public:
WEBCORE_EXPORT Command();
Command(const EditorInternalCommand*, EditorCommandSource, Document&);
WEBCORE_EXPORT bool execute(const String& parameter = String(), Event* triggeringEvent = nullptr) const;
WEBCORE_EXPORT bool execute(Event* triggeringEvent) const;
WEBCORE_EXPORT bool isSupported() const;
WEBCORE_EXPORT bool isEnabled(Event* triggeringEvent = nullptr) const;
WEBCORE_EXPORT TriState state(Event* triggeringEvent = nullptr) const;
String value(Event* triggeringEvent = nullptr) const;
WEBCORE_EXPORT bool isTextInsertion() const;
WEBCORE_EXPORT bool allowExecutionWhenDisabled() const;
private:
const EditorInternalCommand* m_command { nullptr };
EditorCommandSource m_source;
RefPtr<Document> m_document;
RefPtr<Frame> m_frame;
};
WEBCORE_EXPORT Command command(const String& commandName); // Command source is CommandFromMenuOrKeyBinding.
Command command(const String& commandName, EditorCommandSource);
WEBCORE_EXPORT static bool commandIsSupportedFromMenuOrKeyBinding(const String& commandName); // Works without a frame.
WEBCORE_EXPORT bool insertText(const String&, Event* triggeringEvent, TextEventInputType = TextEventInputKeyboard);
bool insertTextForConfirmedComposition(const String& text);
WEBCORE_EXPORT bool insertDictatedText(const String&, const Vector<DictationAlternative>& dictationAlternatives, Event* triggeringEvent);
bool insertTextWithoutSendingTextEvent(const String&, bool selectInsertedText, TextEvent* triggeringEvent);
bool insertLineBreak();
bool insertParagraphSeparator();
WEBCORE_EXPORT bool insertParagraphSeparatorInQuotedContent();
WEBCORE_EXPORT bool isContinuousSpellCheckingEnabled() const;
WEBCORE_EXPORT void toggleContinuousSpellChecking();
bool isGrammarCheckingEnabled();
void toggleGrammarChecking();
void ignoreSpelling();
void learnSpelling();
int spellCheckerDocumentTag();
WEBCORE_EXPORT bool isSelectionUngrammatical();
String misspelledSelectionString() const;
String misspelledWordAtCaretOrRange(Node* clickedNode) const;
Vector<String> guessesForMisspelledWord(const String&) const;
Vector<String> guessesForMisspelledOrUngrammatical(bool& misspelled, bool& ungrammatical);
bool isSpellCheckingEnabledInFocusedNode() const;
bool isSpellCheckingEnabledFor(Node*) const;
WEBCORE_EXPORT void markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart, const VisibleSelection& selectionAfterTyping, bool doReplacement);
void markMisspellings(const VisibleSelection&, RefPtr<Range>& firstMisspellingRange);
void markBadGrammar(const VisibleSelection&);
void markMisspellingsAndBadGrammar(const VisibleSelection& spellingSelection, bool markGrammar, const VisibleSelection& grammarSelection);
void markAndReplaceFor(const SpellCheckRequest&, const Vector<TextCheckingResult>&);
WEBCORE_EXPORT void replaceRangeForSpellChecking(Range&, const String&);
bool isOverwriteModeEnabled() const { return m_overwriteModeEnabled; }
WEBCORE_EXPORT void toggleOverwriteModeEnabled();
void markAllMisspellingsAndBadGrammarInRanges(OptionSet<TextCheckingType>, RefPtr<Range>&& spellingRange, RefPtr<Range>&& automaticReplacementRange, RefPtr<Range>&& grammarRange);
#if PLATFORM(IOS_FAMILY)
NO_RETURN_DUE_TO_ASSERT
#endif
void changeBackToReplacedString(const String& replacedString);
#if !PLATFORM(IOS_FAMILY)
WEBCORE_EXPORT void advanceToNextMisspelling(bool startBeforeSelection = false);
#endif
void showSpellingGuessPanel();
bool spellingPanelIsShowing();
bool shouldBeginEditing(Range*);
bool shouldEndEditing(Range*);
void clearUndoRedoOperations();
bool canUndo() const;
void undo();
bool canRedo() const;
void redo();
void registerCustomUndoStep(Ref<CustomUndoStep>&&);
void didBeginEditing();
void didEndEditing();
void willWriteSelectionToPasteboard(Range*);
void didWriteSelectionToPasteboard();
void showFontPanel();
void showStylesPanel();
void showColorPanel();
void toggleBold();
void toggleUnderline();
WEBCORE_EXPORT void setBaseWritingDirection(WritingDirection);
// smartInsertDeleteEnabled and selectTrailingWhitespaceEnabled are
// mutually exclusive, meaning that enabling one will disable the other.
bool smartInsertDeleteEnabled();
bool isSelectTrailingWhitespaceEnabled() const;
WEBCORE_EXPORT bool hasBidiSelection() const;
// international text input composition
bool hasComposition() const { return m_compositionNode; }
WEBCORE_EXPORT void setComposition(const String&, const Vector<CompositionUnderline>&, const Vector<CompositionHighlight>&, unsigned selectionStart, unsigned selectionEnd);
WEBCORE_EXPORT void confirmComposition();
WEBCORE_EXPORT void confirmComposition(const String&); // if no existing composition, replaces selection
WEBCORE_EXPORT void cancelComposition();
bool cancelCompositionIfSelectionIsInvalid();
WEBCORE_EXPORT RefPtr<Range> compositionRange() const;
WEBCORE_EXPORT bool getCompositionSelection(unsigned& selectionStart, unsigned& selectionEnd) const;
// getting international text input composition state (for use by InlineTextBox)
Text* compositionNode() const { return m_compositionNode.get(); }
unsigned compositionStart() const { return m_compositionStart; }
unsigned compositionEnd() const { return m_compositionEnd; }
bool compositionUsesCustomUnderlines() const { return !m_customCompositionUnderlines.isEmpty(); }
const Vector<CompositionUnderline>& customCompositionUnderlines() const { return m_customCompositionUnderlines; }
bool compositionUsesCustomHighlights() const { return !m_customCompositionHighlights.isEmpty(); }
const Vector<CompositionHighlight>& customCompositionHighlights() const { return m_customCompositionHighlights; }
// FIXME: This should be a page-level concept (i.e. on EditorClient) instead of on the Editor, which
// is a frame-specific concept, because executing an editing command can run JavaScript that can do
// anything, including changing the focused frame. That is, it is not enough to set this setting on
// one Editor to disallow selection changes in all frames.
enum class RevealSelection { No, Yes };
WEBCORE_EXPORT void setIgnoreSelectionChanges(bool, RevealSelection shouldRevealExistingSelection = RevealSelection::Yes);
bool ignoreSelectionChanges() const { return m_ignoreSelectionChanges; }
WEBCORE_EXPORT RefPtr<Range> rangeForPoint(const IntPoint& windowPoint);
void clear();
VisibleSelection selectionForCommand(Event*);
PAL::KillRing& killRing() const { return *m_killRing; }
SpellChecker& spellChecker() const { return *m_spellChecker; }
EditingBehavior behavior() const;
RefPtr<Range> selectedRange();
#if PLATFORM(IOS_FAMILY)
WEBCORE_EXPORT void confirmMarkedText();
WEBCORE_EXPORT void setTextAsChildOfElement(const String&, Element&);
WEBCORE_EXPORT void setTextAlignmentForChangedBaseWritingDirection(WritingDirection);
WEBCORE_EXPORT void insertDictationPhrases(Vector<Vector<String>>&& dictationPhrases, id metadata);
WEBCORE_EXPORT void setDictationPhrasesAsChildOfElement(const Vector<Vector<String>>& dictationPhrases, id metadata, Element&);
#endif
enum class KillRingInsertionMode { PrependText, AppendText };
void addRangeToKillRing(const SimpleRange&, KillRingInsertionMode);
void addTextToKillRing(const String&, KillRingInsertionMode);
void setStartNewKillRingSequence(bool);
void startAlternativeTextUITimer();
// If user confirmed a correction in the correction panel, correction has non-zero length, otherwise it means that user has dismissed the panel.
WEBCORE_EXPORT void handleAlternativeTextUIResult(const String& correction);
void dismissCorrectionPanelAsIgnored();
WEBCORE_EXPORT void pasteAsFragment(Ref<DocumentFragment>&&, bool smartReplace, bool matchStyle, MailBlockquoteHandling = MailBlockquoteHandling::RespectBlockquote);
WEBCORE_EXPORT void pasteAsPlainText(const String&, bool smartReplace);
// This is only called on the mac where paste is implemented primarily at the WebKit level.
WEBCORE_EXPORT void pasteAsPlainTextBypassingDHTML();
void clearMisspellingsAndBadGrammar(const VisibleSelection&);
void markMisspellingsAndBadGrammar(const VisibleSelection&);
Element* findEventTargetFrom(const VisibleSelection& selection) const;
WEBCORE_EXPORT String selectedText() const;
String selectedTextForDataTransfer() const;
WEBCORE_EXPORT bool findString(const String&, FindOptions);
WEBCORE_EXPORT RefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
const VisibleSelection& mark() const; // Mark, to be used as emacs uses it.
void setMark(const VisibleSelection&);
void computeAndSetTypingStyle(EditingStyle& , EditAction = EditAction::Unspecified);
WEBCORE_EXPORT void computeAndSetTypingStyle(StyleProperties& , EditAction = EditAction::Unspecified);
WEBCORE_EXPORT void applyEditingStyleToBodyElement() const;
WEBCORE_EXPORT IntRect firstRectForRange(Range*) const;
void selectionWillChange();
void respondToChangedSelection(const VisibleSelection& oldSelection, OptionSet<FrameSelection::SetSelectionOption>);
WEBCORE_EXPORT void updateEditorUINowIfScheduled();
bool shouldChangeSelection(const VisibleSelection& oldSelection, const VisibleSelection& newSelection, EAffinity, bool stillSelecting) const;
WEBCORE_EXPORT unsigned countMatchesForText(const String&, Range*, FindOptions, unsigned limit, bool markMatches, Vector<RefPtr<Range>>*);
bool markedTextMatchesAreHighlighted() const;
WEBCORE_EXPORT void setMarkedTextMatchesAreHighlighted(bool);
void textFieldDidBeginEditing(Element*);
void textFieldDidEndEditing(Element*);
void textDidChangeInTextField(Element*);
bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*);
void textWillBeDeletedInTextField(Element* input);
void textDidChangeInTextArea(Element*);
WEBCORE_EXPORT WritingDirection baseWritingDirectionForSelectionStart() const;
enum class SelectReplacement : bool { No, Yes };
enum class SmartReplace : bool { No, Yes };
enum class MatchStyle : bool { No, Yes };
WEBCORE_EXPORT void replaceSelectionWithFragment(DocumentFragment&, SelectReplacement, SmartReplace, MatchStyle, EditAction = EditAction::Insert, MailBlockquoteHandling = MailBlockquoteHandling::RespectBlockquote);
WEBCORE_EXPORT void replaceSelectionWithText(const String&, SelectReplacement, SmartReplace, EditAction = EditAction::Insert);
WEBCORE_EXPORT bool selectionStartHasMarkerFor(DocumentMarker::MarkerType, int from, int length) const;
void updateMarkersForWordsAffectedByEditing(bool doNotRemoveIfSelectionAtWordBoundary);
void deletedAutocorrectionAtPosition(const Position&, const String& originalString);
WEBCORE_EXPORT void simplifyMarkup(Node* startNode, Node* endNode);
EditorParagraphSeparator defaultParagraphSeparator() const { return m_defaultParagraphSeparator; }
void setDefaultParagraphSeparator(EditorParagraphSeparator separator) { m_defaultParagraphSeparator = separator; }
Vector<String> dictationAlternativesForMarker(const DocumentMarker&);
void applyDictationAlternativelternative(const String& alternativeString);
#if USE(APPKIT)
WEBCORE_EXPORT void uppercaseWord();
WEBCORE_EXPORT void lowercaseWord();
WEBCORE_EXPORT void capitalizeWord();
#endif
#if USE(AUTOMATIC_TEXT_REPLACEMENT)
WEBCORE_EXPORT void showSubstitutionsPanel();
WEBCORE_EXPORT bool substitutionsPanelIsShowing();
WEBCORE_EXPORT void toggleSmartInsertDelete();
WEBCORE_EXPORT bool isAutomaticQuoteSubstitutionEnabled();
WEBCORE_EXPORT void toggleAutomaticQuoteSubstitution();
WEBCORE_EXPORT bool isAutomaticLinkDetectionEnabled();
WEBCORE_EXPORT void toggleAutomaticLinkDetection();
WEBCORE_EXPORT bool isAutomaticDashSubstitutionEnabled();
WEBCORE_EXPORT void toggleAutomaticDashSubstitution();
WEBCORE_EXPORT bool isAutomaticTextReplacementEnabled();
WEBCORE_EXPORT void toggleAutomaticTextReplacement();
WEBCORE_EXPORT bool isAutomaticSpellingCorrectionEnabled();
WEBCORE_EXPORT void toggleAutomaticSpellingCorrection();
#endif
RefPtr<DocumentFragment> webContentFromPasteboard(Pasteboard&, const SimpleRange& context, bool allowPlainText, bool& chosePlainText);
WEBCORE_EXPORT const Font* fontForSelection(bool& hasMultipleFonts) const;
WEBCORE_EXPORT static const RenderStyle* styleForSelectionStart(Frame* , Node *&nodeToRemove);
WEBCORE_EXPORT FontAttributes fontAttributesAtSelectionStart() const;
#if PLATFORM(COCOA)
WEBCORE_EXPORT String stringSelectionForPasteboard();
String stringSelectionForPasteboardWithImageAltText();
void takeFindStringFromSelection();
WEBCORE_EXPORT void replaceSelectionWithAttributedString(NSAttributedString *, MailBlockquoteHandling = MailBlockquoteHandling::RespectBlockquote);
#endif
#if PLATFORM(MAC)
WEBCORE_EXPORT void readSelectionFromPasteboard(const String& pasteboardName);
WEBCORE_EXPORT void replaceNodeFromPasteboard(Node*, const String& pasteboardName);
WEBCORE_EXPORT RefPtr<SharedBuffer> dataSelectionForPasteboard(const String& pasteboardName);
#endif
bool canCopyExcludingStandaloneImages() const;
#if !PLATFORM(WIN)
WEBCORE_EXPORT void writeSelectionToPasteboard(Pasteboard&);
WEBCORE_EXPORT void writeImageToPasteboard(Pasteboard&, Element& imageElement, const URL&, const String& title);
void writeSelection(PasteboardWriterData&);
#endif
#if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(MAC)
void scanSelectionForTelephoneNumbers();
const Vector<SimpleRange>& detectedTelephoneNumberRanges() const { return m_detectedTelephoneNumberRanges; }
#endif
WEBCORE_EXPORT String stringForCandidateRequest() const;
WEBCORE_EXPORT void handleAcceptedCandidate(TextCheckingResult);
WEBCORE_EXPORT RefPtr<Range> contextRangeForCandidateRequest() const;
RefPtr<Range> rangeForTextCheckingResult(const TextCheckingResult&) const;
bool isHandlingAcceptedCandidate() const { return m_isHandlingAcceptedCandidate; }
void setIsGettingDictionaryPopupInfo(bool b) { m_isGettingDictionaryPopupInfo = b; }
bool isGettingDictionaryPopupInfo() const { return m_isGettingDictionaryPopupInfo; }
#if ENABLE(ATTACHMENT_ELEMENT)
WEBCORE_EXPORT void insertAttachment(const String& identifier, Optional<uint64_t>&& fileSize, const String& fileName, const String& contentType);
void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& fileData);
void registerAttachments(Vector<SerializedAttachmentData>&&);
void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath);
void registerAttachmentIdentifier(const String&);
void cloneAttachmentData(const String& fromIdentifier, const String& toIdentifier);
void didInsertAttachmentElement(HTMLAttachmentElement&);
void didRemoveAttachmentElement(HTMLAttachmentElement&);
WEBCORE_EXPORT PromisedAttachmentInfo promisedAttachmentInfo(Element&);
#if PLATFORM(COCOA)
void getPasteboardTypesAndDataForAttachment(Element&, Vector<String>& outTypes, Vector<RefPtr<SharedBuffer>>& outData);
#endif
#endif
WEBCORE_EXPORT RefPtr<HTMLImageElement> insertEditableImage();
WEBCORE_EXPORT RefPtr<TextPlaceholderElement> insertTextPlaceholder(const IntSize&);
WEBCORE_EXPORT void removeTextPlaceholder(TextPlaceholderElement&);
bool isPastingFromMenuOrKeyBinding() const { return m_pastingFromMenuOrKeyBinding; }
bool isCopyingFromMenuOrKeyBinding() const { return m_copyingFromMenuOrKeyBinding; }
private:
Document& document() const { return m_document; }
bool canDeleteRange(Range*) const;
bool canSmartReplaceWithPasteboard(Pasteboard&);
void pasteAsPlainTextWithPasteboard(Pasteboard&);
void pasteWithPasteboard(Pasteboard*, OptionSet<PasteOption>);
String plainTextFromPasteboard(const PasteboardPlainText&);
void quoteFragmentForPasting(DocumentFragment&);
void revealSelectionAfterEditingOperation(const ScrollAlignment& = ScrollAlignment::alignCenterIfNeeded, RevealExtentOption = DoNotRevealExtent);
void markMisspellingsOrBadGrammar(const VisibleSelection&, bool checkSpelling, RefPtr<Range>& firstMisspellingRange);
OptionSet<TextCheckingType> resolveTextCheckingTypeMask(const Node& rootEditableElement, OptionSet<TextCheckingType>);
WEBCORE_EXPORT String selectedText(TextIteratorBehavior) const;
void selectComposition();
enum SetCompositionMode { ConfirmComposition, CancelComposition };
void setComposition(const String&, SetCompositionMode);
void changeSelectionAfterCommand(const VisibleSelection& newSelection, OptionSet<FrameSelection::SetSelectionOption>);
enum EditorActionSpecifier { CutAction, CopyAction };
void performCutOrCopy(EditorActionSpecifier);
void editorUIUpdateTimerFired();
Element* findEventTargetFromSelection() const;
bool unifiedTextCheckerEnabled() const;
RefPtr<Range> adjustedSelectionRange();
#if PLATFORM(COCOA)
RefPtr<SharedBuffer> selectionInWebArchiveFormat();
String selectionInHTMLFormat();
RefPtr<SharedBuffer> imageInWebArchiveFormat(Element&);
static String userVisibleString(const URL&);
static RefPtr<SharedBuffer> dataInRTFDFormat(NSAttributedString *);
static RefPtr<SharedBuffer> dataInRTFFormat(NSAttributedString *);
#endif
void platformFontAttributesAtSelectionStart(FontAttributes&, const RenderStyle&) const;
void scheduleEditorUIUpdate();
#if ENABLE(ATTACHMENT_ELEMENT)
void notifyClientOfAttachmentUpdates();
#endif
String platformContentTypeForBlobType(const String& type) const;
void postTextStateChangeNotificationForCut(const String&, const VisibleSelection&);
Document& m_document;
RefPtr<CompositeEditCommand> m_lastEditCommand;
RefPtr<Text> m_compositionNode;
unsigned m_compositionStart;
unsigned m_compositionEnd;
Vector<CompositionUnderline> m_customCompositionUnderlines;
Vector<CompositionHighlight> m_customCompositionHighlights;
bool m_ignoreSelectionChanges { false };
bool m_shouldStartNewKillRingSequence { false };
bool m_shouldStyleWithCSS { false };
const std::unique_ptr<PAL::KillRing> m_killRing;
const std::unique_ptr<SpellChecker> m_spellChecker;
const std::unique_ptr<AlternativeTextController> m_alternativeTextController;
EditorParagraphSeparator m_defaultParagraphSeparator { EditorParagraphSeparatorIsDiv };
bool m_overwriteModeEnabled { false };
#if ENABLE(ATTACHMENT_ELEMENT)
HashSet<String> m_insertedAttachmentIdentifiers;
HashSet<String> m_removedAttachmentIdentifiers;
#endif
VisibleSelection m_mark;
bool m_areMarkedTextMatchesHighlighted { false };
VisibleSelection m_oldSelectionForEditorUIUpdate;
Timer m_editorUIUpdateTimer;
bool m_editorUIUpdateTimerShouldCheckSpellingAndGrammar { false };
bool m_editorUIUpdateTimerWasTriggeredByDictation { false };
bool m_isHandlingAcceptedCandidate { false };
bool m_copyingFromMenuOrKeyBinding { false };
bool m_pastingFromMenuOrKeyBinding { false };
#if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(MAC)
bool shouldDetectTelephoneNumbers() const;
Timer m_telephoneNumberDetectionUpdateTimer;
Vector<SimpleRange> m_detectedTelephoneNumberRanges;
#endif
bool m_isGettingDictionaryPopupInfo { false };
HashSet<RefPtr<HTMLImageElement>> m_imageElementsToLoadBeforeRevealingSelection;
};
inline void Editor::setStartNewKillRingSequence(bool flag)
{
m_shouldStartNewKillRingSequence = flag;
}
inline const VisibleSelection& Editor::mark() const
{
return m_mark;
}
inline void Editor::setMark(const VisibleSelection& selection)
{
m_mark = selection;
}
inline bool Editor::markedTextMatchesAreHighlighted() const
{
return m_areMarkedTextMatchesHighlighted;
}
} // namespace WebCore