Changeset 73416 in webkit


Ignore:
Timestamp:
Dec 6, 2010 5:00:23 PM (13 years ago)
Author:
rniwa@webkit.org
Message:

2010-12-06 Ryosuke Niwa <rniwa@webkit.org>

Reviewed by Tony Chang.

ApplyStyleCommand should take EditingStyle instead of CSSStyleDeclaration
https://bugs.webkit.org/show_bug.cgi?id=49938

Modified ApplyStyleCommand::ApplyStyleCommand and ApplyStyleCommand::create to take EditingStyle*
instead of CSSStyleDeclaration*. Also replaced much of code in Editor::computeAndSetTypingStyle
by calls to EditingStyle's member functions and extracted EditingStyle::overrideWith and
EditingStyle::extractAndRemoveBlockProperties.

No new tests are added since this is a refactoring.

  • WebCore.exp.in: Added SelectionController::copyTypingStyle and EditingStyle::~EditingStyle.
  • css/CSSMutableStyleDeclaration.cpp: Made CSSMutableStyleDeclaration* in the argument list const. (WebCore::CSSMutableStyleDeclaration::merge):
  • css/CSSMutableStyleDeclaration.h:
  • editing/ApplyStyleCommand.cpp: (WebCore::ApplyStyleCommand::ApplyStyleCommand): Takes EditingStyle* instead of CSSStyleDeclaration*. (WebCore::ApplyStyleCommand::doApply): Uses EditingStyle.
  • editing/ApplyStyleCommand.h: m_style is now a ref-pointer to EditingStyle instead of CSSMutableStyleDeclaration. (WebCore::ApplyStyleCommand::create): Takes EditingStyle* instead of CSSStyleDeclaration*.
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::applyStyle): Ditto. (WebCore::CompositeEditCommand::moveParagraphs): Calls applyStyle. (WebCore::CompositeEditCommand::breakOutOfEmptyListItem): Ditto.
  • editing/CompositeEditCommand.h:
  • editing/DeleteSelectionCommand.cpp: (WebCore::DeleteSelectionCommand::calculateTypingStyleAfterDelete): Ditto.
  • editing/EditCommand.cpp:
  • editing/EditCommand.h:
  • editing/EditingStyle.cpp: (WebCore::EditingStyle::~EditingStyle): Added. (WebCore::EditingStyle::overrideWithStyle): Extracted from Editor::calculateTypingStyleAfterDelete. (WebCore::EditingStyle::copy): Added. (WebCore::EditingStyle::extractAndRemoveBlockProperties): Extracted from Editor::calculateTypingStyleAfterDelete.
  • editing/EditingStyle.h:
  • editing/Editor.cpp: (WebCore::Editor::applyStyle): Calls ApplyStyleCommand::create. (WebCore::Editor::applyParagraphStyle): Ditto. (WebCore::Editor::computeAndSetTypingStyle): Ditto.
  • editing/InsertLineBreakCommand.cpp: (WebCore::InsertLineBreakCommand::doApply): Calls applyStyle.
  • editing/InsertParagraphSeparatorCommand.cpp: (WebCore::InsertParagraphSeparatorCommand::applyStyleAfterInsertion): Ditto.
  • editing/InsertTextCommand.cpp: (WebCore::InsertTextCommand::input): Ditto.
  • editing/RemoveFormatCommand.cpp: (WebCore::RemoveFormatCommand::doApply): Calls ApplyStyleCommand::create.
  • editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::completeHTMLReplacement): Calls applyStyle.
  • editing/SelectionController.cpp: (WebCore::SelectionController::copyTypingStyle): Moved from SelectionController.h
  • editing/SelectionController.h:
