| /* |
| * Copyright (C) 2010 Google Inc. All rights reserved. |
| * Copyright (C) 2013 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: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * 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. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "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 THE COPYRIGHT |
| * OWNER 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 EditingStyle_h |
| #define EditingStyle_h |
| |
| #include "core/CSSPropertyNames.h" |
| #include "core/CSSValueKeywords.h" |
| #include "core/CoreExport.h" |
| #include "core/editing/Position.h" |
| #include "core/editing/VisibleSelection.h" |
| #include "core/editing/WritingDirection.h" |
| #include "platform/heap/Handle.h" |
| #include "wtf/Forward.h" |
| #include "wtf/TriState.h" |
| #include "wtf/Vector.h" |
| #include "wtf/text/WTFString.h" |
| |
| namespace blink { |
| |
| class CSSStyleDeclaration; |
| class CSSComputedStyleDeclaration; |
| class ContainerNode; |
| class Document; |
| class Element; |
| class HTMLElement; |
| class MutableStylePropertySet; |
| class Node; |
| class QualifiedName; |
| class ComputedStyle; |
| class StylePropertySet; |
| |
| class CORE_EXPORT EditingStyle final : public GarbageCollected<EditingStyle> { |
| public: |
| enum PropertiesToInclude { |
| AllProperties, |
| OnlyEditingInheritableProperties, |
| EditingPropertiesInEffect |
| }; |
| enum ShouldPreserveWritingDirection { |
| PreserveWritingDirection, |
| DoNotPreserveWritingDirection |
| }; |
| enum ShouldExtractMatchingStyle { |
| ExtractMatchingStyle, |
| DoNotExtractMatchingStyle |
| }; |
| static float NoFontDelta; |
| |
| static EditingStyle* create() { return new EditingStyle(); } |
| |
| static EditingStyle* create(ContainerNode* node, |
| PropertiesToInclude propertiesToInclude = |
| OnlyEditingInheritableProperties) { |
| return new EditingStyle(node, propertiesToInclude); |
| } |
| |
| static EditingStyle* create(const Position& position, |
| PropertiesToInclude propertiesToInclude = |
| OnlyEditingInheritableProperties) { |
| return new EditingStyle(position, propertiesToInclude); |
| } |
| |
| static EditingStyle* create(const StylePropertySet* style) { |
| return new EditingStyle(style); |
| } |
| |
| static EditingStyle* create(CSSPropertyID propertyID, const String& value) { |
| return new EditingStyle(propertyID, value); |
| } |
| |
| MutableStylePropertySet* style() { return m_mutableStyle.get(); } |
| bool textDirection(WritingDirection&) const; |
| bool isEmpty() const; |
| void overrideWithStyle(const StylePropertySet*); |
| void clear(); |
| EditingStyle* copy() const; |
| EditingStyle* extractAndRemoveBlockProperties(); |
| EditingStyle* extractAndRemoveTextDirection(); |
| void removeBlockProperties(); |
| void removeStyleAddedByElement(Element*); |
| void removeStyleConflictingWithStyleOfElement(Element*); |
| void collapseTextDecorationProperties(); |
| enum ShouldIgnoreTextOnlyProperties { |
| IgnoreTextOnlyProperties, |
| DoNotIgnoreTextOnlyProperties |
| }; |
| TriState triStateOfStyle(EditingStyle*) const; |
| TriState triStateOfStyle(const VisibleSelection&) const; |
| bool conflictsWithInlineStyleOfElement(HTMLElement* element) const { |
| return conflictsWithInlineStyleOfElement(element, 0, 0); |
| } |
| bool conflictsWithInlineStyleOfElement( |
| HTMLElement* element, |
| EditingStyle* extractedStyle, |
| Vector<CSSPropertyID>& conflictingProperties) const { |
| return conflictsWithInlineStyleOfElement(element, extractedStyle, |
| &conflictingProperties); |
| } |
| bool conflictsWithImplicitStyleOfElement( |
| HTMLElement*, |
| EditingStyle* extractedStyle = nullptr, |
| ShouldExtractMatchingStyle = DoNotExtractMatchingStyle) const; |
| bool conflictsWithImplicitStyleOfAttributes(HTMLElement*) const; |
| bool extractConflictingImplicitStyleOfAttributes( |
| HTMLElement*, |
| ShouldPreserveWritingDirection, |
| EditingStyle* extractedStyle, |
| Vector<QualifiedName>& conflictingAttributes, |
| ShouldExtractMatchingStyle) const; |
| bool styleIsPresentInComputedStyleOfNode(Node*) const; |
| |
| static bool elementIsStyledSpanOrHTMLEquivalent(const HTMLElement*); |
| |
| void prepareToApplyAt( |
| const Position&, |
| ShouldPreserveWritingDirection = DoNotPreserveWritingDirection); |
| void mergeTypingStyle(Document*); |
| enum CSSPropertyOverrideMode { OverrideValues, DoNotOverrideValues }; |
| void mergeInlineStyleOfElement(HTMLElement*, |
| CSSPropertyOverrideMode, |
| PropertiesToInclude = AllProperties); |
| static EditingStyle* wrappingStyleForAnnotatedSerialization( |
| ContainerNode* context); |
| static EditingStyle* wrappingStyleForSerialization(ContainerNode* context); |
| void mergeStyleFromRules(Element*); |
| void mergeStyleFromRulesForSerialization(Element*); |
| void removeStyleFromRulesAndContext(Element*, ContainerNode* context); |
| void removePropertiesInElementDefaultStyle(Element*); |
| void addAbsolutePositioningFromElement(const Element&); |
| void forceInline(); |
| int legacyFontSize(Document*) const; |
| |
| float fontSizeDelta() const { return m_fontSizeDelta; } |
| bool hasFontSizeDelta() const { return m_fontSizeDelta != NoFontDelta; } |
| |
| static EditingStyle* styleAtSelectionStart( |
| const VisibleSelection&, |
| bool shouldUseBackgroundColorInEffect = false, |
| MutableStylePropertySet* styleToCheck = nullptr); |
| static WritingDirection textDirectionForSelection( |
| const VisibleSelection&, |
| EditingStyle* typingStyle, |
| bool& hasNestedOrMultipleEmbeddings); |
| static bool isEmbedOrIsolate(CSSValueID unicodeBidi) { |
| return unicodeBidi == CSSValueIsolate || |
| unicodeBidi == CSSValueWebkitIsolate || unicodeBidi == CSSValueEmbed; |
| } |
| |
| DECLARE_TRACE(); |
| |
| private: |
| EditingStyle() = default; |
| EditingStyle(ContainerNode*, PropertiesToInclude); |
| EditingStyle(const Position&, PropertiesToInclude); |
| explicit EditingStyle(const StylePropertySet*); |
| EditingStyle(CSSPropertyID, const String& value); |
| void init(Node*, PropertiesToInclude); |
| void removeTextFillAndStrokeColorsIfNeeded(const ComputedStyle*); |
| void setProperty(CSSPropertyID, const String& value, bool important = false); |
| void replaceFontSizeByKeywordIfPossible(const ComputedStyle*, |
| CSSComputedStyleDeclaration*); |
| void extractFontSizeDelta(); |
| TriState triStateOfStyle(CSSStyleDeclaration* styleToCompare, |
| ShouldIgnoreTextOnlyProperties) const; |
| bool conflictsWithInlineStyleOfElement( |
| HTMLElement*, |
| EditingStyle* extractedStyle, |
| Vector<CSSPropertyID>* conflictingProperties) const; |
| void mergeInlineAndImplicitStyleOfElement(Element*, |
| CSSPropertyOverrideMode, |
| PropertiesToInclude); |
| void mergeStyle(const StylePropertySet*, CSSPropertyOverrideMode); |
| |
| Member<MutableStylePropertySet> m_mutableStyle; |
| bool m_isMonospaceFont = false; |
| float m_fontSizeDelta = NoFontDelta; |
| bool m_isVerticalAlign = false; |
| |
| friend class HTMLElementEquivalent; |
| friend class HTMLAttributeEquivalent; |
| }; |
| |
| class StyleChange { |
| DISALLOW_NEW(); |
| |
| public: |
| StyleChange() |
| : m_applyBold(false), |
| m_applyItalic(false), |
| m_applyUnderline(false), |
| m_applyLineThrough(false), |
| m_applySubscript(false), |
| m_applySuperscript(false) {} |
| |
| StyleChange(EditingStyle*, const Position&); |
| |
| String cssStyle() const { return m_cssStyle; } |
| bool applyBold() const { return m_applyBold; } |
| bool applyItalic() const { return m_applyItalic; } |
| bool applyUnderline() const { return m_applyUnderline; } |
| bool applyLineThrough() const { return m_applyLineThrough; } |
| bool applySubscript() const { return m_applySubscript; } |
| bool applySuperscript() const { return m_applySuperscript; } |
| bool applyFontColor() const { return m_applyFontColor.length() > 0; } |
| bool applyFontFace() const { return m_applyFontFace.length() > 0; } |
| bool applyFontSize() const { return m_applyFontSize.length() > 0; } |
| |
| String fontColor() { return m_applyFontColor; } |
| String fontFace() { return m_applyFontFace; } |
| String fontSize() { return m_applyFontSize; } |
| |
| bool operator==(const StyleChange& other) { |
| return m_cssStyle == other.m_cssStyle && m_applyBold == other.m_applyBold && |
| m_applyItalic == other.m_applyItalic && |
| m_applyUnderline == other.m_applyUnderline && |
| m_applyLineThrough == other.m_applyLineThrough && |
| m_applySubscript == other.m_applySubscript && |
| m_applySuperscript == other.m_applySuperscript && |
| m_applyFontColor == other.m_applyFontColor && |
| m_applyFontFace == other.m_applyFontFace && |
| m_applyFontSize == other.m_applyFontSize; |
| } |
| bool operator!=(const StyleChange& other) { return !(*this == other); } |
| |
| private: |
| void extractTextStyles(Document*, |
| MutableStylePropertySet*, |
| bool isMonospaceFont); |
| |
| String m_cssStyle; |
| bool m_applyBold; |
| bool m_applyItalic; |
| bool m_applyUnderline; |
| bool m_applyLineThrough; |
| bool m_applySubscript; |
| bool m_applySuperscript; |
| String m_applyFontColor; |
| String m_applyFontFace; |
| String m_applyFontSize; |
| }; |
| |
| // FIXME: Remove these functions or make them non-global to discourage using |
| // CSSStyleDeclaration directly. |
| CSSValueID getIdentifierValue(CSSStyleDeclaration*, CSSPropertyID); |
| CSSValueID getIdentifierValue(StylePropertySet*, CSSPropertyID); |
| |
| } // namespace blink |
| |
| #endif // EditingStyle_h |