Location:
trunk/WebCore
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/ChangeLog

    r73411 r73416  
     12010-12-06  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Reviewed by Tony Chang.
     4
     5        ApplyStyleCommand should take EditingStyle instead of CSSStyleDeclaration
     6        https://bugs.webkit.org/show_bug.cgi?id=49938
     7
     8        Modified ApplyStyleCommand::ApplyStyleCommand and ApplyStyleCommand::create to take EditingStyle*
     9        instead of CSSStyleDeclaration*. Also replaced much of code in Editor::computeAndSetTypingStyle
     10        by calls to EditingStyle's member functions and extracted EditingStyle::overrideWith and
     11        EditingStyle::extractAndRemoveBlockProperties.
     12
     13        No new tests are added since this is a refactoring.
     14
     15        * WebCore.exp.in: Added SelectionController::copyTypingStyle and EditingStyle::~EditingStyle.
     16        * css/CSSMutableStyleDeclaration.cpp: Made CSSMutableStyleDeclaration* in the argument list const.
     17        (WebCore::CSSMutableStyleDeclaration::merge):
     18        * css/CSSMutableStyleDeclaration.h:
     19        * editing/ApplyStyleCommand.cpp:
     20        (WebCore::ApplyStyleCommand::ApplyStyleCommand): Takes EditingStyle* instead of CSSStyleDeclaration*.
     21        (WebCore::ApplyStyleCommand::doApply): Uses EditingStyle.
     22        * editing/ApplyStyleCommand.h: m_style is now a ref-pointer to EditingStyle instead of CSSMutableStyleDeclaration.
     23        (WebCore::ApplyStyleCommand::create): Takes EditingStyle* instead of CSSStyleDeclaration*.
     24        * editing/CompositeEditCommand.cpp:
     25        (WebCore::CompositeEditCommand::applyStyle): Ditto.
     26        (WebCore::CompositeEditCommand::moveParagraphs): Calls applyStyle.
     27        (WebCore::CompositeEditCommand::breakOutOfEmptyListItem): Ditto.
     28        * editing/CompositeEditCommand.h:
     29        * editing/DeleteSelectionCommand.cpp:
     30        (WebCore::DeleteSelectionCommand::calculateTypingStyleAfterDelete): Ditto.
     31        * editing/EditCommand.cpp:
     32        * editing/EditCommand.h:
     33        * editing/EditingStyle.cpp:
     34        (WebCore::EditingStyle::~EditingStyle): Added.
     35        (WebCore::EditingStyle::overrideWithStyle): Extracted from Editor::calculateTypingStyleAfterDelete.
     36        (WebCore::EditingStyle::copy): Added.
     37        (WebCore::EditingStyle::extractAndRemoveBlockProperties): Extracted from Editor::calculateTypingStyleAfterDelete.
     38        * editing/EditingStyle.h:
     39        * editing/Editor.cpp:
     40        (WebCore::Editor::applyStyle): Calls ApplyStyleCommand::create.
     41        (WebCore::Editor::applyParagraphStyle): Ditto.
     42        (WebCore::Editor::computeAndSetTypingStyle): Ditto.
     43        * editing/InsertLineBreakCommand.cpp:
     44        (WebCore::InsertLineBreakCommand::doApply): Calls applyStyle.
     45        * editing/InsertParagraphSeparatorCommand.cpp:
     46        (WebCore::InsertParagraphSeparatorCommand::applyStyleAfterInsertion): Ditto.
     47        * editing/InsertTextCommand.cpp:
     48        (WebCore::InsertTextCommand::input): Ditto.
     49        * editing/RemoveFormatCommand.cpp:
     50        (WebCore::RemoveFormatCommand::doApply): Calls ApplyStyleCommand::create.
     51        * editing/ReplaceSelectionCommand.cpp:
     52        (WebCore::ReplaceSelectionCommand::completeHTMLReplacement): Calls applyStyle.
     53        * editing/SelectionController.cpp:
     54        (WebCore::SelectionController::copyTypingStyle): Moved from SelectionController.h
     55        * editing/SelectionController.h:
     56
    1572010-12-05  Ryosuke Niwa  <rniwa@webkit.org>
    258
  • trunk/WebCore/WebCore.exp.in

    r73337 r73416  
    211211__ZN7WebCore12ChromeClient20paintCustomScrollbarEPNS_15GraphicsContextERKNS_9FloatRectENS_20ScrollbarControlSizeEjNS_13ScrollbarPartEbffj
    212212__ZN7WebCore12ChromeClient23paintCustomScrollCornerEPNS_15GraphicsContextERKNS_9FloatRectE
     213__ZN7WebCore12EditingStyleD1Ev
    213214__ZN7WebCore12EventHandler10mouseMovedEP7NSEvent
    214215__ZN7WebCore12EventHandler10mouseMovedERKNS_18PlatformMouseEventE
     
    10321033__ZNK7WebCore19ResourceRequestBase7isEmptyEv
    10331034__ZNK7WebCore19SelectionController11currentFormEv
     1035__ZNK7WebCore19SelectionController15copyTypingStyleEv
    10341036__ZNK7WebCore19SelectionController17isInPasswordFieldEv
    10351037__ZNK7WebCore19SelectionController18isFocusedAndActiveEv
  • trunk/WebCore/css/CSSMutableStyleDeclaration.cpp

    r72500 r73416  
    709709}
    710710
    711 void CSSMutableStyleDeclaration::merge(CSSMutableStyleDeclaration* other, bool argOverridesOnConflict)
     711void CSSMutableStyleDeclaration::merge(const CSSMutableStyleDeclaration* other, bool argOverridesOnConflict)
    712712{
    713713    ASSERT(!m_iteratorCount);
     
    715715    unsigned size = other->m_properties.size();
    716716    for (unsigned n = 0; n < size; ++n) {
    717         CSSProperty& toMerge = other->m_properties[n];
     717        const CSSProperty& toMerge = other->m_properties[n];
    718718        CSSProperty* old = findPropertyWithId(toMerge.id());
    719719        if (old) {
  • trunk/WebCore/css/CSSMutableStyleDeclaration.h

    r72116 r73416  
    130130    void removePropertiesInSet(const int* set, unsigned length, bool notifyChanged = true);
    131131
    132     void merge(CSSMutableStyleDeclaration*, bool argOverridesOnConflict = true);
     132    void merge(const CSSMutableStyleDeclaration*, bool argOverridesOnConflict = true);
    133133
    134134    void setStrictParsing(bool b) { m_strictParsing = b; }
  • trunk/WebCore/editing/ApplyStyleCommand.cpp

    r72500 r73416  
    3535#include "CSSValueKeywords.h"
    3636#include "Document.h"
     37#include "EditingStyle.h"
    3738#include "Editor.h"
    3839#include "Frame.h"
     
    430431}
    431432
    432 ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, EditAction editingAction, EPropertyLevel propertyLevel)
     433ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, EditAction editingAction, EPropertyLevel propertyLevel)
    433434    : CompositeEditCommand(document)
    434     , m_style(style->makeMutable())
     435    , m_style(style->copy())
    435436    , m_editingAction(editingAction)
    436437    , m_propertyLevel(propertyLevel)
     
    444445}
    445446
    446 ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)
     447ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)
    447448    : CompositeEditCommand(document)
    448     , m_style(style->makeMutable())
     449    , m_style(style->copy())
    449450    , m_editingAction(editingAction)
    450451    , m_propertyLevel(propertyLevel)
     
    460461ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)
    461462    : CompositeEditCommand(element->document())
    462     , m_style(CSSMutableStyleDeclaration::create())
     463    , m_style(EditingStyle::create())
    463464    , m_editingAction(editingAction)
    464465    , m_propertyLevel(PropertyDefault)
     
    472473}
    473474
    474 ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction editingAction)
     475ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction editingAction)
    475476    : CompositeEditCommand(document)
    476     , m_style(style->makeMutable())
     477    , m_style(style->copy())
    477478    , m_editingAction(editingAction)
    478479    , m_propertyLevel(PropertyDefault)
     
    517518{
    518519    switch (m_propertyLevel) {
    519         case PropertyDefault: {
    520             // apply the block-centric properties of the style
    521             RefPtr<CSSMutableStyleDeclaration> blockStyle = m_style->copyBlockProperties();
    522             if (blockStyle->length())
    523                 applyBlockStyle(blockStyle.get());
    524             // apply any remaining styles to the inline elements
    525             // NOTE: hopefully, this string comparison is the same as checking for a non-null diff
    526             if (blockStyle->length() < m_style->length() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
    527                 RefPtr<CSSMutableStyleDeclaration> inlineStyle = m_style->copy();
    528                 applyRelativeFontStyleChange(inlineStyle.get());
    529                 blockStyle->diff(inlineStyle.get());
    530                 applyInlineStyle(inlineStyle.get());
    531             }
    532             break;
    533         }
    534         case ForceBlockProperties:
    535             // Force all properties to be applied as block styles.
    536             applyBlockStyle(m_style.get());
    537             break;
     520    case PropertyDefault: {
     521        // Apply the block-centric properties of the style.
     522        RefPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
     523        if (!blockStyle->isEmpty())
     524            applyBlockStyle(blockStyle->style());
     525        // Apply any remaining styles to the inline elements.
     526        if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
     527            RefPtr<CSSMutableStyleDeclaration> style = m_style->style() ? m_style->style() : CSSMutableStyleDeclaration::create();
     528            applyRelativeFontStyleChange(style.get());
     529            applyInlineStyle(style.get());
     530        }
     531        break;
     532    }
     533    case ForceBlockProperties:
     534        // Force all properties to be applied as block styles.
     535        applyBlockStyle(m_style->style());
     536        break;
    538537    }
    539538}
  • trunk/WebCore/editing/ApplyStyleCommand.h

    r71556 r73416  
    3333
    3434class CSSPrimitiveValue;
     35class EditingStyle;
    3536class HTMLElement;
    3637class StyleChange;
     
    4849    typedef bool (*IsInlineElementToRemoveFunction)(const Element*);
    4950
    50     static PassRefPtr<ApplyStyleCommand> create(Document* document, CSSStyleDeclaration* style, EditAction action = EditActionChangeAttributes, EPropertyLevel level = PropertyDefault)
     51    static PassRefPtr<ApplyStyleCommand> create(Document* document, const EditingStyle* style, EditAction action = EditActionChangeAttributes, EPropertyLevel level = PropertyDefault)
    5152    {
    5253        return adoptRef(new ApplyStyleCommand(document, style, action, level));
    5354    }
    54     static PassRefPtr<ApplyStyleCommand> create(Document* document, CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction action = EditActionChangeAttributes, EPropertyLevel level = PropertyDefault)
     55    static PassRefPtr<ApplyStyleCommand> create(Document* document, const EditingStyle* style, const Position& start, const Position& end, EditAction action = EditActionChangeAttributes, EPropertyLevel level = PropertyDefault)
    5556    {
    5657        return adoptRef(new ApplyStyleCommand(document, style, start, end, action, level));
     
    6061        return adoptRef(new ApplyStyleCommand(element, removeOnly, action));
    6162    }
    62     static PassRefPtr<ApplyStyleCommand> create(Document* document, CSSStyleDeclaration* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction action = EditActionChangeAttributes)
     63    static PassRefPtr<ApplyStyleCommand> create(Document* document, const EditingStyle* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction action = EditActionChangeAttributes)
    6364    {
    6465        return adoptRef(new ApplyStyleCommand(document, style, isInlineElementToRemoveFunction, action));
     
    6667
    6768private:
    68     ApplyStyleCommand(Document*, CSSStyleDeclaration*, EditAction, EPropertyLevel);
    69     ApplyStyleCommand(Document*, CSSStyleDeclaration*, const Position& start, const Position& end, EditAction, EPropertyLevel);
     69    ApplyStyleCommand(Document*, const EditingStyle*, EditAction, EPropertyLevel);
     70    ApplyStyleCommand(Document*, const EditingStyle*, const Position& start, const Position& end, EditAction, EPropertyLevel);
    7071    ApplyStyleCommand(PassRefPtr<Element>, bool removeOnly, EditAction);
    71     ApplyStyleCommand(Document*, CSSStyleDeclaration*, bool (*isInlineElementToRemove)(const Element*), EditAction);
     72    ApplyStyleCommand(Document*, const EditingStyle*, bool (*isInlineElementToRemove)(const Element*), EditAction);
    7273
    7374    virtual void doApply();
    7475    virtual EditAction editingAction() const;
    75 
    76     CSSMutableStyleDeclaration* style() const { return m_style.get(); }
    7776
    7877    // style-removal helpers
     
    120119    Position endPosition();
    121120
    122     RefPtr<CSSMutableStyleDeclaration> m_style;
     121    RefPtr<EditingStyle> m_style;
    123122    EditAction m_editingAction;
    124123    EPropertyLevel m_propertyLevel;
  • trunk/WebCore/editing/CompositeEditCommand.cpp

    r73052 r73416  
    2929#include "AppendNodeCommand.h"
    3030#include "ApplyStyleCommand.h"
    31 #include "CSSComputedStyleDeclaration.h"
    32 #include "CSSMutableStyleDeclaration.h"
    3331#include "CharacterNames.h"
    3432#include "DeleteFromTextNodeCommand.h"
     
    106104}
    107105
    108 void CompositeEditCommand::applyStyle(CSSStyleDeclaration* style, EditAction editingAction)
     106void CompositeEditCommand::applyStyle(const EditingStyle* style, EditAction editingAction)
    109107{
    110108    applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));
    111109}
    112110
    113 void CompositeEditCommand::applyStyle(CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction)
     111void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction)
    114112{
    115113    applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end, editingAction));
     
    984982    bool selectionIsEmptyParagraph = endingSelection().isCaret() && isStartOfParagraph(endingSelection().visibleStart()) && isEndOfParagraph(endingSelection().visibleStart());
    985983    if (styleInEmptyParagraph && selectionIsEmptyParagraph)
    986         applyStyle(styleInEmptyParagraph->style());
     984        applyStyle(styleInEmptyParagraph.get());
    987985
    988986    if (preserveSelection && startIndex != -1) {
     
    10571055    style->prepareToApplyAt(endingSelection().start());
    10581056    if (!style->isEmpty())
    1059         applyStyle(style->style());
     1057        applyStyle(style.get());
    10601058
    10611059    return true;
  • trunk/WebCore/editing/CompositeEditCommand.h

    r69868 r73416  
    3434
    3535class CSSStyleDeclaration;
     36class EditingStyle;
    3637class HTMLElement;
    3738class StyledElement;
     
    5253    void appendNode(PassRefPtr<Node>, PassRefPtr<Element> parent);
    5354    void applyCommandToComposite(PassRefPtr<EditCommand>);
    54     void applyStyle(CSSStyleDeclaration*, EditAction = EditActionChangeAttributes);
    55     void applyStyle(CSSStyleDeclaration*, const Position& start, const Position& end, EditAction = EditActionChangeAttributes);
     55    void applyStyle(const EditingStyle*, EditAction = EditActionChangeAttributes);
     56    void applyStyle(const EditingStyle*, const Position& start, const Position& end, EditAction = EditActionChangeAttributes);
    5657    void applyStyledElement(PassRefPtr<Element>);
    5758    void removeStyledElement(PassRefPtr<Element>);
  • trunk/WebCore/editing/DeleteSelectionCommand.cpp

    r72777 r73416  
    692692
    693693        setEndingSelection(visibleEnd);
    694         applyStyle(m_typingStyle->style(), EditActionUnspecified);
     694        applyStyle(m_typingStyle.get(), EditActionUnspecified);
    695695        // applyStyle can destroy the placeholder that was at m_endingPosition if it needs to
    696696        // move it, but it will set an endingSelection() at [movedPlaceholder, 0] if it does so.
  • trunk/WebCore/editing/EditCommand.cpp

    r58551 r73416  
    2828
    2929#include "CompositeEditCommand.h"
    30 #include "CSSComputedStyleDeclaration.h"
    31 #include "CSSMutableStyleDeclaration.h"
    3230#include "DeleteButtonController.h"
    3331#include "Document.h"
  • trunk/WebCore/editing/EditCommand.h

    r58551 r73416  
    3434
    3535class CompositeEditCommand;
    36 class CSSMutableStyleDeclaration;
    3736
    3837class EditCommand : public RefCounted<EditCommand> {
  • trunk/WebCore/editing/EditingStyle.cpp

    r72573 r73416  
    104104}
    105105
     106EditingStyle::~EditingStyle()
     107{
     108}
     109
    106110void EditingStyle::init(Node* node)
    107111{
     
    178182}
    179183
     184void EditingStyle::overrideWithStyle(const CSSMutableStyleDeclaration* style)
     185{
     186    if (!style || !style->length())
     187        return;
     188    if (!m_mutableStyle)
     189        m_mutableStyle = CSSMutableStyleDeclaration::create();
     190    m_mutableStyle->merge(style);
     191}
     192
    180193void EditingStyle::clear()
    181194{
    182195    m_mutableStyle.clear();
    183196    m_shouldUseFixedDefaultFontSize = false;
     197}
     198
     199PassRefPtr<EditingStyle> EditingStyle::copy() const
     200{
     201    RefPtr<EditingStyle> copy = EditingStyle::create();
     202    if (m_mutableStyle)
     203        copy->m_mutableStyle = m_mutableStyle->copy();
     204    copy->m_shouldUseFixedDefaultFontSize = m_shouldUseFixedDefaultFontSize;
     205    return copy;
     206}
     207
     208PassRefPtr<EditingStyle> EditingStyle::extractAndRemoveBlockProperties()
     209{
     210    RefPtr<EditingStyle> blockProperties = EditingStyle::create();
     211    if (!m_mutableStyle)
     212        return blockProperties;
     213
     214    blockProperties->m_mutableStyle = m_mutableStyle->copyBlockProperties();
     215    m_mutableStyle->removeBlockProperties();
     216
     217    return blockProperties;
    184218}
    185219
  • trunk/WebCore/editing/EditingStyle.h

    r72573 r73416  
    3232#define EditingStyle_h
    3333
    34 #include "CSSMutableStyleDeclaration.h"
    3534#include "Document.h"
    3635#include "Position.h"
     
    4039class CSSStyleDeclaration;
    4140class CSSComputedStyleDeclaration;
     41class CSSMutableStyleDeclaration;
    4242
    4343enum WritingDirection { NaturalWritingDirection, LeftToRightWritingDirection, RightToLeftWritingDirection };
     
    6868    }
    6969
     70    ~EditingStyle();
     71
    7072    CSSMutableStyleDeclaration* style() { return m_mutableStyle.get(); }
    7173    bool textDirection(WritingDirection&) const;
    7274    bool isEmpty() const;
    7375    void setStyle(PassRefPtr<CSSMutableStyleDeclaration>);
     76    void overrideWithStyle(const CSSMutableStyleDeclaration*);
    7477    void clear();
     78    PassRefPtr<EditingStyle> copy() const;
     79    PassRefPtr<EditingStyle> extractAndRemoveBlockProperties();
    7580    void removeBlockProperties();
    76     void removeStyleAddedByNode(Node* node);
    77     void removeStyleConflictingWithStyleOfNode(Node* node);
     81    void removeStyleAddedByNode(Node*);
     82    void removeStyleConflictingWithStyleOfNode(Node*);
    7883    void removeNonEditingProperties();
    7984    void prepareToApplyAt(const Position&, ShouldPreserveWritingDirection = DoNotPreserveWritingDirection);
  • trunk/WebCore/editing/Editor.cpp

    r73337 r73416  
    893893    case VisibleSelection::RangeSelection:
    894894        if (style)
    895             applyCommand(ApplyStyleCommand::create(m_frame->document(), style, editingAction));
     895            applyCommand(ApplyStyleCommand::create(m_frame->document(), EditingStyle::create(style).get(), editingAction));
    896896        break;
    897897    }
     
    912912    case VisibleSelection::RangeSelection:
    913913        if (style)
    914             applyCommand(ApplyStyleCommand::create(m_frame->document(), style, editingAction, ApplyStyleCommand::ForceBlockProperties));
     914            applyCommand(ApplyStyleCommand::create(m_frame->document(), EditingStyle::create(style).get(), editingAction, ApplyStyleCommand::ForceBlockProperties));
    915915        break;
    916916    }
     
    30873087
    30883088    // Calculate the current typing style.
    3089     RefPtr<CSSMutableStyleDeclaration> mutableStyle = style->makeMutable();
    3090     RefPtr<EditingStyle> typingStyle = m_frame->selection()->typingStyle();
    3091     if (typingStyle && typingStyle->style()) {
    3092         typingStyle->style()->merge(mutableStyle.get());
    3093         mutableStyle = typingStyle->style();
    3094     }
    3095 
    3096     RefPtr<CSSValue> unicodeBidi;
    3097     RefPtr<CSSValue> direction;
    3098     if (editingAction == EditActionSetWritingDirection) {
    3099         unicodeBidi = mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
    3100         direction = mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
    3101     }
    3102 
    3103     Node* node = m_frame->selection()->selection().visibleStart().deepEquivalent().node();
    3104     computedStyle(node)->diff(mutableStyle.get());
    3105 
    3106     if (editingAction == EditActionSetWritingDirection && unicodeBidi) {
    3107         ASSERT(unicodeBidi->isPrimitiveValue());
    3108         mutableStyle->setProperty(CSSPropertyUnicodeBidi, static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent());
    3109         if (direction) {
    3110             ASSERT(direction->isPrimitiveValue());
    3111             mutableStyle->setProperty(CSSPropertyDirection, static_cast<CSSPrimitiveValue*>(direction.get())->getIdent());
    3112         }
    3113     }
     3089    RefPtr<EditingStyle> typingStyle;
     3090    if (m_frame->selection()->typingStyle()) {
     3091        typingStyle = m_frame->selection()->typingStyle()->copy();
     3092        typingStyle->overrideWithStyle(style->makeMutable().get());
     3093    } else
     3094        typingStyle = EditingStyle::create(style);
     3095
     3096    typingStyle->prepareToApplyAt(m_frame->selection()->selection().visibleStart().deepEquivalent(), EditingStyle::PreserveWritingDirection);
    31143097
    31153098    // Handle block styles, substracting these from the typing style.
    3116     RefPtr<CSSMutableStyleDeclaration> blockStyle = mutableStyle->copyBlockProperties();
    3117     blockStyle->diff(mutableStyle.get());
    3118     if (blockStyle->length() > 0)
     3099    RefPtr<EditingStyle> blockStyle = typingStyle->extractAndRemoveBlockProperties();
     3100    if (!blockStyle->isEmpty())
    31193101        applyCommand(ApplyStyleCommand::create(m_frame->document(), blockStyle.get(), editingAction));
    31203102
    31213103    // Set the remaining style as the typing style.
    3122     m_frame->selection()->setTypingStyle(EditingStyle::create(mutableStyle.get()));
     3104    m_frame->selection()->setTypingStyle(typingStyle);
    31233105}
    31243106
  • trunk/WebCore/editing/InsertLineBreakCommand.cpp

    r72573 r73416  
    173173        // FIXME: We shouldn't always apply the typing style to the line break here,
    174174        // see <rdar://problem/5794462>.
    175         applyStyle(typingStyle->style(), firstDeepEditingPositionForNode(nodeToInsert.get()), lastDeepEditingPositionForNode(nodeToInsert.get()));
     175        applyStyle(typingStyle.get(), firstDeepEditingPositionForNode(nodeToInsert.get()), lastDeepEditingPositionForNode(nodeToInsert.get()));
    176176        // Even though this applyStyle operates on a Range, it still sets an endingSelection().
    177177        // It tries to set a VisibleSelection around the content it operated on. So, that VisibleSelection
  • trunk/WebCore/editing/InsertParagraphSeparatorCommand.cpp

    r71556 r73416  
    9999    m_style->prepareToApplyAt(endingSelection().start());
    100100    if (!m_style->isEmpty())
    101         applyStyle(m_style->style());
     101        applyStyle(m_style.get());
    102102}
    103103
  • trunk/WebCore/editing/InsertTextCommand.cpp

    r72573 r73416  
    194194        typingStyle->prepareToApplyAt(endPosition, EditingStyle::PreserveWritingDirection);
    195195        if (!typingStyle->isEmpty())
    196             applyStyle(typingStyle->style());
     196            applyStyle(typingStyle.get());
    197197    }
    198198
  • trunk/WebCore/editing/RemoveFormatCommand.cpp

    r71556 r73416  
    8888    RefPtr<EditingStyle> defaultStyle = EditingStyle::create(root);
    8989
    90     applyCommandToComposite(ApplyStyleCommand::create(document(), defaultStyle->style(), isElementForRemoveFormatCommand, editingAction()));
     90    applyCommandToComposite(ApplyStyleCommand::create(document(), defaultStyle.get(), isElementForRemoveFormatCommand, editingAction()));
    9191}
    9292
  • trunk/WebCore/editing/ReplaceSelectionCommand.cpp

    r71556 r73416  
    11441144        if (m_matchStyle) {
    11451145            ASSERT(m_insertionStyle);
    1146             applyStyle(m_insertionStyle->style(), start, end);
     1146            applyStyle(m_insertionStyle.get(), start, end);
    11471147        }   
    11481148       
  • trunk/WebCore/editing/SelectionController.cpp

    r72796 r73416  
    15911591}
    15921592
     1593PassRefPtr<CSSMutableStyleDeclaration> SelectionController::copyTypingStyle() const
     1594{
     1595    if (!m_typingStyle || !m_typingStyle->style())
     1596        return 0;
     1597    return m_typingStyle->style()->copy();
     1598}
     1599
    15931600bool SelectionController::shouldDeleteSelection(const VisibleSelection& selection) const
    15941601{
  • trunk/WebCore/editing/SelectionController.h

    r72573 r73416  
    3737namespace WebCore {
    3838
     39class CSSMutableStyleDeclaration;
    3940class Frame;
    40 class CSSMutableStyleDeclaration;
    4141class GraphicsContext;
    4242class HTMLFormElement;
     
    240240}
    241241
    242 inline PassRefPtr<CSSMutableStyleDeclaration> SelectionController::copyTypingStyle() const
    243 {
    244     if (!m_typingStyle || !m_typingStyle->style())
    245         return 0;
    246     return m_typingStyle->style()->copy();
    247 }
    248 
    249242inline void SelectionController::clearTypingStyle()
    250243{
Note: See TracChangeset for help on using the changeset viewer.