Reviewed by Ken.
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 19 Nov 2004 00:12:21 +0000 (00:12 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 19 Nov 2004 00:12:21 +0000 (00:12 +0000)
        - fixed <rdar://problem/3885744> crash with XMLHttpRequest test page (reported by KDE folks)

        * khtml/ecma/xmlhttprequest.cpp: (KJS::XMLHttpRequest::slotFinished):
        Rolled in fix from KDE; make sure to set job to 0 before calling changeState.

        - fixed <rdar://problem/3885729> attempting to modify a computed style does nothing, but should raise a DOM exception
        - fixed <rdar://problem/3885731> style declarations use too many malloc blocks; switch to QValueList
        - fixed <rdar://problem/3885739> DOM::NodeImpl accessor in DOM::Node class is hot; should be inlined
        - changed NodeImpl calls like replaceChild to always ref/deref the parameter; this is a better way to fix
          an entire category of leaks we have been fixing one by one recently
        - changed computed styles so they hold a reference to the DOM node; the old code could end up with a
          stale RenderObject pointer, although I never saw it do that in practice
        - implemented the length and item methods for computed styles
        - implemented querying additional properties in computed styles (29 more)

        * khtml/khtml_part.h: Update forward declaration of CSSMutableStyleDeclarationImpl since it's
        now a separate class rather than a typedef. Changed the parameter type of setTypingStyle to
        take a mutable style.
        * khtml/khtml_part.cpp:
        (KHTMLPart::setTypingStyle): Change parameter to take a mutable style.
        (KHTMLPart::applyStyle): Add code to make a mutable style in case we are passed
        a computed style; also change some types to mutable style.
        (updateState): Update iteration of CSSProperty objects in a style declaration to use
        the new valuesIterator interface.
        (KHTMLPart::selectionHasStyle): Add a call to makeMutable.
        (KHTMLPart::selectionStartHasStyle): Add call to makeMutable and update iteration.
        (editingStyle): Change type to mutable style, and simplify the style-creation calls,
        including accomodating the exception code that setCssText has now.
        (KHTMLPart::applyEditingStyleToElement): Change types to mutable style.
        (KHTMLPart::removeEditingStyleFromElement): Change code to call setChanged only if removing
        the style attributes really was a change, although it's not an important optimization it's
        good to do it right.

        * khtml/css/css_base.h: Remove unneeded setParsedValue method.
        * khtml/css/css_base.cpp: Remove unneeded setParsedValue method. All the places that were
        calling it were already removing the old property explicitly, so the code in here to remove
        the property again was redundant.

        * khtml/css/css_computedstyle.h: Updated virtual functions for changes to parameters in base class.
        Moved all the "set"-type functions so they are private. Store a node pointer instead of a renderer.
        * khtml/css/css_computedstyle.cpp:
        (DOM::CSSComputedStyleDeclarationImpl::CSSComputedStyleDeclarationImpl): Hold a reference to
        the node we compute style for, so we don't end up with a pointer to a deallocated RenderObject.
        Before we had no guarantee the object would outlast us.
        (DOM::CSSComputedStyleDeclarationImpl::setCssText): Add exception parameter, and set the
        exception to NO_MODIFICATION_ALLOWED_ERR.
        (DOM::CSSComputedStyleDeclarationImpl::getPropertyCSSValue): Update to use node pointer rather
        than renderer pointer. Added implementation for box-align, box-direction, box-flex, box-flex-group,
        box-lines, box-ordinal-group, box-orient, box-pack, caption-side, clear, cursor, direction,
        list-style-image, list-style-position, list-style-type, marquee-direction, marquee-repetition,
        marquee-style, user-modify, opacity, orphans, outline-style, page-break-after, page-break-before,
        page-break-inside, position, unicode-bidi, widows, z-index.
        (DOM::CSSComputedStyleDeclarationImpl::removeProperty): Add exception parameter, and set the
        exception to NO_MODIFICATION_ALLOWED_ERR.
        (DOM::CSSComputedStyleDeclarationImpl::setProperty): Ditto.
        (DOM::CSSComputedStyleDeclarationImpl::length): Implemented.
        (DOM::CSSComputedStyleDeclarationImpl::item): Implemented, calls getPropertyValue.
        (DOM::CSSComputedStyleDeclarationImpl::copyInheritableProperties): Changed return type to
        CSSMutableStyleDeclarationImpl.
        (DOM::CSSComputedStyleDeclarationImpl::copy): Added.
        (DOM::CSSComputedStyleDeclarationImpl::makeMutable): Added.

        * khtml/css/css_ruleimpl.h: Update forward declaration of CSSMutableStyleDeclarationImpl since it's
        now a separate class rather than a typedef.
        * khtml/css/cssparser.h: Ditto.

        * khtml/css/css_valueimpl.h: Refactor CSSStyleDeclarationImpl into two classes. New derived class
        CSSMutableStyleDeclarationImpl has the guts, and the base class has only some virtual functions.
        Removed a bunch of redundant stuff from other classes in this file too.
        (DOM::DashboardRegionImpl::setNext): Ref new before deref'ing old to handle the set-to-same case.
        (DOM::CSSProperty::CSSProperty): Added new overload so you can create a CSSProperty with initial values.
        (DOM::CSSProperty::operator=): Added.
        (DOM::CSSProperty::setValue): Use ref-before-deref pattern to simplify slightly.

        * khtml/css/css_valueimpl.cpp:
        (DOM::CSSStyleDeclarationImpl::CSSStyleDeclarationImpl): Remove uneeded things.
        (DOM::CSSStyleDeclarationImpl::isStyleDeclaration): Put here now that it's no longer inline.
        (DOM::CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl): Added.
        (DOM::CSSMutableStyleDeclarationImpl::operator=): Added.
        (DOM::CSSMutableStyleDeclarationImpl::~CSSMutableStyleDeclarationImpl): Updated.
        (DOM::CSSMutableStyleDeclarationImpl::getPropertyValue): Removed now-uneeded check.
        (DOM::CSSMutableStyleDeclarationImpl::get4Values): Moved here from base class.
        (DOM::CSSMutableStyleDeclarationImpl::getShortHandValue): Ditto.
        (DOM::CSSMutableStyleDeclarationImpl::getPropertyCSSValue): Update to use QValueList instead of QPtrList.
        (DOM::CSSMutableStyleDeclarationImpl::removeProperty): Added exception parameter, updated for QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::setChanged): Moved here from base class.
        (DOM::CSSMutableStyleDeclarationImpl::getPropertyPriority): Update to use QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::setProperty): Added more overloads to match new parameters.
        (DOM::CSSMutableStyleDeclarationImpl::setStringProperty): Update to use QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::setImageProperty): Ditto.
        (DOM::CSSMutableStyleDeclarationImpl::parseProperty): Remove unneeded initialization code due to QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::addParsedProperties): Added.
        (DOM::CSSMutableStyleDeclarationImpl::setLengthProperty): Moved here from base class.
        (DOM::CSSMutableStyleDeclarationImpl::length): Update to use QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::item): Moved here from base class.
        (DOM::CSSMutableStyleDeclarationImpl::cssText): Return empty string rather than null string when there are
        no styles in the list. Update to use QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::setCssText): Update to use QValueList and to take an exceptionCode
        parameter and set it.
        (DOM::CSSMutableStyleDeclarationImpl::merge): Update to use QValueList.
        (DOM::CSSStyleDeclarationImpl::diff): Update to use QValueList.
        (DOM::CSSMutableStyleDeclarationImpl::copyBlockProperties): Moved here from base class. Change return type.
        (DOM::CSSStyleDeclarationImpl::copyPropertiesInSet): Update to use QValueList and use stack, not new/delete.
        (DOM::CSSMutableStyleDeclarationImpl::makeMutable): Added.
        (DOM::CSSMutableStyleDeclarationImpl::copy): Added.

        * khtml/css/cssparser.cpp:
        (CSSParser::parseValue): Changed to use addParsedProperties.
        (CSSParser::parseDeclaration): Ditto.
        (CSSParser::createStyleDeclaration): Use new constructor to create declaration in a more efficient manner.

        * khtml/css/cssproperties.in: Removed unused font-size-adjust and -khtml-flow-mode.
        * khtml/css/cssproperties.c: Regenerated.
        * khtml/css/cssproperties.h: Regenerated.

        * khtml/css/cssstyleselector.cpp: (khtml::CSSStyleSelector::applyDeclarations):
        Updated to use QValueList interface to CSSMutableStyleDeclarationImpl.

        * khtml/dom/css_value.cpp:
        (DOM::CSSStyleDeclaration::cssText): Removed unneeded cast.
        (DOM::CSSStyleDeclaration::setCssText): Added exception code handling.
        (DOM::CSSStyleDeclaration::getPropertyValue): Changed to call getPropertyValue directly instead of
        first doing getPropertyCSSValue and then doing cssText.
        (DOM::CSSStyleDeclaration::getPropertyCSSValue): Removed unneeded cast.
        (DOM::CSSStyleDeclaration::removeProperty): Added exception code handling.
        (DOM::CSSStyleDeclaration::setProperty): Added exception code handling.
        (DOM::CSSStyleDeclaration::length): Removed unneeded cast.
        (DOM::CSSStyleDeclaration::item): Removed unneeded cast.
        (DOM::CSSStyleDeclaration::parentRule): Removed unneeded cast.
        (DOM::CSSValue::setCssText): Removed strange non-implementation (still not implemented).

        * khtml/dom/dom_node.h: Made isNull and handle functions inline.
        * khtml/dom/dom_node.cpp: Ditto.

        * khtml/editing/htmlediting.h: Change some types to mutable style.
        * khtml/editing/htmlediting.cpp:
        (khtml::EditCommandPtr::typingStyle): Change return type to mutable style.
        (khtml::EditCommandPtr::setTypingStyle): Change parameter to mutable style.
        (khtml::StyleChange::init): Convert parameter to mutable style. Update to use QValueList.
        (khtml::EditCommand::assignTypingStyle): Change parameter to mutable type.
        (khtml::EditCommand::setTypingStyle): Ditto.
        (khtml::ApplyStyleCommand::ApplyStyleCommand): Convert parameter to mutable style.
        (khtml::ApplyStyleCommand::doApply): Change local variables to mutable style.
        (khtml::ApplyStyleCommand::applyBlockStyle): Change parameter to mutable style.
        (khtml::ApplyStyleCommand::applyInlineStyle): Ditto.
        (khtml::ApplyStyleCommand::isHTMLStyleNode): Ditto.
        (khtml::ApplyStyleCommand::removeCSSStyle): Ditto. Also update to use QValueList.
        (khtml::ApplyStyleCommand::removeBlockStyle): Change parameter to mutable style.
        (khtml::ApplyStyleCommand::removeInlineStyle): Ditto.
        (khtml::ApplyStyleCommand::addBlockStyleIfNeeded): Ditto.
        (khtml::ApplyStyleCommand::addInlineStyleIfNeeded): Ditto.
        (khtml::InsertLineBreakCommand::doApply): Convert locals to mutable style.
        (khtml::InsertTextCommand::prepareForTextInsertion): Ditto.
        (khtml::RemoveCSSPropertyCommand::RemoveCSSPropertyCommand): Convert parameter to mutable style.

        * khtml/editing/jsediting.cpp: Convert types to mutable styles where we create styles.
        * khtml/html/html_baseimpl.h: Change type to mutable style.
        * khtml/html/html_baseimpl.cpp: (HTMLBodyElementImpl::createLinkDecl): Ditto.

        * khtml/html/html_elementimpl.h: Make CSSMappedAttributeDeclarationImpl use the mutable style
        class as a base class, and change types to mutable style as needed.
        * khtml/html/html_elementimpl.cpp:
        (HTMLElementImpl::createInlineStyleDecl): Change type to mutable style.
        (HTMLElementImpl::parseHTMLAttribute): Call parseProperty method.
        (HTMLElementImpl::getInlineStyleDecl): Change type to mutable style.
        (HTMLElementImpl::additionalAttributeStyleDecl): Ditto.
        (HTMLElementImpl::createContextualFragment): Add ref/deref to fix potential node leak.
        (HTMLElementImpl::setInnerHTML): Remove ref/deref pair because this leak is now fixed by changes
        to appendChild.
        (HTMLElementImpl::setOuterHTML): Remove ref/deref pair because this leak is now fixed by changes
        to replaceChild.

        * khtml/html/html_tableimpl.h: Change types to mutable style.
        * khtml/html/html_tableimpl.cpp:
        (HTMLTableElementImpl::additionalAttributeStyleDecl): Change type to mutable style.
        (HTMLTableElementImpl::getSharedCellDecl): Change type to mutable style.
        (HTMLTableCellElementImpl::additionalAttributeStyleDecl): Change type to mutable style.

        * khtml/html/htmlparser.cpp:
        (KHTMLParser::parseToken): Use a local variable to protect the node by ref'ing it. This is better
        than using an explicit delete to make the node go away, and is required for compatibility with the
        changes to the NodeImpl functions.
        (KHTMLParser::insertNode): Ditto.
        (KHTMLParser::createHead): Get rid of explicit delete, no longer needed because of changes to
        the NodeImpl functions.

        * khtml/xml/dom_docimpl.cpp: (DocumentImpl::createCSSStyleDeclaration): Call simpler constructor
        now that there's no need to make the property list explictly.

        * kwq/DOM-CSS.mm:
        (-[DOMCSSStyleDeclaration setCssText:]): Raise exception when appropriate.
        (-[DOMCSSStyleDeclaration removeProperty:]): Ditto.
        (-[DOMCSSStyleDeclaration setProperty:::]): Dito.

        * khtml/xml/dom_nodeimpl.cpp:
        (NodeImpl::insertBefore): Always do a ref/deref, so callers don't have to worry about whether the
        function succeeded or not for ownership purposes.
        (NodeImpl::replaceChild): Ditto.
        (NodeImpl::appendChild): Ditto.
        (NodeBaseImpl::insertBefore): Ditto.
        (NodeBaseImpl::replaceChild): Ditto.
        (NodeBaseImpl::appendChild): Ditto.
        (NodeBaseImpl::addChild): Ditto.

        * WebCore-tests.exp: Removed CSSStyleDeclaration::length; not sure why it was in here.
        * WebCore-combined.exp: Regenerated.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@8041 268f45cc-cd09-0410-ab3c-d52691b4dbfc

35 files changed:
WebCore/ChangeLog-2005-08-23
WebCore/WebCore-combined.exp
WebCore/WebCore-tests.exp
WebCore/khtml/css/css_base.cpp
WebCore/khtml/css/css_base.h
WebCore/khtml/css/css_computedstyle.cpp
WebCore/khtml/css/css_computedstyle.h
WebCore/khtml/css/css_ruleimpl.h
WebCore/khtml/css/css_valueimpl.cpp
WebCore/khtml/css/css_valueimpl.h
WebCore/khtml/css/cssparser.cpp
WebCore/khtml/css/cssparser.h
WebCore/khtml/css/cssproperties.c
WebCore/khtml/css/cssproperties.h
WebCore/khtml/css/cssproperties.in
WebCore/khtml/css/cssstyleselector.cpp
WebCore/khtml/dom/css_value.cpp
WebCore/khtml/dom/dom_node.cpp
WebCore/khtml/dom/dom_node.h
WebCore/khtml/ecma/xmlhttprequest.cpp
WebCore/khtml/editing/htmlediting.cpp
WebCore/khtml/editing/htmlediting.h
WebCore/khtml/editing/jsediting.cpp
WebCore/khtml/html/html_baseimpl.cpp
WebCore/khtml/html/html_baseimpl.h
WebCore/khtml/html/html_elementimpl.cpp
WebCore/khtml/html/html_elementimpl.h
WebCore/khtml/html/html_tableimpl.cpp
WebCore/khtml/html/html_tableimpl.h
WebCore/khtml/html/htmlparser.cpp
WebCore/khtml/khtml_part.cpp
WebCore/khtml/khtml_part.h
WebCore/khtml/xml/dom_docimpl.cpp
WebCore/khtml/xml/dom_nodeimpl.cpp
WebCore/kwq/DOM-CSS.mm

index 5b5e9203dee79b23b618230d5a8bcc7e09a0844a..99e54b94fe9d6e9febb3b3b00bfbeced61e0d3f8 100644 (file)
@@ -1,3 +1,214 @@
+2004-11-17  Darin Adler  <darin@apple.com>
+
+        Reviewed by Ken.
+
+        - fixed <rdar://problem/3885744> crash with XMLHttpRequest test page (reported by KDE folks)
+
+        * khtml/ecma/xmlhttprequest.cpp: (KJS::XMLHttpRequest::slotFinished):
+        Rolled in fix from KDE; make sure to set job to 0 before calling changeState.
+
+        - fixed <rdar://problem/3885729> attempting to modify a computed style does nothing, but should raise a DOM exception
+        - fixed <rdar://problem/3885731> style declarations use too many malloc blocks; switch to QValueList
+        - fixed <rdar://problem/3885739> DOM::NodeImpl accessor in DOM::Node class is hot; should be inlined
+        - changed NodeImpl calls like replaceChild to always ref/deref the parameter; this is a better way to fix
+          an entire category of leaks we have been fixing one by one recently
+        - changed computed styles so they hold a reference to the DOM node; the old code could end up with a
+          stale RenderObject pointer, although I never saw it do that in practice
+        - implemented the length and item methods for computed styles
+        - implemented querying additional properties in computed styles (29 more)
+
+        * khtml/khtml_part.h: Update forward declaration of CSSMutableStyleDeclarationImpl since it's
+        now a separate class rather than a typedef. Changed the parameter type of setTypingStyle to
+        take a mutable style.
+        * khtml/khtml_part.cpp:
+        (KHTMLPart::setTypingStyle): Change parameter to take a mutable style.
+        (KHTMLPart::applyStyle): Add code to make a mutable style in case we are passed
+        a computed style; also change some types to mutable style.
+        (updateState): Update iteration of CSSProperty objects in a style declaration to use
+        the new valuesIterator interface.
+        (KHTMLPart::selectionHasStyle): Add a call to makeMutable.
+        (KHTMLPart::selectionStartHasStyle): Add call to makeMutable and update iteration.
+        (editingStyle): Change type to mutable style, and simplify the style-creation calls,
+        including accomodating the exception code that setCssText has now.
+        (KHTMLPart::applyEditingStyleToElement): Change types to mutable style.
+        (KHTMLPart::removeEditingStyleFromElement): Change code to call setChanged only if removing
+        the style attributes really was a change, although it's not an important optimization it's
+        good to do it right.
+
+        * khtml/css/css_base.h: Remove unneeded setParsedValue method.
+        * khtml/css/css_base.cpp: Remove unneeded setParsedValue method. All the places that were
+        calling it were already removing the old property explicitly, so the code in here to remove
+        the property again was redundant.
+
+        * khtml/css/css_computedstyle.h: Updated virtual functions for changes to parameters in base class.
+        Moved all the "set"-type functions so they are private. Store a node pointer instead of a renderer.
+        * khtml/css/css_computedstyle.cpp:
+        (DOM::CSSComputedStyleDeclarationImpl::CSSComputedStyleDeclarationImpl): Hold a reference to
+        the node we compute style for, so we don't end up with a pointer to a deallocated RenderObject.
+        Before we had no guarantee the object would outlast us.
+        (DOM::CSSComputedStyleDeclarationImpl::setCssText): Add exception parameter, and set the
+        exception to NO_MODIFICATION_ALLOWED_ERR.
+        (DOM::CSSComputedStyleDeclarationImpl::getPropertyCSSValue): Update to use node pointer rather
+        than renderer pointer. Added implementation for box-align, box-direction, box-flex, box-flex-group,
+        box-lines, box-ordinal-group, box-orient, box-pack, caption-side, clear, cursor, direction,
+        list-style-image, list-style-position, list-style-type, marquee-direction, marquee-repetition,
+        marquee-style, user-modify, opacity, orphans, outline-style, page-break-after, page-break-before,
+        page-break-inside, position, unicode-bidi, widows, z-index.
+        (DOM::CSSComputedStyleDeclarationImpl::removeProperty): Add exception parameter, and set the
+        exception to NO_MODIFICATION_ALLOWED_ERR.
+        (DOM::CSSComputedStyleDeclarationImpl::setProperty): Ditto.
+        (DOM::CSSComputedStyleDeclarationImpl::length): Implemented.
+        (DOM::CSSComputedStyleDeclarationImpl::item): Implemented, calls getPropertyValue.
+        (DOM::CSSComputedStyleDeclarationImpl::copyInheritableProperties): Changed return type to
+        CSSMutableStyleDeclarationImpl.
+        (DOM::CSSComputedStyleDeclarationImpl::copy): Added.
+        (DOM::CSSComputedStyleDeclarationImpl::makeMutable): Added.
+
+        * khtml/css/css_ruleimpl.h: Update forward declaration of CSSMutableStyleDeclarationImpl since it's
+        now a separate class rather than a typedef.
+        * khtml/css/cssparser.h: Ditto.
+
+        * khtml/css/css_valueimpl.h: Refactor CSSStyleDeclarationImpl into two classes. New derived class
+        CSSMutableStyleDeclarationImpl has the guts, and the base class has only some virtual functions.
+        Removed a bunch of redundant stuff from other classes in this file too.
+        (DOM::DashboardRegionImpl::setNext): Ref new before deref'ing old to handle the set-to-same case.
+        (DOM::CSSProperty::CSSProperty): Added new overload so you can create a CSSProperty with initial values.
+        (DOM::CSSProperty::operator=): Added.
+        (DOM::CSSProperty::setValue): Use ref-before-deref pattern to simplify slightly.
+
+        * khtml/css/css_valueimpl.cpp:
+        (DOM::CSSStyleDeclarationImpl::CSSStyleDeclarationImpl): Remove uneeded things.
+        (DOM::CSSStyleDeclarationImpl::isStyleDeclaration): Put here now that it's no longer inline.
+        (DOM::CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl): Added.
+        (DOM::CSSMutableStyleDeclarationImpl::operator=): Added.
+        (DOM::CSSMutableStyleDeclarationImpl::~CSSMutableStyleDeclarationImpl): Updated.
+        (DOM::CSSMutableStyleDeclarationImpl::getPropertyValue): Removed now-uneeded check.
+        (DOM::CSSMutableStyleDeclarationImpl::get4Values): Moved here from base class.
+        (DOM::CSSMutableStyleDeclarationImpl::getShortHandValue): Ditto.
+        (DOM::CSSMutableStyleDeclarationImpl::getPropertyCSSValue): Update to use QValueList instead of QPtrList.
+        (DOM::CSSMutableStyleDeclarationImpl::removeProperty): Added exception parameter, updated for QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::setChanged): Moved here from base class.
+        (DOM::CSSMutableStyleDeclarationImpl::getPropertyPriority): Update to use QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::setProperty): Added more overloads to match new parameters.
+        (DOM::CSSMutableStyleDeclarationImpl::setStringProperty): Update to use QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::setImageProperty): Ditto.
+        (DOM::CSSMutableStyleDeclarationImpl::parseProperty): Remove unneeded initialization code due to QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::addParsedProperties): Added.
+        (DOM::CSSMutableStyleDeclarationImpl::setLengthProperty): Moved here from base class.
+        (DOM::CSSMutableStyleDeclarationImpl::length): Update to use QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::item): Moved here from base class.
+        (DOM::CSSMutableStyleDeclarationImpl::cssText): Return empty string rather than null string when there are
+        no styles in the list. Update to use QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::setCssText): Update to use QValueList and to take an exceptionCode
+        parameter and set it.
+        (DOM::CSSMutableStyleDeclarationImpl::merge): Update to use QValueList.
+        (DOM::CSSStyleDeclarationImpl::diff): Update to use QValueList.
+        (DOM::CSSMutableStyleDeclarationImpl::copyBlockProperties): Moved here from base class. Change return type.
+        (DOM::CSSStyleDeclarationImpl::copyPropertiesInSet): Update to use QValueList and use stack, not new/delete.
+        (DOM::CSSMutableStyleDeclarationImpl::makeMutable): Added.
+        (DOM::CSSMutableStyleDeclarationImpl::copy): Added.
+
+        * khtml/css/cssparser.cpp:
+        (CSSParser::parseValue): Changed to use addParsedProperties.
+        (CSSParser::parseDeclaration): Ditto.
+        (CSSParser::createStyleDeclaration): Use new constructor to create declaration in a more efficient manner.
+
+        * khtml/css/cssproperties.in: Removed unused font-size-adjust and -khtml-flow-mode.
+        * khtml/css/cssproperties.c: Regenerated.
+        * khtml/css/cssproperties.h: Regenerated.
+
+        * khtml/css/cssstyleselector.cpp: (khtml::CSSStyleSelector::applyDeclarations):
+        Updated to use QValueList interface to CSSMutableStyleDeclarationImpl.
+
+        * khtml/dom/css_value.cpp:
+        (DOM::CSSStyleDeclaration::cssText): Removed unneeded cast.
+        (DOM::CSSStyleDeclaration::setCssText): Added exception code handling.
+        (DOM::CSSStyleDeclaration::getPropertyValue): Changed to call getPropertyValue directly instead of
+        first doing getPropertyCSSValue and then doing cssText.
+        (DOM::CSSStyleDeclaration::getPropertyCSSValue): Removed unneeded cast.
+        (DOM::CSSStyleDeclaration::removeProperty): Added exception code handling. 
+        (DOM::CSSStyleDeclaration::setProperty): Added exception code handling.
+        (DOM::CSSStyleDeclaration::length): Removed unneeded cast.
+        (DOM::CSSStyleDeclaration::item): Removed unneeded cast.
+        (DOM::CSSStyleDeclaration::parentRule): Removed unneeded cast.
+        (DOM::CSSValue::setCssText): Removed strange non-implementation (still not implemented).
+
+        * khtml/dom/dom_node.h: Made isNull and handle functions inline.
+        * khtml/dom/dom_node.cpp: Ditto.
+
+        * khtml/editing/htmlediting.h: Change some types to mutable style.
+        * khtml/editing/htmlediting.cpp:
+        (khtml::EditCommandPtr::typingStyle): Change return type to mutable style.
+        (khtml::EditCommandPtr::setTypingStyle): Change parameter to mutable style.
+        (khtml::StyleChange::init): Convert parameter to mutable style. Update to use QValueList.
+        (khtml::EditCommand::assignTypingStyle): Change parameter to mutable type.
+        (khtml::EditCommand::setTypingStyle): Ditto.
+        (khtml::ApplyStyleCommand::ApplyStyleCommand): Convert parameter to mutable style.
+        (khtml::ApplyStyleCommand::doApply): Change local variables to mutable style.
+        (khtml::ApplyStyleCommand::applyBlockStyle): Change parameter to mutable style.
+        (khtml::ApplyStyleCommand::applyInlineStyle): Ditto.
+        (khtml::ApplyStyleCommand::isHTMLStyleNode): Ditto.
+        (khtml::ApplyStyleCommand::removeCSSStyle): Ditto. Also update to use QValueList.
+        (khtml::ApplyStyleCommand::removeBlockStyle): Change parameter to mutable style.
+        (khtml::ApplyStyleCommand::removeInlineStyle): Ditto.
+        (khtml::ApplyStyleCommand::addBlockStyleIfNeeded): Ditto.
+        (khtml::ApplyStyleCommand::addInlineStyleIfNeeded): Ditto.
+        (khtml::InsertLineBreakCommand::doApply): Convert locals to mutable style.
+        (khtml::InsertTextCommand::prepareForTextInsertion): Ditto.
+        (khtml::RemoveCSSPropertyCommand::RemoveCSSPropertyCommand): Convert parameter to mutable style.
+
+        * khtml/editing/jsediting.cpp: Convert types to mutable styles where we create styles.
+        * khtml/html/html_baseimpl.h: Change type to mutable style.
+        * khtml/html/html_baseimpl.cpp: (HTMLBodyElementImpl::createLinkDecl): Ditto.
+
+        * khtml/html/html_elementimpl.h: Make CSSMappedAttributeDeclarationImpl use the mutable style
+        class as a base class, and change types to mutable style as needed.
+        * khtml/html/html_elementimpl.cpp:
+        (HTMLElementImpl::createInlineStyleDecl): Change type to mutable style.
+        (HTMLElementImpl::parseHTMLAttribute): Call parseProperty method.
+        (HTMLElementImpl::getInlineStyleDecl): Change type to mutable style.
+        (HTMLElementImpl::additionalAttributeStyleDecl): Ditto.
+        (HTMLElementImpl::createContextualFragment): Add ref/deref to fix potential node leak.
+        (HTMLElementImpl::setInnerHTML): Remove ref/deref pair because this leak is now fixed by changes
+        to appendChild.
+        (HTMLElementImpl::setOuterHTML): Remove ref/deref pair because this leak is now fixed by changes
+        to replaceChild.
+
+        * khtml/html/html_tableimpl.h: Change types to mutable style.
+        * khtml/html/html_tableimpl.cpp:
+        (HTMLTableElementImpl::additionalAttributeStyleDecl): Change type to mutable style.
+        (HTMLTableElementImpl::getSharedCellDecl): Change type to mutable style.
+        (HTMLTableCellElementImpl::additionalAttributeStyleDecl): Change type to mutable style.
+
+        * khtml/html/htmlparser.cpp:
+        (KHTMLParser::parseToken): Use a local variable to protect the node by ref'ing it. This is better
+        than using an explicit delete to make the node go away, and is required for compatibility with the
+        changes to the NodeImpl functions.
+        (KHTMLParser::insertNode): Ditto.
+        (KHTMLParser::createHead): Get rid of explicit delete, no longer needed because of changes to
+        the NodeImpl functions.
+
+        * khtml/xml/dom_docimpl.cpp: (DocumentImpl::createCSSStyleDeclaration): Call simpler constructor
+        now that there's no need to make the property list explictly.
+
+        * kwq/DOM-CSS.mm:
+        (-[DOMCSSStyleDeclaration setCssText:]): Raise exception when appropriate.
+        (-[DOMCSSStyleDeclaration removeProperty:]): Ditto.
+        (-[DOMCSSStyleDeclaration setProperty:::]): Dito.
+
+        * khtml/xml/dom_nodeimpl.cpp:
+        (NodeImpl::insertBefore): Always do a ref/deref, so callers don't have to worry about whether the
+        function succeeded or not for ownership purposes.
+        (NodeImpl::replaceChild): Ditto.
+        (NodeImpl::appendChild): Ditto.
+        (NodeBaseImpl::insertBefore): Ditto.
+        (NodeBaseImpl::replaceChild): Ditto.
+        (NodeBaseImpl::appendChild): Ditto.
+        (NodeBaseImpl::addChild): Ditto.
+
+        * WebCore-tests.exp: Removed CSSStyleDeclaration::length; not sure why it was in here.
+        * WebCore-combined.exp: Regenerated.
+
 2004-11-18  Maciej Stachowiak  <mjs@apple.com>
 
         still even more build fixing
 2004-11-18  Maciej Stachowiak  <mjs@apple.com>
 
         still even more build fixing
index 4fbe20ad20663059cac13e633f07aa3531b16d2d..16543c17d25cedf12b32afdd268f0ea590879da7 100644 (file)
@@ -320,7 +320,6 @@ __ZNK22KWQPtrDictIteratorImpl5countEv
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
-__ZNK3DOM23CSSStyleDeclarationImpl6lengthEv
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
index 6939209ab9416ad6e168c8e9a218171c8b682233..fbdeb482097c409ed475beea5f7943ea0f053716 100644 (file)
@@ -208,7 +208,6 @@ __ZNK22KWQPtrDictIteratorImpl5countEv
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
-__ZNK3DOM23CSSStyleDeclarationImpl6lengthEv
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
index 0df4d3a72fba3610a5eeac57f297366bfe420c9c..8d079eeb0db9a7a19190af81660230138d3cdeae 100644 (file)
@@ -75,32 +75,6 @@ DOMString StyleBaseImpl::baseURL()
     return doc->baseURL();
 }
 
     return doc->baseURL();
 }
 
-void StyleBaseImpl::setParsedValue(int propId, const CSSValueImpl *parsedValue,
-                                  bool important, QPtrList<CSSProperty> *propList)
-{
-    QPtrListIterator<CSSProperty> propIt(*propList);
-    propIt.toLast(); // just remove the top one - not sure what should happen if we have multiple instances of the property
-    while (propIt.current() &&
-           ( propIt.current()->m_id != propId ||
-             propIt.current()->m_bImportant != important) )
-        --propIt;
-    if (propIt.current())
-        propList->removeRef(propIt.current());
-
-    CSSProperty *prop = new CSSProperty();
-    prop->m_id = propId;
-    prop->setValue((CSSValueImpl *) parsedValue);
-    prop->m_bImportant = important;
-    
-    propList->append(prop);
-#ifdef CSS_DEBUG
-    kdDebug( 6080 ) << "added property: " << getPropertyName(propId).string()
-                    // non implemented yet << ", value: " << parsedValue->cssText().string()
-                    << " important: " << prop->m_bImportant
-                    << " nonCSS: " << prop->nonCSSHint << endl;
-#endif
-}
-
 // ------------------------------------------------------------------------------
 
 StyleListImpl::~StyleListImpl()
 // ------------------------------------------------------------------------------
 
 StyleListImpl::~StyleListImpl()
index 97fe7bd4c08d8d41c05ce905bcd83d51c9db954c..ead924187004c39f9adc51c1b396cefaa4f97117 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
- * Copyright (C) 2002 Apple Computer, Inc.
+ * Copyright (C) 2004 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -19,9 +19,8 @@
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
- *
- * $Id$
  */
  */
+
 #ifndef _CSS_BASE_H
 #define _CSS_BASE_H
 
 #ifndef _CSS_BASE_H
 #define _CSS_BASE_H
 
@@ -216,9 +215,6 @@ namespace DOM {
 
        void setParent(StyleBaseImpl *parent) { m_parent = parent; }
 
 
        void setParent(StyleBaseImpl *parent) { m_parent = parent; }
 
-       static void setParsedValue(int propId, const CSSValueImpl *parsedValue,
-                                  bool important, QPtrList<CSSProperty> *propList);
-
        virtual bool parseString(const DOMString &/*cssString*/, bool = false) { return false; }
 
        virtual void checkLoaded();
        virtual bool parseString(const DOMString &/*cssString*/, bool = false) { return false; }
 
        virtual void checkLoaded();
index c43aa5e7eb3d6a24b4714981ec45c6cd009e1c23..935085c975b7f7f4386662c8900cbb7b3cf72a97 100644 (file)
@@ -2,7 +2,7 @@
  * css_computedstyle.cpp
  *
  * Copyright (C)  2004  Zack Rusin <zack@kde.org>
  * css_computedstyle.cpp
  *
  * Copyright (C)  2004  Zack Rusin <zack@kde.org>
- * Copyright (C)  2004  Apple Computer, Inc.
+ * Copyright (C) 2004 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  * 02111-1307  USA
  */
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  * 02111-1307  USA
  */
+
 #include "css_computedstyle.h"
 
 #include "cssproperties.h"
 #include "cssvalues.h"
 #include "dom_atomicstring.h"
 #include "css_computedstyle.h"
 
 #include "cssproperties.h"
 #include "cssvalues.h"
 #include "dom_atomicstring.h"
+#include "dom_exception.h"
 #include "dom_string.h"
 #include "font.h"
 #include "khtmllayout.h"
 #include "dom_string.h"
 #include "font.h"
 #include "khtmllayout.h"
@@ -43,16 +45,120 @@ using khtml::Font;
 using khtml::FontDef;
 using khtml::Length;
 using khtml::LengthBox;
 using khtml::FontDef;
 using khtml::Length;
 using khtml::LengthBox;
+using khtml::RenderObject;
 using khtml::RenderStyle;
 using khtml::ShadowData;
 using khtml::StyleDashboardRegion;
 
 namespace DOM {
 
 using khtml::RenderStyle;
 using khtml::ShadowData;
 using khtml::StyleDashboardRegion;
 
 namespace DOM {
 
+// List of all properties we know how to compute, omitting shorthands.
+static const int computedProperties[] = {
+    CSS_PROP_BACKGROUND_COLOR,
+    CSS_PROP_BACKGROUND_IMAGE,
+    CSS_PROP_BACKGROUND_REPEAT,
+    CSS_PROP_BACKGROUND_ATTACHMENT,
+    CSS_PROP_BACKGROUND_POSITION,
+    CSS_PROP_BACKGROUND_POSITION_X,
+    CSS_PROP_BACKGROUND_POSITION_Y,
+    CSS_PROP_BORDER_COLLAPSE,
+    CSS_PROP_BORDER_SPACING,
+    CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING,
+    CSS_PROP__KHTML_BORDER_VERTICAL_SPACING,
+    CSS_PROP_BORDER_TOP_COLOR,
+    CSS_PROP_BORDER_RIGHT_COLOR,
+    CSS_PROP_BORDER_BOTTOM_COLOR,
+    CSS_PROP_BORDER_LEFT_COLOR,
+    CSS_PROP_BORDER_TOP_STYLE,
+    CSS_PROP_BORDER_RIGHT_STYLE,
+    CSS_PROP_BORDER_BOTTOM_STYLE,
+    CSS_PROP_BORDER_LEFT_STYLE,
+    CSS_PROP_BORDER_TOP_WIDTH,
+    CSS_PROP_BORDER_RIGHT_WIDTH,
+    CSS_PROP_BORDER_BOTTOM_WIDTH,
+    CSS_PROP_BORDER_LEFT_WIDTH,
+    CSS_PROP_BOTTOM,
+    CSS_PROP__KHTML_BOX_ALIGN,
+    CSS_PROP__KHTML_BOX_DIRECTION,
+    CSS_PROP__KHTML_BOX_FLEX,
+    CSS_PROP__KHTML_BOX_FLEX_GROUP,
+    CSS_PROP__KHTML_BOX_LINES,
+    CSS_PROP__KHTML_BOX_ORDINAL_GROUP,
+    CSS_PROP__KHTML_BOX_ORIENT,
+    CSS_PROP__KHTML_BOX_PACK,
+    CSS_PROP_CAPTION_SIDE,
+    CSS_PROP_CLEAR,
+    CSS_PROP_COLOR,
+    CSS_PROP_CURSOR,
+    CSS_PROP__APPLE_DASHBOARD_REGION,
+    CSS_PROP_DIRECTION,
+    CSS_PROP_DISPLAY,
+    CSS_PROP_EMPTY_CELLS,
+    CSS_PROP_FLOAT,
+    CSS_PROP_FONT_FAMILY,
+    CSS_PROP_FONT_SIZE,
+    CSS_PROP_FONT_STYLE,
+    CSS_PROP_FONT_VARIANT,
+    CSS_PROP_FONT_WEIGHT,
+    CSS_PROP_HEIGHT,
+    CSS_PROP_LEFT,
+    CSS_PROP_LETTER_SPACING,
+    CSS_PROP__KHTML_LINE_BREAK,
+    CSS_PROP_LINE_HEIGHT,
+    CSS_PROP_LIST_STYLE_IMAGE,
+    CSS_PROP_LIST_STYLE_POSITION,
+    CSS_PROP_LIST_STYLE_TYPE,
+    CSS_PROP_MARGIN_TOP,
+    CSS_PROP_MARGIN_RIGHT,
+    CSS_PROP_MARGIN_BOTTOM,
+    CSS_PROP_MARGIN_LEFT,
+    CSS_PROP__KHTML_MARQUEE_DIRECTION,
+    CSS_PROP__KHTML_MARQUEE_INCREMENT,
+    CSS_PROP__KHTML_MARQUEE_REPETITION,
+    CSS_PROP__KHTML_MARQUEE_STYLE,
+    CSS_PROP_MAX_HEIGHT,
+    CSS_PROP_MAX_WIDTH,
+    CSS_PROP_MIN_HEIGHT,
+    CSS_PROP_MIN_WIDTH,
+    CSS_PROP__KHTML_NBSP_MODE,
+    CSS_PROP_OPACITY,
+    CSS_PROP_ORPHANS,
+    CSS_PROP_OUTLINE_STYLE,
+    CSS_PROP_OVERFLOW,
+    CSS_PROP_PADDING_TOP,
+    CSS_PROP_PADDING_RIGHT,
+    CSS_PROP_PADDING_BOTTOM,
+    CSS_PROP_PADDING_LEFT,
+    CSS_PROP_PAGE_BREAK_AFTER,
+    CSS_PROP_PAGE_BREAK_BEFORE,
+    CSS_PROP_PAGE_BREAK_INSIDE,
+    CSS_PROP_POSITION,
+    CSS_PROP_RIGHT,
+    CSS_PROP_TABLE_LAYOUT,
+    CSS_PROP_TEXT_ALIGN,
+    CSS_PROP_TEXT_DECORATION,
+    CSS_PROP_TEXT_INDENT,
+    CSS_PROP_TEXT_SHADOW,
+    CSS_PROP_TEXT_TRANSFORM,
+    CSS_PROP_TOP,
+    CSS_PROP_UNICODE_BIDI,
+    CSS_PROP__KHTML_USER_MODIFY,
+    CSS_PROP_VERTICAL_ALIGN,
+    CSS_PROP_VISIBILITY,
+    CSS_PROP_WHITE_SPACE,
+    CSS_PROP_WIDOWS,
+    CSS_PROP_WIDTH,
+    CSS_PROP_WORD_SPACING,
+    CSS_PROP_WORD_WRAP,
+    CSS_PROP_Z_INDEX,
+};
+
+const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[0]);
+
 // This is the list of properties we want to copy in the copyInheritableProperties() function.
 // It is the intersection of the list of inherited CSS properties and the
 // properties for which we have a computed implementation in this file.
 // This is the list of properties we want to copy in the copyInheritableProperties() function.
 // It is the intersection of the list of inherited CSS properties and the
 // properties for which we have a computed implementation in this file.
-static const int InheritableProperties[] = {
+static const int inheritableProperties[] = {
     CSS_PROP_BORDER_COLLAPSE,
     CSS_PROP_BORDER_SPACING,
     CSS_PROP_COLOR,
     CSS_PROP_BORDER_COLLAPSE,
     CSS_PROP_BORDER_SPACING,
     CSS_PROP_COLOR,
@@ -67,10 +173,14 @@ static const int InheritableProperties[] = {
     CSS_PROP_TEXT_DECORATION, // this is not inheritable, yet we do want to consider it for typing style (name change needed? redesign?)
     CSS_PROP_TEXT_INDENT,
     CSS_PROP_TEXT_TRANSFORM,
     CSS_PROP_TEXT_DECORATION, // this is not inheritable, yet we do want to consider it for typing style (name change needed? redesign?)
     CSS_PROP_TEXT_INDENT,
     CSS_PROP_TEXT_TRANSFORM,
+    CSS_PROP_ORPHANS,
     CSS_PROP_WHITE_SPACE,
     CSS_PROP_WHITE_SPACE,
+    CSS_PROP_WIDOWS,
     CSS_PROP_WORD_SPACING,
 };
 
     CSS_PROP_WORD_SPACING,
 };
 
+const unsigned numInheritableProperties = sizeof(inheritableProperties) / sizeof(inheritableProperties[0]);
+
 static CSSValueImpl* valueForLength(const Length &length)
 {
     switch (length.type) {
 static CSSValueImpl* valueForLength(const Length &length)
 {
     switch (length.type) {
@@ -150,30 +260,37 @@ static CSSValueImpl* valueForShadow(const ShadowData *shadow)
     return list;
 }
 
     return list;
 }
 
-CSSValueImpl* CSSComputedStyleDeclarationImpl::getPositionOffsetValue(int propertyID) const
+static CSSValueImpl *getPositionOffsetValue(RenderObject *renderer, int propertyID)
 {
 {
+    if (!renderer)
+        return 0;
+
+    RenderStyle *style = renderer->style();
+    if (!style)
+        return 0;
+
     Length l;
     switch (propertyID) {
     case CSS_PROP_LEFT:
     Length l;
     switch (propertyID) {
     case CSS_PROP_LEFT:
-        l = m_renderer->style()->left();
+        l = style->left();
         break;
     case CSS_PROP_RIGHT:
         break;
     case CSS_PROP_RIGHT:
-        l = m_renderer->style()->right();
+        l = style->right();
         break;
     case CSS_PROP_TOP:
         break;
     case CSS_PROP_TOP:
-        l = m_renderer->style()->top();
+        l = style->top();
         break;
     case CSS_PROP_BOTTOM:
         break;
     case CSS_PROP_BOTTOM:
-        l = m_renderer->style()->bottom();
+        l = style->bottom();
         break;
     default:
         return 0;
     }
 
         break;
     default:
         return 0;
     }
 
-    if (m_renderer->isPositioned())
+    if (renderer->isPositioned())
         return valueForLength(l);
     
         return valueForLength(l);
     
-    if (m_renderer->isRelPositioned())
+    if (renderer->isRelPositioned())
         // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
         // In other words if left is auto and right is not auto, then left's computed value is negative right.
         // So we should get the opposite length unit and see if it is auto.
         // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
         // In other words if left is auto and right is not auto, then left's computed value is negative right.
         // So we should get the opposite length unit and see if it is auto.
@@ -183,10 +300,8 @@ CSSValueImpl* CSSComputedStyleDeclarationImpl::getPositionOffsetValue(int proper
 }
 
 CSSComputedStyleDeclarationImpl::CSSComputedStyleDeclarationImpl(NodeImpl *n)
 }
 
 CSSComputedStyleDeclarationImpl::CSSComputedStyleDeclarationImpl(NodeImpl *n)
-    : CSSStyleDeclarationImpl(0)
+    : m_node(n)
 {
 {
-    setNode(n);
-    m_renderer = node()->renderer();
 }
 
 CSSComputedStyleDeclarationImpl::~CSSComputedStyleDeclarationImpl()
 }
 
 CSSComputedStyleDeclarationImpl::~CSSComputedStyleDeclarationImpl()
@@ -199,9 +314,9 @@ DOMString CSSComputedStyleDeclarationImpl::cssText() const
     return DOMString();
 }
 
     return DOMString();
 }
 
-void CSSComputedStyleDeclarationImpl::setCssText(const DOMString &)
+void CSSComputedStyleDeclarationImpl::setCssText(const DOMString &, int &exceptionCode)
 {
 {
-    ERROR("CSSComputedStyleDeclarationImpl is a read-only object");
+    exceptionCode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
 }
 
 // Display integers in integer format instead of "1.0".
 }
 
 // Display integers in integer format instead of "1.0".
@@ -216,28 +331,32 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
     return getPropertyCSSValue(propertyID, UpdateLayout);
 }
 
     return getPropertyCSSValue(propertyID, UpdateLayout);
 }
 
-CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyID, bool updateLayout) const
+CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const
 {
 {
+    NodeImpl *node = m_node.handle();
+    if (!node)
+        return 0;
+
     // Make sure our layout is up to date before we allow a query on these attributes.
     // Make sure our layout is up to date before we allow a query on these attributes.
-    DocumentImpl* docimpl = node()->getDocument();
+    DocumentImpl* docimpl = node->getDocument();
     if (docimpl && updateLayout)
         docimpl->updateLayout();
 
     if (docimpl && updateLayout)
         docimpl->updateLayout();
 
-    if (!m_renderer)
+    RenderObject *renderer = node->renderer();
+    if (!renderer)
         return 0;
         return 0;
-    RenderStyle *style = m_renderer->style();
+    RenderStyle *style = renderer->style();
     if (!style)
         return 0;
 
     if (!style)
         return 0;
 
-    switch(propertyID)
+    switch (propertyID)
     {
     case CSS_PROP_BACKGROUND_COLOR:
         return new CSSPrimitiveValueImpl(style->backgroundColor().rgb());
     case CSS_PROP_BACKGROUND_IMAGE:
         if (style->backgroundImage())
     {
     case CSS_PROP_BACKGROUND_COLOR:
         return new CSSPrimitiveValueImpl(style->backgroundColor().rgb());
     case CSS_PROP_BACKGROUND_IMAGE:
         if (style->backgroundImage())
-            return new CSSPrimitiveValueImpl(style->backgroundImage()->url(),
-                                             CSSPrimitiveValue::CSS_URI);
-        return 0;
+            return new CSSPrimitiveValueImpl(style->backgroundImage()->url(), CSSPrimitiveValue::CSS_URI);
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
     case CSS_PROP_BACKGROUND_REPEAT:
         switch (style->backgroundRepeat()) {
             case khtml::REPEAT:
     case CSS_PROP_BACKGROUND_REPEAT:
         switch (style->backgroundRepeat()) {
             case khtml::REPEAT:
@@ -263,13 +382,13 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         if (length.isPercent())
             string = numberAsString(length.length()) + "%";
         else
         if (length.isPercent())
             string = numberAsString(length.length()) + "%";
         else
-            string = numberAsString(length.minWidth(m_renderer->contentWidth()));
+            string = numberAsString(length.minWidth(renderer->contentWidth()));
         string += " ";
         length = style->backgroundYPosition();
         if (length.isPercent())
             string += numberAsString(length.length()) + "%";
         else
         string += " ";
         length = style->backgroundYPosition();
         if (length.isPercent())
             string += numberAsString(length.length()) + "%";
         else
-            string += numberAsString(length.minWidth(m_renderer->contentWidth()));
+            string += numberAsString(length.minWidth(renderer->contentWidth()));
         return new CSSPrimitiveValueImpl(string, CSSPrimitiveValue::CSS_STRING);
     }
     case CSS_PROP_BACKGROUND_POSITION_X:
         return new CSSPrimitiveValueImpl(string, CSSPrimitiveValue::CSS_STRING);
     }
     case CSS_PROP_BACKGROUND_POSITION_X:
@@ -323,37 +442,99 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
     case CSS_PROP_BORDER_LEFT_WIDTH:
         return new CSSPrimitiveValueImpl(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_BOTTOM:
     case CSS_PROP_BORDER_LEFT_WIDTH:
         return new CSSPrimitiveValueImpl(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_BOTTOM:
-        return getPositionOffsetValue(CSS_PROP_BOTTOM);
+        return getPositionOffsetValue(renderer, CSS_PROP_BOTTOM);
     case CSS_PROP__KHTML_BOX_ALIGN:
     case CSS_PROP__KHTML_BOX_ALIGN:
-        // FIXME: unimplemented
-        break;
+        switch (style->boxAlign()) {
+            case khtml::BSTRETCH:
+                return new CSSPrimitiveValueImpl(CSS_VAL_STRETCH);
+            case khtml::BSTART:
+                return new CSSPrimitiveValueImpl(CSS_VAL_START);
+            case khtml::BCENTER:
+                return new CSSPrimitiveValueImpl(CSS_VAL_CENTER);
+            case khtml::BEND:
+                return new CSSPrimitiveValueImpl(CSS_VAL_END);
+            case khtml::BBASELINE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_BASELINE);
+            case khtml::BJUSTIFY:
+                break; // not allowed
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_BOX_DIRECTION:
     case CSS_PROP__KHTML_BOX_DIRECTION:
-        // FIXME: unimplemented
-        break;
+        switch (style->boxDirection()) {
+            case khtml::BNORMAL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+            case khtml::BREVERSE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_REVERSE);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_BOX_FLEX:
     case CSS_PROP__KHTML_BOX_FLEX:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP__KHTML_BOX_FLEX_GROUP:
     case CSS_PROP__KHTML_BOX_FLEX_GROUP:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP__KHTML_BOX_LINES:
     case CSS_PROP__KHTML_BOX_LINES:
-        // FIXME: unimplemented
-        break;
+        switch (style->boxLines()) {
+            case khtml::SINGLE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SINGLE);
+            case khtml::MULTIPLE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_MULTIPLE);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_BOX_ORDINAL_GROUP:
     case CSS_PROP__KHTML_BOX_ORDINAL_GROUP:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP__KHTML_BOX_ORIENT:
     case CSS_PROP__KHTML_BOX_ORIENT:
-        // FIXME: unimplemented
-        break;
+        switch (style->boxOrient()) {
+            case khtml::HORIZONTAL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HORIZONTAL);
+            case khtml::VERTICAL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_VERTICAL);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_BOX_PACK:
     case CSS_PROP__KHTML_BOX_PACK:
-        // FIXME: unimplemented
-        break;
+        switch (style->boxPack()) {
+            case khtml::BSTART:
+                return new CSSPrimitiveValueImpl(CSS_VAL_START);
+            case khtml::BEND:
+                return new CSSPrimitiveValueImpl(CSS_VAL_END);
+            case khtml::BCENTER:
+                return new CSSPrimitiveValueImpl(CSS_VAL_CENTER);
+            case khtml::BJUSTIFY:
+                return new CSSPrimitiveValueImpl(CSS_VAL_JUSTIFY);
+            case khtml::BSTRETCH:
+            case khtml::BBASELINE:
+                break; // not allowed
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_CAPTION_SIDE:
     case CSS_PROP_CAPTION_SIDE:
-        // FIXME: unimplemented
-        break;
+        switch (style->captionSide()) {
+            case khtml::CAPLEFT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+            case khtml::CAPRIGHT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+            case khtml::CAPTOP:
+                return new CSSPrimitiveValueImpl(CSS_VAL_TOP);
+            case khtml::CAPBOTTOM:
+                return new CSSPrimitiveValueImpl(CSS_VAL_BOTTOM);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_CLEAR:
     case CSS_PROP_CLEAR:
-        // FIXME: unimplemented
-        break;
+        switch (style->clear()) {
+            case khtml::CNONE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+            case khtml::CLEFT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+            case khtml::CRIGHT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+            case khtml::CBOTH:
+                return new CSSPrimitiveValueImpl(CSS_VAL_BOTH);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_CLIP:
         // FIXME: unimplemented
         break;
     case CSS_PROP_CLIP:
         // FIXME: unimplemented
         break;
@@ -369,11 +550,51 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // FIXME: unimplemented
         break;
     case CSS_PROP_CURSOR:
         // FIXME: unimplemented
         break;
     case CSS_PROP_CURSOR:
-        // FIXME: unimplemented
-        break;
+        switch (style->cursor()) {
+            case khtml::CURSOR_AUTO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+            case khtml::CURSOR_CROSS:
+                return new CSSPrimitiveValueImpl(CSS_VAL_CROSSHAIR);
+            case khtml::CURSOR_DEFAULT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_DEFAULT);
+            case khtml::CURSOR_POINTER:
+                return new CSSPrimitiveValueImpl(CSS_VAL_POINTER);
+            case khtml::CURSOR_MOVE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_MOVE);
+            case khtml::CURSOR_E_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_E_RESIZE);
+            case khtml::CURSOR_NE_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NE_RESIZE);
+            case khtml::CURSOR_NW_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NW_RESIZE);
+            case khtml::CURSOR_N_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_N_RESIZE);
+            case khtml::CURSOR_SE_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SE_RESIZE);
+            case khtml::CURSOR_SW_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SW_RESIZE);
+            case khtml::CURSOR_S_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_S_RESIZE);
+            case khtml::CURSOR_W_RESIZE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_W_RESIZE);
+            case khtml::CURSOR_TEXT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_TEXT);
+            case khtml::CURSOR_WAIT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_WAIT);
+            case khtml::CURSOR_HELP:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HELP);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_DIRECTION:
     case CSS_PROP_DIRECTION:
-        // FIXME: unimplemented
-        break;
+        switch (style->direction()) {
+            case khtml::LTR:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LTR);
+            case khtml::RTL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_RTL);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_DISPLAY:
         switch (style->display()) {
             case khtml::INLINE:
     case CSS_PROP_DISPLAY:
         switch (style->display()) {
             case khtml::INLINE:
@@ -447,9 +668,6 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         FontDef def = style->htmlFont().getFontDef();
         return new CSSPrimitiveValueImpl(def.specifiedSize, CSSPrimitiveValue::CSS_PX);
     }
         FontDef def = style->htmlFont().getFontDef();
         return new CSSPrimitiveValueImpl(def.specifiedSize, CSSPrimitiveValue::CSS_PX);
     }
-    case CSS_PROP_FONT_SIZE_ADJUST:
-        // FIXME: unimplemented
-        break;
     case CSS_PROP_FONT_STRETCH:
         // FIXME: unimplemented
         break;
     case CSS_PROP_FONT_STRETCH:
         // FIXME: unimplemented
         break;
@@ -481,9 +699,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
             return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
     }
     case CSS_PROP_HEIGHT:
             return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
     }
     case CSS_PROP_HEIGHT:
-        return new CSSPrimitiveValueImpl(m_renderer->contentHeight(), CSSPrimitiveValue::CSS_PX);
+        return new CSSPrimitiveValueImpl(renderer->contentHeight(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_LEFT:
     case CSS_PROP_LEFT:
-        return getPositionOffsetValue(CSS_PROP_LEFT);
+        return getPositionOffsetValue(renderer, CSS_PROP_LEFT);
     case CSS_PROP_LETTER_SPACING:
         if (style->letterSpacing() == 0)
             return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
     case CSS_PROP_LETTER_SPACING:
         if (style->letterSpacing() == 0)
             return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
@@ -501,14 +719,65 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         }
     }
     case CSS_PROP_LIST_STYLE_IMAGE:
         }
     }
     case CSS_PROP_LIST_STYLE_IMAGE:
-        // FIXME: unimplemented
-        break;
+        if (style->listStyleImage())
+            return new CSSPrimitiveValueImpl(style->listStyleImage()->url(), CSSPrimitiveValue::CSS_URI);
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
     case CSS_PROP_LIST_STYLE_POSITION:
     case CSS_PROP_LIST_STYLE_POSITION:
-        // FIXME: unimplemented
-        break;
+        switch (style->listStylePosition()) {
+            case khtml::OUTSIDE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_OUTSIDE);
+            case khtml::INSIDE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_INSIDE);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_LIST_STYLE_TYPE:
     case CSS_PROP_LIST_STYLE_TYPE:
-        // FIXME: unimplemented
-        break;
+        switch (style->listStyleType()) {
+            case khtml::LNONE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+            case khtml::DISC:
+                return new CSSPrimitiveValueImpl(CSS_VAL_DISC);
+            case khtml::CIRCLE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_CIRCLE);
+            case khtml::SQUARE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SQUARE);
+            case khtml::LDECIMAL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_DECIMAL);
+            case khtml::DECIMAL_LEADING_ZERO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_DECIMAL_LEADING_ZERO);
+            case khtml::LOWER_ROMAN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LOWER_ROMAN);
+            case khtml::UPPER_ROMAN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_UPPER_ROMAN);
+            case khtml::LOWER_GREEK:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LOWER_GREEK);
+            case khtml::LOWER_ALPHA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LOWER_ALPHA);
+            case khtml::LOWER_LATIN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LOWER_LATIN);
+            case khtml::UPPER_ALPHA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_UPPER_ALPHA);
+            case khtml::UPPER_LATIN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_UPPER_LATIN);
+            case khtml::HEBREW:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HEBREW);
+            case khtml::ARMENIAN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_ARMENIAN);
+            case khtml::GEORGIAN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_GEORGIAN);
+            case khtml::CJK_IDEOGRAPHIC:
+                return new CSSPrimitiveValueImpl(CSS_VAL_CJK_IDEOGRAPHIC);
+            case khtml::HIRAGANA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HIRAGANA);
+            case khtml::KATAKANA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_KATAKANA);
+            case khtml::HIRAGANA_IROHA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HIRAGANA_IROHA);
+            case khtml::KATAKANA_IROHA:
+                return new CSSPrimitiveValueImpl(CSS_VAL_KATAKANA_IROHA);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_MARGIN_TOP:
         return valueForLength(style->marginTop());
     case CSS_PROP_MARGIN_RIGHT:
     case CSS_PROP_MARGIN_TOP:
         return valueForLength(style->marginTop());
     case CSS_PROP_MARGIN_RIGHT:
@@ -521,22 +790,57 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // FIXME: unimplemented
         break;
     case CSS_PROP__KHTML_MARQUEE_DIRECTION:
         // FIXME: unimplemented
         break;
     case CSS_PROP__KHTML_MARQUEE_DIRECTION:
-        // FIXME: unimplemented
-        break;
+        switch (style->marqueeDirection()) {
+            case khtml::MFORWARD:
+                return new CSSPrimitiveValueImpl(CSS_VAL_FORWARDS);
+            case khtml::MBACKWARD:
+                return new CSSPrimitiveValueImpl(CSS_VAL_BACKWARDS);
+            case khtml::MAUTO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+            case khtml::MUP:
+                return new CSSPrimitiveValueImpl(CSS_VAL_UP);
+            case khtml::MDOWN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_DOWN);
+            case khtml::MLEFT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+            case khtml::MRIGHT:
+                return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_MARQUEE_INCREMENT:
         return valueForLength(style->marqueeIncrement());
     case CSS_PROP__KHTML_MARQUEE_REPETITION:
     case CSS_PROP__KHTML_MARQUEE_INCREMENT:
         return valueForLength(style->marqueeIncrement());
     case CSS_PROP__KHTML_MARQUEE_REPETITION:
-        // FIXME: unimplemented
-        break;
+        if (style->marqueeLoopCount() < 0)
+            return new CSSPrimitiveValueImpl(CSS_VAL_INFINITE);
+        return new CSSPrimitiveValueImpl(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP__KHTML_MARQUEE_SPEED:
         // FIXME: unimplemented
         break;
     case CSS_PROP__KHTML_MARQUEE_STYLE:
     case CSS_PROP__KHTML_MARQUEE_SPEED:
         // FIXME: unimplemented
         break;
     case CSS_PROP__KHTML_MARQUEE_STYLE:
-        // FIXME: unimplemented
-        break;
+        switch (style->marqueeBehavior()) {
+            case khtml::MNONE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+            case khtml::MSCROLL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SCROLL);
+            case khtml::MSLIDE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_SLIDE);
+            case khtml::MALTERNATE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_ALTERNATE);
+            case khtml::MUNFURL:
+                return new CSSPrimitiveValueImpl(CSS_VAL_UNFURL);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP__KHTML_USER_MODIFY:
     case CSS_PROP__KHTML_USER_MODIFY:
-        // FIXME: unimplemented
-        break;
+        switch (style->userModify()) {
+            case khtml::READ_ONLY:
+                return new CSSPrimitiveValueImpl(CSS_VAL_READ_ONLY);
+            case khtml::READ_WRITE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_READ_WRITE);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_MAX_HEIGHT:
         return valueForLength(style->maxHeight());
     case CSS_PROP_MAX_WIDTH:
     case CSS_PROP_MAX_HEIGHT:
         return valueForLength(style->maxHeight());
     case CSS_PROP_MAX_WIDTH:
@@ -546,13 +850,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
     case CSS_PROP_MIN_WIDTH:
         return valueForLength(style->minWidth());
     case CSS_PROP_OPACITY:
     case CSS_PROP_MIN_WIDTH:
         return valueForLength(style->minWidth());
     case CSS_PROP_OPACITY:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP_ORPHANS:
     case CSS_PROP_ORPHANS:
-        // FIXME: unimplemented
-        break;
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP_OUTLINE_COLOR:
         // FIXME: unimplemented
         break;
     case CSS_PROP_OUTLINE_COLOR:
         // FIXME: unimplemented
         break;
@@ -560,8 +860,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // FIXME: unimplemented
         break;
     case CSS_PROP_OUTLINE_STYLE:
         // FIXME: unimplemented
         break;
     case CSS_PROP_OUTLINE_STYLE:
-        // FIXME: unimplemented
-        break;
+        if (style->outlineStyleIsAuto())
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        return valueForBorderStyle(style->outlineStyle());
     case CSS_PROP_OUTLINE_WIDTH:
         // FIXME: unimplemented
         break;
     case CSS_PROP_OUTLINE_WIDTH:
         // FIXME: unimplemented
         break;
@@ -594,22 +895,56 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // FIXME: unimplemented
         break;
     case CSS_PROP_PAGE_BREAK_AFTER:
         // FIXME: unimplemented
         break;
     case CSS_PROP_PAGE_BREAK_AFTER:
-        // FIXME: unimplemented
-        break;
+        switch (style->pageBreakAfter()) {
+            case khtml::PBAUTO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+            case khtml::PBALWAYS:
+                return new CSSPrimitiveValueImpl(CSS_VAL_ALWAYS);
+            case khtml::PBAVOID:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_PAGE_BREAK_BEFORE:
     case CSS_PROP_PAGE_BREAK_BEFORE:
-        // FIXME: unimplemented
-        break;
+        switch (style->pageBreakBefore()) {
+            case khtml::PBAUTO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+            case khtml::PBALWAYS:
+                return new CSSPrimitiveValueImpl(CSS_VAL_ALWAYS);
+            case khtml::PBAVOID:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_PAGE_BREAK_INSIDE:
     case CSS_PROP_PAGE_BREAK_INSIDE:
-        // FIXME: unimplemented
-        break;
+        switch (style->pageBreakInside()) {
+            case khtml::PBAUTO:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+            case khtml::PBAVOID:
+                return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+            case khtml::PBALWAYS:
+                break; // not allowed
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_POSITION:
     case CSS_PROP_POSITION:
-        // FIXME: unimplemented
-        break;
+        switch (style->position()) {
+            case khtml::STATIC:
+                return new CSSPrimitiveValueImpl(CSS_VAL_STATIC);
+            case khtml::RELATIVE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_RELATIVE);
+            case khtml::ABSOLUTE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_ABSOLUTE);
+            case khtml::FIXED:
+                return new CSSPrimitiveValueImpl(CSS_VAL_FIXED);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_QUOTES:
         // FIXME: unimplemented
         break;
     case CSS_PROP_RIGHT:
     case CSS_PROP_QUOTES:
         // FIXME: unimplemented
         break;
     case CSS_PROP_RIGHT:
-        return getPositionOffsetValue(CSS_PROP_RIGHT);
+        return getPositionOffsetValue(renderer, CSS_PROP_RIGHT);
     case CSS_PROP_SIZE:
         // FIXME: unimplemented
         break;
     case CSS_PROP_SIZE:
         // FIXME: unimplemented
         break;
@@ -666,10 +1001,18 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_TOP:
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_TOP:
-        return getPositionOffsetValue(CSS_PROP_TOP);
+        return getPositionOffsetValue(renderer, CSS_PROP_TOP);
     case CSS_PROP_UNICODE_BIDI:
     case CSS_PROP_UNICODE_BIDI:
-        // FIXME: unimplemented
-        break;
+        switch (style->unicodeBidi()) {
+            case khtml::UBNormal:
+                return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+            case khtml::Embed:
+                return new CSSPrimitiveValueImpl(CSS_VAL_EMBED);
+            case khtml::Override:
+                return new CSSPrimitiveValueImpl(CSS_VAL_BIDI_OVERRIDE);
+        }
+        ASSERT_NOT_REACHED();
+        return 0;
     case CSS_PROP_VERTICAL_ALIGN:
         switch (style->verticalAlign()) {
             case khtml::BASELINE:
     case CSS_PROP_VERTICAL_ALIGN:
         switch (style->verticalAlign()) {
             case khtml::BASELINE:
@@ -720,10 +1063,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_WIDOWS:
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_WIDOWS:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP_WIDTH:
     case CSS_PROP_WIDTH:
-        return new CSSPrimitiveValueImpl(m_renderer->contentWidth(), CSSPrimitiveValue::CSS_PX);
+        return new CSSPrimitiveValueImpl(renderer->contentWidth(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_WORD_SPACING:
         return new CSSPrimitiveValueImpl(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_WORD_WRAP:
     case CSS_PROP_WORD_SPACING:
         return new CSSPrimitiveValueImpl(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
     case CSS_PROP_WORD_WRAP:
@@ -754,8 +1096,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_Z_INDEX:
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_Z_INDEX:
-        // FIXME: unimplemented
-        break;
+        if (style->hasAutoZIndex())
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        return new CSSPrimitiveValueImpl(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP_BACKGROUND:
         // FIXME: unimplemented
         break;
     case CSS_PROP_BACKGROUND:
         // FIXME: unimplemented
         break;
@@ -821,9 +1164,6 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // FIXME: unimplemented
         break;
 #endif
         // FIXME: unimplemented
         break;
 #endif
-    case CSS_PROP__KHTML_FLOW_MODE:
-        // FIXME: unimplemented
-        break;
 #if APPLE_CHANGES
         case CSS_PROP__APPLE_DASHBOARD_REGION: {
             QValueList<StyleDashboardRegion> regions = style->dashboardRegions();
 #if APPLE_CHANGES
         case CSS_PROP__APPLE_DASHBOARD_REGION: {
             QValueList<StyleDashboardRegion> regions = style->dashboardRegions();
@@ -872,57 +1212,46 @@ DOMString CSSComputedStyleDeclarationImpl::getPropertyValue(int propertyID) cons
 
 bool CSSComputedStyleDeclarationImpl::getPropertyPriority(int) const
 {
 
 bool CSSComputedStyleDeclarationImpl::getPropertyPriority(int) const
 {
-    // This class does not support the notion of priority, since the object
-    // is a computed value.
+    // All computed styles have a priority of false (not "important").
     return false;
 }
 
     return false;
 }
 
-DOMString CSSComputedStyleDeclarationImpl::removeProperty(int)
+DOMString CSSComputedStyleDeclarationImpl::removeProperty(int, int &exceptionCode)
 {
 {
-    ASSERT_NOT_REACHED();
+    exceptionCode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
     return DOMString();
 }
 
     return DOMString();
 }
 
-bool CSSComputedStyleDeclarationImpl::setProperty(int, const DOMString &, bool)
+void CSSComputedStyleDeclarationImpl::setProperty(int, const DOMString &, bool, int &exceptionCode)
 {
 {
-    ASSERT_NOT_REACHED();
-    return false;
+    exceptionCode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
 }
 
 }
 
-void CSSComputedStyleDeclarationImpl::setProperty(int, int, bool)
+unsigned long CSSComputedStyleDeclarationImpl::length() const
 {
 {
-    ASSERT_NOT_REACHED();
+    return numComputedProperties;
 }
 
 }
 
-void CSSComputedStyleDeclarationImpl::setLengthProperty(int, const DOMString&, bool, bool)
+DOMString CSSComputedStyleDeclarationImpl::item(unsigned long i) const
 {
 {
-    ASSERT_NOT_REACHED();
+    if (i >= numComputedProperties)
+        return DOMString();
+    return getPropertyValue(computedProperties[i]);
 }
 
 }
 
-void CSSComputedStyleDeclarationImpl::setProperty(const DOMString &)
+CSSMutableStyleDeclarationImpl *CSSComputedStyleDeclarationImpl::copyInheritableProperties() const
 {
 {
-    ASSERT_NOT_REACHED();
+    return copyPropertiesInSet(inheritableProperties, numInheritableProperties);
 }
 
 }
 
-DOMString CSSComputedStyleDeclarationImpl::item(unsigned long) const
-{
-    ERROR("unimplemented");
-    return DOMString();
-}
-
-
-CSSProperty CSSComputedStyleDeclarationImpl::property(int id) const
+CSSMutableStyleDeclarationImpl *CSSComputedStyleDeclarationImpl::copy() const
 {
 {
-    CSSProperty prop;
-    prop.m_id = id;
-    prop.m_bImportant = false;
-    prop.setValue(getPropertyCSSValue(id));
-    return prop;
+    return copyPropertiesInSet(computedProperties, numComputedProperties);
 }
 
 }
 
-CSSStyleDeclarationImpl *CSSComputedStyleDeclarationImpl::copyInheritableProperties() const
+CSSMutableStyleDeclarationImpl *CSSComputedStyleDeclarationImpl::makeMutable()
 {
 {
-    return copyPropertiesInSet(InheritableProperties, sizeof(InheritableProperties) / sizeof(InheritableProperties[0]));
+    return copy();
 }
 
 } // namespace DOM
 }
 
 } // namespace DOM
index aa50f754bcd6f4105af7a971d34ee8bb2972dee6..5a7a90740b16c81212e14851a236cb5ccc95cd6a 100644 (file)
@@ -2,7 +2,7 @@
  * css_computedstyle.h
  *
  * Copyright (C)  2004  Zack Rusin <zack@kde.org>
  * css_computedstyle.h
  *
  * Copyright (C)  2004  Zack Rusin <zack@kde.org>
- * Copyright (C)  2004  Apple Computer, Inc.
+ * Copyright (C) 2004 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  * 02111-1307  USA
  */
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  * 02111-1307  USA
  */
+
 #ifndef CSS_COMPUTEDSTYLE_H
 #define CSS_COMPUTEDSTYLE_H
 
 #include "css/css_valueimpl.h"
 #ifndef CSS_COMPUTEDSTYLE_H
 #define CSS_COMPUTEDSTYLE_H
 
 #include "css/css_valueimpl.h"
-#include "dom/dom_string.h"
 
 namespace khtml {
     class RenderObject;
 
 namespace khtml {
     class RenderObject;
+    class RenderStyle;
 }
 
 namespace DOM {
 
 class CSSProperty;
 }
 
 namespace DOM {
 
 class CSSProperty;
-class CSSStyleDeclarationImpl;
-class CSSValueImpl;
-class DOMString;
-class NodeImpl;
 
 enum EUpdateLayout { DoNotUpdateLayout = false, UpdateLayout = true };
 
 
 enum EUpdateLayout { DoNotUpdateLayout = false, UpdateLayout = true };
 
@@ -46,32 +43,29 @@ public:
     virtual ~CSSComputedStyleDeclarationImpl();
 
     virtual DOMString cssText() const;
     virtual ~CSSComputedStyleDeclarationImpl();
 
     virtual DOMString cssText() const;
-    virtual void setCssText(const DOMString &);
+
+    virtual unsigned long length() const;
+    virtual DOMString item(unsigned long index) const;
 
     virtual CSSValueImpl *getPropertyCSSValue(int propertyID) const;
 
     virtual CSSValueImpl *getPropertyCSSValue(int propertyID) const;
-    CSSValueImpl *getPropertyCSSValue(int propertyID, bool updateLayout) const;
     virtual DOMString getPropertyValue(int propertyID) const;
     virtual bool getPropertyPriority(int propertyID) const;
 
     virtual DOMString getPropertyValue(int propertyID) const;
     virtual bool getPropertyPriority(int propertyID) const;
 
-    virtual DOMString removeProperty(int propertyID);
-    virtual bool setProperty(int propertyId, const DOMString &value, bool important = false);
-    virtual void setProperty(int propertyId, int value, bool important = false);
-    virtual void setLengthProperty(int id, const DOMString &value, bool important, bool multiLength = false);
+    virtual CSSMutableStyleDeclarationImpl *copy() const;
+    virtual CSSMutableStyleDeclarationImpl *makeMutable();
 
 
-    virtual void setProperty(const DOMString &propertyString);
-    virtual DOMString item(unsigned long index) const;
-
-    CSSStyleDeclarationImpl *copyInheritableProperties() const;
+    CSSValueImpl *getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const;
 
 
-    CSSValueImpl* getPositionOffsetValue(int propertyID) const;
+    CSSMutableStyleDeclarationImpl *copyInheritableProperties() const;
 
 private:
 
 private:
-    CSSProperty property(int id) const;
+    virtual void setCssText(const DOMString &, int &exceptionCode);
+    virtual DOMString removeProperty(int propertyID, int &exceptionCode);
+    virtual void setProperty(int propertyId, const DOMString &value, bool important, int &exceptionCode);
 
 
-    khtml::RenderObject *m_renderer;
+    Node m_node;
 };
 
 };
 
-
 }
 
 #endif
 }
 
 #endif
index bd0fee92eda93db709633fdcbb457c4d092a9c83..025326b275d4f84e445db414f905fe4f189c8264 100644 (file)
@@ -38,11 +38,10 @@ namespace khtml {
 
 namespace DOM {
 
 
 namespace DOM {
 
+class CSSMutableStyleDeclarationImpl;
 class CSSRule;
 class CSSStyleSheet;
 class CSSStyleSheetImpl;
 class CSSRule;
 class CSSStyleSheet;
 class CSSStyleSheetImpl;
-class CSSStyleDeclarationImpl;
-typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
 class MediaListImpl;
 
 class CSSRuleImpl : public StyleBaseImpl
 class MediaListImpl;
 
 class CSSRuleImpl : public StyleBaseImpl
index 5361a66f5072d8f2781b16318ed8115401006d1f..bdd324adc23ee5133070baf9ac0b27c6bbc5ed84 100644 (file)
@@ -2,7 +2,7 @@
  * This file is part of the DOM implementation for KDE.
  *
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * This file is part of the DOM implementation for KDE.
  *
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2002 Apple Computer, Inc.
+ * Copyright (C) 2004 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -51,61 +51,57 @@ extern DOM::DOMString getPropertyName(unsigned short id);
 using khtml::FontDef;
 using khtml::CSSStyleSelector;
 
 using khtml::FontDef;
 using khtml::CSSStyleSelector;
 
-using namespace DOM;
+namespace DOM {
 
 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent)
     : StyleBaseImpl(parent)
 {
 
 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent)
     : StyleBaseImpl(parent)
 {
-    m_lstValues = 0;
-    m_node = 0;
 }
 
 }
 
-CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent, QPtrList<CSSProperty> *lstValues)
-    : StyleBaseImpl(parent)
+bool CSSStyleDeclarationImpl::isStyleDeclaration()
 {
 {
-    if (!lstValues) {
-        m_lstValues = 0;
-    }
-    else {
-        m_lstValues = new QPtrList<CSSProperty>;
-        m_lstValues->setAutoDelete(true);
+    return true;
+}
 
 
-        QPtrListIterator<CSSProperty> lstValuesIt(*lstValues);
-        for (lstValuesIt.toFirst(); lstValuesIt.current(); ++lstValuesIt)
-            m_lstValues->append(new CSSProperty(*lstValuesIt.current()));
-    }
-    m_node = 0;
+CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl()
+    : m_node(0)
+{
 }
 
 }
 
-CSSStyleDeclarationImpl&  CSSStyleDeclarationImpl::operator= (const CSSStyleDeclarationImpl& o)
+CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl(CSSRuleImpl *parent)
+    : CSSStyleDeclarationImpl(parent), m_node(0)
 {
 {
-    // don't attach it to the same node, just leave the current m_node value
-    delete m_lstValues;
-    m_lstValues = 0;
-    if (o.m_lstValues) {
-        m_lstValues = new QPtrList<CSSProperty>;
-        m_lstValues->setAutoDelete( true );
-
-        QPtrListIterator<CSSProperty> lstValuesIt(*o.m_lstValues);
-        for (lstValuesIt.toFirst(); lstValuesIt.current(); ++lstValuesIt)
-            m_lstValues->append(new CSSProperty(*lstValuesIt.current()));
-    }
+}
 
 
+CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl(CSSRuleImpl *parent, const QValueList<CSSProperty> &values)
+    : CSSStyleDeclarationImpl(parent), m_values(values), m_node(0)
+{
+    // FIXME: This allows duplicate properties.
+}
+
+CSSMutableStyleDeclarationImpl::CSSMutableStyleDeclarationImpl(CSSRuleImpl *parent, const CSSProperty * const *properties, int numProperties)
+{
+    for (int i = 0; i < numProperties; ++i)
+        m_values.append(*properties[i]);
+    // FIXME: This allows duplicate properties.
+}
+
+CSSMutableStyleDeclarationImpl& CSSMutableStyleDeclarationImpl::operator=(const CSSMutableStyleDeclarationImpl& o)
+{
+    // don't attach it to the same node, just leave the current m_node value
+    m_values = o.m_values;
     return *this;
 }
 
     return *this;
 }
 
-CSSStyleDeclarationImpl::~CSSStyleDeclarationImpl()
+CSSMutableStyleDeclarationImpl::~CSSMutableStyleDeclarationImpl()
 {
 {
-    delete m_lstValues;
     // we don't use refcounting for m_node, to avoid cyclic references (see ElementImpl)
 }
 
     // we don't use refcounting for m_node, to avoid cyclic references (see ElementImpl)
 }
 
-DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
+DOMString CSSMutableStyleDeclarationImpl::getPropertyValue( int propertyID ) const
 {
 {
-    if(!m_lstValues) return DOMString();
-
     CSSValueImpl* value = getPropertyCSSValue( propertyID );
     CSSValueImpl* value = getPropertyCSSValue( propertyID );
-    if ( value )
+    if (value)
         return CSSValue(value).cssText();
 
     // Shorthand and 4-values properties
         return CSSValue(value).cssText();
 
     // Shorthand and 4-values properties
@@ -201,7 +197,7 @@ DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
     return DOMString();
 }
 
     return DOMString();
 }
 
-DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
+DOMString CSSMutableStyleDeclarationImpl::get4Values( const int* properties ) const
 {
     DOMString res;
     for ( int i = 0 ; i < 4 ; ++i ) {
 {
     DOMString res;
     for ( int i = 0 ; i < 4 ; ++i ) {
@@ -218,7 +214,7 @@ DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
     return res;
 }
 
     return res;
 }
 
-DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int number ) const
+DOMString CSSMutableStyleDeclarationImpl::getShortHandValue( const int* properties, int number ) const
 {
     DOMString res;
     for ( int i = 0 ; i < number ; ++i ) {
 {
     DOMString res;
     for ( int i = 0 ; i < number ; ++i ) {
@@ -234,38 +230,35 @@ DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int
     return res;
 }
 
     return res;
 }
 
- CSSValueImpl *CSSStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
+ CSSValueImpl *CSSMutableStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
 {
 {
-    if(!m_lstValues) return 0;
-
-    QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
-    CSSProperty *current;
-    for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
-        if (current->m_id == propertyID)
-            return current->value();
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = m_values.fromLast(); it != end; --it)
+        if (propertyID == (*it).m_id)
+            return (*it).value();
     return 0;
 }
 
     return 0;
 }
 
-DOMString CSSStyleDeclarationImpl::removeProperty(int propertyID, bool notifyChanged)
+DOMString CSSMutableStyleDeclarationImpl::removeProperty(int propertyID, bool notifyChanged, int &exceptionCode)
 {
 {
-    if(!m_lstValues) return DOMString();
+    exceptionCode = 0;
+
     DOMString value;
 
     DOMString value;
 
-    QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
-     CSSProperty *current;
-     for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
-         if (current->m_id == propertyID) {
-             value = current->value()->cssText();
-             m_lstValues->removeRef(current);
-             if (notifyChanged)
-                 setChanged();
-            break;
+    QValueListIterator<CSSProperty> end;
+    for (QValueListIterator<CSSProperty> it = m_values.fromLast(); it != end; --it)
+        if (propertyID == (*it).m_id) {
+            value = (*it).value()->cssText();
+            m_values.remove(it);
+            if (notifyChanged)
+                setChanged();
+            break;
         }
 
     return value;
 }
 
         }
 
     return value;
 }
 
-void CSSStyleDeclarationImpl::setChanged()
+void CSSMutableStyleDeclarationImpl::setChanged()
 {
     if (m_node) {
         m_node->setChanged();
 {
     if (m_node) {
         m_node->setChanged();
@@ -280,86 +273,83 @@ void CSSStyleDeclarationImpl::setChanged()
         }
 }
 
         }
 }
 
-bool CSSStyleDeclarationImpl::getPropertyPriority( int propertyID ) const
+bool CSSMutableStyleDeclarationImpl::getPropertyPriority(int propertyID) const
 {
 {
-    if ( m_lstValues) {
-       QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
-       CSSProperty *current;
-       for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt ) {
-           if( propertyID == current->m_id )
-               return current->m_bImportant;
-       }
-    }
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it)
+        if (propertyID == (*it).m_id)
+            return (*it).m_bImportant;
     return false;
 }
 
     return false;
 }
 
-bool CSSStyleDeclarationImpl::setProperty(int id, const DOMString &value, bool important, bool notifyChanged)
+void CSSMutableStyleDeclarationImpl::setProperty(int propertyID, const DOMString &value, bool important, int &exceptionCode)
 {
 {
-    if(!m_lstValues) {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete(true);
-    }
-    removeProperty(id);
+    setProperty(propertyID, value, important, true, exceptionCode);
+}
 
 
-    CSSParser parser( strictParsing );
-    bool success = parser.parseValue(this, id, value, important);
-    if(!success)
-       kdDebug( 6080 ) << "CSSStyleDeclarationImpl::setProperty invalid property: [" << getPropertyName(id).string()
+DOMString CSSMutableStyleDeclarationImpl::removeProperty(int propertyID, int &exceptionCode)
+{
+    return removeProperty(propertyID, true, exceptionCode);
+}
+
+bool CSSMutableStyleDeclarationImpl::setProperty(int propertyID, const DOMString &value, bool important, bool notifyChanged, int &exceptionCode)
+{
+    exceptionCode = 0;
+
+    removeProperty(propertyID);
+
+    CSSParser parser(strictParsing);
+    bool success = parser.parseValue(this, propertyID, value, important);
+    if (!success) {
+#if !APPLE_CHANGES
+       kdDebug( 6080 ) << "CSSMutableStyleDeclarationImpl::setProperty invalid property: [" << getPropertyName(id).string()
                        << "] value: [" << value.string() << "]"<< endl;
                        << "] value: [" << value.string() << "]"<< endl;
-    else if (notifyChanged)
+#endif
+        exceptionCode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
+    } else if (notifyChanged)
         setChanged();
     return success;
 }
 
         setChanged();
     return success;
 }
 
-void CSSStyleDeclarationImpl::setProperty(int id, int value, bool important, bool notifyChanged)
+bool CSSMutableStyleDeclarationImpl::setProperty(int propertyID, int value, bool important, bool notifyChanged)
 {
 {
-    if(!m_lstValues) {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete(true);
-    }
-    removeProperty(id);
-
-    CSSValueImpl * cssValue = new CSSPrimitiveValueImpl(value);
-    setParsedValue(id, cssValue, important, m_lstValues);
+    removeProperty(propertyID);
+    m_values.append(CSSProperty(propertyID, new CSSPrimitiveValueImpl(value), important));
     if (notifyChanged)
         setChanged();
     if (notifyChanged)
         setChanged();
+    return true;
 }
 
 }
 
-void CSSStyleDeclarationImpl::setStringProperty(int propertyId, const DOMString &value, CSSPrimitiveValue::UnitTypes type, bool important)
+void CSSMutableStyleDeclarationImpl::setStringProperty(int propertyId, const DOMString &value, CSSPrimitiveValue::UnitTypes type, bool important)
 {
 {
-    if (!m_lstValues) {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete(true);
-    }
     removeProperty(propertyId);
     removeProperty(propertyId);
-    setParsedValue(propertyId, new CSSPrimitiveValueImpl(value, type), important, m_lstValues);
+    m_values.append(CSSProperty(propertyId, new CSSPrimitiveValueImpl(value, type), important));
     setChanged();
 }
 
     setChanged();
 }
 
-void CSSStyleDeclarationImpl::setImageProperty(int propertyId, const DOMString &URL, bool important)
+void CSSMutableStyleDeclarationImpl::setImageProperty(int propertyId, const DOMString &URL, bool important)
 {
 {
-    if (!m_lstValues) {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete(true);
-    }
     removeProperty(propertyId);
     removeProperty(propertyId);
-    setParsedValue(propertyId, new CSSImageValueImpl(URL, this), important, m_lstValues);
+    m_values.append(CSSProperty(propertyId, new CSSImageValueImpl(URL, this), important));
     setChanged();
 }
 
     setChanged();
 }
 
-void CSSStyleDeclarationImpl::setProperty ( const DOMString &propertyString)
+void CSSMutableStyleDeclarationImpl::parseProperty(const DOMString &propertyString)
 {
 {
-    if(!m_lstValues) {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete( true );
-    }
-
     CSSParser parser(strictParsing);
     parser.parseDeclaration(this, propertyString);
     setChanged();
 }
 
     CSSParser parser(strictParsing);
     parser.parseDeclaration(this, propertyString);
     setChanged();
 }
 
-void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &value, bool important, bool _multiLength )
+void CSSMutableStyleDeclarationImpl::addParsedProperties(const CSSProperty * const *properties, int numProperties)
+{
+    for (int i = 0; i < numProperties; ++i) {
+        removeProperty(properties[i]->id(), false);
+        m_values.append(*properties[i]);
+    }
+}
+
+void CSSMutableStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &value, bool important, bool _multiLength )
 {
     bool parseMode = strictParsing;
     strictParsing = false;
 {
     bool parseMode = strictParsing;
     strictParsing = false;
@@ -369,12 +359,12 @@ void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &va
     multiLength = false;
 }
 
     multiLength = false;
 }
 
-unsigned long CSSStyleDeclarationImpl::length() const
+unsigned long CSSMutableStyleDeclarationImpl::length() const
 {
 {
-    return m_lstValues ? m_lstValues->count() : 0;
+    return m_values.count();
 }
 
 }
 
-DOMString CSSStyleDeclarationImpl::item( unsigned long /*index*/ )
+DOMString CSSMutableStyleDeclarationImpl::item( unsigned long /*index*/ ) const
 {
     // ###
     //return m_lstValues->at(index);
 {
     // ###
     //return m_lstValues->at(index);
@@ -387,73 +377,58 @@ CSSRuleImpl *CSSStyleDeclarationImpl::parentRule() const
        static_cast<CSSRuleImpl *>(m_parent) : 0;
 }
 
        static_cast<CSSRuleImpl *>(m_parent) : 0;
 }
 
-DOM::DOMString CSSStyleDeclarationImpl::cssText() const
+DOM::DOMString CSSMutableStyleDeclarationImpl::cssText() const
 {
 {
-    DOMString result;
+    DOMString result = "";
     
     
-    if ( m_lstValues) {
-       QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
-       CSSProperty *current;
-       for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt )
-           result += current->cssText();
-    }
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it)
+        result += (*it).cssText();
 
     return result;
 }
 
 
     return result;
 }
 
-void CSSStyleDeclarationImpl::setCssText(const DOM::DOMString& text)
+void CSSMutableStyleDeclarationImpl::setCssText(const DOM::DOMString& text, int &exceptionCode)
 {
 {
-    if (m_lstValues)
-        m_lstValues->clear();
-    else {
-       m_lstValues = new QPtrList<CSSProperty>;
-       m_lstValues->setAutoDelete(true);
-    }
-
+    exceptionCode = 0;
+    m_values.clear();
     CSSParser parser(strictParsing);
     parser.parseDeclaration(this, text);
     CSSParser parser(strictParsing);
     parser.parseDeclaration(this, text);
+    // FIXME: Detect syntax errors and set exceptionCode.
     setChanged();
 }
 
     setChanged();
 }
 
-bool CSSStyleDeclarationImpl::parseString( const DOMString &/*string*/, bool )
+void CSSMutableStyleDeclarationImpl::merge(CSSMutableStyleDeclarationImpl *other, bool argOverridesOnConflict)
 {
 {
-    return false;
-    // ###
-}
-
-void CSSStyleDeclarationImpl::merge(CSSStyleDeclarationImpl *other, bool argOverridesOnConflict)
-{
-    for (QPtrListIterator<CSSProperty> it(*(other->values())); it.current(); ++it) {
-        CSSProperty *property = it.current();
-        CSSValueImpl *value = getPropertyCSSValue(property->id());
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = other->valuesIterator(); it != end; ++it) {
+        const CSSProperty &property = *it;
+        CSSValueImpl *value = getPropertyCSSValue(property.id());
         if (value) {
             value->ref();
             value->deref();
             if (!argOverridesOnConflict)
                 continue;
         if (value) {
             value->ref();
             value->deref();
             if (!argOverridesOnConflict)
                 continue;
-            removeProperty(property->id());
+            removeProperty(property.id());
         }
         }
-        if (!m_lstValues) {
-            m_lstValues = new QPtrList<CSSProperty>;
-            m_lstValues->setAutoDelete(true);
-        }
-        m_lstValues->append(new CSSProperty(*property));
+        m_values.append(property);
     }
 }
 
     }
 }
 
-void CSSStyleDeclarationImpl::diff(CSSStyleDeclarationImpl *style) const
+void CSSStyleDeclarationImpl::diff(CSSMutableStyleDeclarationImpl *style) const
 {
     if (!style)
         return;
 
     QValueList<int> properties;
 {
     if (!style)
         return;
 
     QValueList<int> properties;
-    for (QPtrListIterator<CSSProperty> it(*style->values()); it.current(); ++it) {
-        CSSProperty *property = it.current();
-        CSSValueImpl *value = getPropertyCSSValue(property->id());
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it(style->valuesIterator()); it != end; ++it) {
+        const CSSProperty &property = *it;
+        CSSValueImpl *value = getPropertyCSSValue(property.id());
         if (value) {
             value->ref();
         if (value) {
             value->ref();
-            if (value->cssText() == property->value()->cssText()) {
-                properties.append(property->id());
+            if (value->cssText() == property.value()->cssText()) {
+                properties.append(property.id());
             }
             value->deref();
         }
             }
             value->deref();
         }
@@ -476,40 +451,34 @@ static const int BlockProperties[] = {
     CSS_PROP_WIDOWS
 };
 
     CSS_PROP_WIDOWS
 };
 
-CSSStyleDeclarationImpl *CSSStyleDeclarationImpl::copyBlockProperties() const
+CSSMutableStyleDeclarationImpl *CSSMutableStyleDeclarationImpl::copyBlockProperties() const
 {
     return copyPropertiesInSet(BlockProperties, sizeof(BlockProperties) / sizeof(BlockProperties[0]));
 }
 
 {
     return copyPropertiesInSet(BlockProperties, sizeof(BlockProperties) / sizeof(BlockProperties[0]));
 }
 
-CSSStyleDeclarationImpl *CSSStyleDeclarationImpl::copyPropertiesInSet(const int *set, unsigned length) const
+CSSMutableStyleDeclarationImpl *CSSStyleDeclarationImpl::copyPropertiesInSet(const int *set, unsigned length) const
 {
 {
-    QPtrList<CSSProperty> *list = new QPtrList<CSSProperty>;
-    list->setAutoDelete(true);
+    QValueList<CSSProperty> list;
     for (unsigned i = 0; i < length; i++) {
         CSSValueImpl *value = getPropertyCSSValue(set[i]);
     for (unsigned i = 0; i < length; i++) {
         CSSValueImpl *value = getPropertyCSSValue(set[i]);
-        if (value) {
-            CSSProperty *property = new CSSProperty;
-            property->m_id = set[i];
-            property->setValue(value);
-            list->append(property);
-        }
+        if (value)
+            list.append(CSSProperty(set[i], value, false));
     }
     }
-    CSSStyleDeclarationImpl *result = new CSSStyleDeclarationImpl(0, list);
-    delete list;
-    return result;
+    return new CSSMutableStyleDeclarationImpl(0, list);
 }
 
 }
 
-// --------------------------------------------------------------------------------------
-
-CSSValueImpl::CSSValueImpl()
-    : StyleBaseImpl()
+CSSMutableStyleDeclarationImpl *CSSMutableStyleDeclarationImpl::makeMutable()
 {
 {
+    return this;
 }
 
 }
 
-CSSValueImpl::~CSSValueImpl()
+CSSMutableStyleDeclarationImpl *CSSMutableStyleDeclarationImpl::copy() const
 {
 {
+    return new CSSMutableStyleDeclarationImpl(0, m_values);
 }
 
 }
 
+// --------------------------------------------------------------------------------------
+
 unsigned short CSSInheritedValueImpl::cssValueType() const
 {
     return CSSValue::CSS_INHERIT;
 unsigned short CSSInheritedValueImpl::cssValueType() const
 {
     return CSSValue::CSS_INHERIT;
@@ -533,7 +502,6 @@ DOM::DOMString CSSInitialValueImpl::cssText() const
 // ----------------------------------------------------------------------------------------
 
 CSSValueListImpl::CSSValueListImpl()
 // ----------------------------------------------------------------------------------------
 
 CSSValueListImpl::CSSValueListImpl()
-    : CSSValueImpl()
 {
 }
 
 {
 }
 
@@ -1206,3 +1174,5 @@ DOMString CSSProperty::cssText() const
 {
     return getPropertyName(m_id) + DOMString(": ") + m_value->cssText() + (m_bImportant ? DOMString(" !important") : DOMString()) + DOMString("; ");
 }
 {
     return getPropertyName(m_id) + DOMString(": ") + m_value->cssText() + (m_bImportant ? DOMString(" !important") : DOMString()) + DOMString("; ");
 }
+
+}
index 4f0259fa4a526d1ea5a9adeea7ef3ef0ba7549bc..7ea65cd09be4c75fe32a484a2ce8b4a3d9ce0897 100644 (file)
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
- *
- * $Id$
  */
  */
+
 #ifndef _CSS_css_valueimpl_h_
 #define _CSS_css_valueimpl_h_
 
 #include "dom/css_value.h"
 #ifndef _CSS_css_valueimpl_h_
 #define _CSS_css_valueimpl_h_
 
 #include "dom/css_value.h"
-#include "dom/dom_string.h"
 #include "css/css_base.h"
 #include "misc/loader_client.h"
 #include "css/css_base.h"
 #include "misc/loader_client.h"
-#include "misc/shared.h"
-
-#include <qintdict.h>
+#include <qvaluelist.h>
 
 namespace khtml {
     class RenderStyle;
 
 namespace khtml {
     class RenderStyle;
@@ -40,81 +36,48 @@ namespace khtml {
 
 namespace DOM {
 
 
 namespace DOM {
 
-class CSSRuleImpl;
-class CSSValueImpl;
-class NodeImpl;
+class CSSMutableStyleDeclarationImpl;
 class CounterImpl;
 
 class CSSStyleDeclarationImpl : public StyleBaseImpl
 {
 public:
 class CounterImpl;
 
 class CSSStyleDeclarationImpl : public StyleBaseImpl
 {
 public:
-    CSSStyleDeclarationImpl(CSSRuleImpl *parentRule = 0);
-    CSSStyleDeclarationImpl(CSSRuleImpl *parentRule, QPtrList<CSSProperty> *lstValues);
-    virtual ~CSSStyleDeclarationImpl();
+    virtual bool isStyleDeclaration();
 
 
-    CSSStyleDeclarationImpl& operator=( const CSSStyleDeclarationImpl&);
-
-    unsigned long length() const;
     CSSRuleImpl *parentRule() const;
     CSSRuleImpl *parentRule() const;
-    virtual DOM::DOMString removeProperty(int propertyID, bool notifyChanged = true);
-    virtual bool setProperty(int propertyId, const DOM::DOMString &value, bool important = false, bool notifyChanged = true);
-    virtual void setProperty(int propertyId, int value, bool important = false, bool notifyChanged = true);
-    // this treats integers as pixels!
-    // needed for conversion of html attributes
-    virtual void setLengthProperty(int id, const DOM::DOMString &value, bool important,bool multiLength = false);
-    virtual void setStringProperty(int propertyId, const DOM::DOMString &value, DOM::CSSPrimitiveValue::UnitTypes, bool important = false); // parsed string value
-    virtual void setImageProperty(int propertyId, const DOM::DOMString &URL, bool important = false);
-
-    // add a whole, unparsed property
-    virtual void setProperty ( const DOMString &propertyString);
-    virtual DOM::DOMString item ( unsigned long index );
-
-    virtual DOM::DOMString cssText() const;
-    virtual void setCssText(const DOM::DOMString& str);
-
-    virtual bool isStyleDeclaration() { return true; }
-
-    virtual bool parseString( const DOMString &string, bool = false );
-
-    virtual CSSValueImpl *getPropertyCSSValue( int propertyID ) const;
-    virtual DOMString getPropertyValue( int propertyID ) const;
-    virtual bool getPropertyPriority( int propertyID ) const;
-
-    QPtrList<CSSProperty> *values() { return m_lstValues; }
-    const QPtrList<CSSProperty> *values() const { return m_lstValues; }
-    void setNode(NodeImpl *_node) { m_node = _node; }
-    NodeImpl* node() const { return m_node; }
-    
-    void merge(CSSStyleDeclarationImpl *, bool argOverridesOnConflict=true);
-    void diff(CSSStyleDeclarationImpl *) const;
 
 
-    CSSStyleDeclarationImpl *copyBlockProperties() const;
+    virtual DOMString cssText() const = 0;
+    virtual void setCssText(const DOMString &, int &exceptionCode) = 0;
+
+    virtual unsigned long length() const = 0;
+    virtual DOMString item(unsigned long index) const = 0;
 
 
-    void setChanged();
+    virtual CSSValueImpl *getPropertyCSSValue(int propertyID) const = 0;
+    virtual DOMString getPropertyValue(int propertyID) const = 0;
+    virtual bool getPropertyPriority(int propertyID) const = 0;
 
 
-protected:
-    DOMString getShortHandValue( const int* properties, int number ) const;
-    DOMString get4Values( const int* properties ) const;
+    virtual void setProperty(int propertyId, const DOMString &value, bool important, int &exceptionCode) = 0;
+    virtual DOMString removeProperty(int propertyID, int &exceptionCode) = 0;
 
 
-    CSSStyleDeclarationImpl *copyPropertiesInSet(const int *set, unsigned length) const;
+    virtual CSSMutableStyleDeclarationImpl *copy() const = 0;
+    virtual CSSMutableStyleDeclarationImpl *makeMutable() = 0;
+    void diff(CSSMutableStyleDeclarationImpl *) const;
 
 
-    QPtrList<CSSProperty> *m_lstValues;
-    NodeImpl *m_node;
+protected:
+    CSSStyleDeclarationImpl(CSSRuleImpl *parentRule = 0);
+
+    CSSMutableStyleDeclarationImpl *copyPropertiesInSet(const int *set, unsigned length) const;
 
 private:
 
 private:
-    // currently not needed - make sure its not used
-    CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl& o);
+    CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl &);
+    CSSStyleDeclarationImpl& operator=(const CSSStyleDeclarationImpl &);
 };
 
 class CSSValueImpl : public StyleBaseImpl
 {
 public:
 };
 
 class CSSValueImpl : public StyleBaseImpl
 {
 public:
-    CSSValueImpl();
-
-    virtual ~CSSValueImpl();
-
     virtual unsigned short cssValueType() const = 0;
     virtual unsigned short cssValueType() const = 0;
-
     virtual DOMString cssText() const = 0;
 
     virtual bool isValue() { return true; }
     virtual DOMString cssText() const = 0;
 
     virtual bool isValue() { return true; }
@@ -124,9 +87,6 @@ public:
 class CSSInheritedValueImpl : public CSSValueImpl
 {
 public:
 class CSSInheritedValueImpl : public CSSValueImpl
 {
 public:
-    CSSInheritedValueImpl() : CSSValueImpl() {}
-    virtual ~CSSInheritedValueImpl() {}
-
     virtual unsigned short cssValueType() const;
     virtual DOMString cssText() const;
 };
     virtual unsigned short cssValueType() const;
     virtual DOMString cssText() const;
 };
@@ -173,8 +133,8 @@ public:
     CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type);
     CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type);
     CSSPrimitiveValueImpl(const Counter &c);
     CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type);
     CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type);
     CSSPrimitiveValueImpl(const Counter &c);
-    CSSPrimitiveValueImpl( RectImpl *r);
-    CSSPrimitiveValueImpl( DashboardRegionImpl *r);
+    CSSPrimitiveValueImpl(RectImpl *r);
+    CSSPrimitiveValueImpl(DashboardRegionImpl *r);
     CSSPrimitiveValueImpl(QRgb color);
 
     virtual ~CSSPrimitiveValueImpl();
     CSSPrimitiveValueImpl(QRgb color);
 
     virtual ~CSSPrimitiveValueImpl();
@@ -261,14 +221,11 @@ public:
     CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
       :CSSPrimitiveValueImpl(num, type) {}
 
     CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
       :CSSPrimitiveValueImpl(num, type) {}
 
-    virtual ~CSSQuirkPrimitiveValueImpl() {}
-
     virtual bool isQuirkValue() { return true; }
 };
 
 class CounterImpl : public khtml::Shared<CounterImpl> {
 public:
     virtual bool isQuirkValue() { return true; }
 };
 
 class CounterImpl : public khtml::Shared<CounterImpl> {
 public:
-    CounterImpl() { }
     DOMString identifier() const { return m_identifier; }
     DOMString listStyle() const { return m_listStyle; }
     DOMString separator() const { return m_separator; }
     DOMString identifier() const { return m_identifier; }
     DOMString listStyle() const { return m_listStyle; }
     DOMString separator() const { return m_separator; }
@@ -281,7 +238,7 @@ public:
 class RectImpl : public khtml::Shared<RectImpl> {
 public:
     RectImpl();
 class RectImpl : public khtml::Shared<RectImpl> {
 public:
     RectImpl();
-    ~RectImpl();
+    virtual ~RectImpl();
 
     CSSPrimitiveValueImpl *top() { return m_top; }
     CSSPrimitiveValueImpl *right() { return m_right; }
 
     CSSPrimitiveValueImpl *top() { return m_top; }
     CSSPrimitiveValueImpl *right() { return m_right; }
@@ -300,19 +257,21 @@ protected:
 };
 
 #if APPLE_CHANGES
 };
 
 #if APPLE_CHANGES
+
 class DashboardRegionImpl : public RectImpl {
 public:
 class DashboardRegionImpl : public RectImpl {
 public:
-    DashboardRegionImpl() : RectImpl(), m_next(0), m_isCircle(0), m_isRectangle(0) { };
+    DashboardRegionImpl() : m_next(0), m_isCircle(0), m_isRectangle(0) { }
     ~DashboardRegionImpl() {
         if (m_next)
             m_next->deref();
     ~DashboardRegionImpl() {
         if (m_next)
             m_next->deref();
-    };
+    }
 
 
-    void setNext (DashboardRegionImpl *next) {
-        if (m_next) m_next->deref();
+    void setNext (DashboardRegionImpl *next)
+    {
         if (next) next->ref();
         if (next) next->ref();
+        if (m_next) m_next->deref();
         m_next = next;
         m_next = next;
-    };
+    }
     
 public:
     DashboardRegionImpl *m_next;
     
 public:
     DashboardRegionImpl *m_next;
@@ -321,13 +280,14 @@ public:
     unsigned int m_isCircle:1;
     unsigned int m_isRectangle:1;
 };
     unsigned int m_isCircle:1;
     unsigned int m_isRectangle:1;
 };
+
 #endif
 
 class CSSImageValueImpl : public CSSPrimitiveValueImpl, public khtml::CachedObjectClient
 {
 public:
 #endif
 
 class CSSImageValueImpl : public CSSPrimitiveValueImpl, public khtml::CachedObjectClient
 {
 public:
-    CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style);
     CSSImageValueImpl();
     CSSImageValueImpl();
+    CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style);
     virtual ~CSSImageValueImpl();
 
     khtml::CachedImage *image(khtml::DocLoader* loader);
     virtual ~CSSImageValueImpl();
 
     khtml::CachedImage *image(khtml::DocLoader* loader);
@@ -417,11 +377,13 @@ public:
 class CSSProperty
 {
 public:
 class CSSProperty
 {
 public:
-    CSSProperty()
+    CSSProperty() : m_id(-1), m_bImportant(false), m_value(0)
     {
     {
-       m_id = -1;
-       m_bImportant = false;
-       m_value = 0;
+    }
+    CSSProperty(int propID, CSSValueImpl *value, bool important = false)
+        : m_id(propID), m_bImportant(important), m_value(value)
+    {
+        if (value) value->ref();
     }
     CSSProperty(const CSSProperty& o)
     {
     }
     CSSProperty(const CSSProperty& o)
     {
@@ -430,21 +392,27 @@ public:
         m_value = o.m_value;
         if (m_value) m_value->ref();
     }
         m_value = o.m_value;
         if (m_value) m_value->ref();
     }
+    CSSProperty &operator=(const CSSProperty& o)
+    {
+        if (o.m_value) o.m_value->ref();
+       if (m_value) m_value->deref();
+        m_id = o.m_id;
+        m_bImportant = o.m_bImportant;
+        m_value = o.m_value;
+        return *this;
+    }
     ~CSSProperty() {
        if(m_value) m_value->deref();
     }
 
     void setValue(CSSValueImpl *val) {
     ~CSSProperty() {
        if(m_value) m_value->deref();
     }
 
     void setValue(CSSValueImpl *val) {
-       if ( val != m_value ) {
-           if(m_value) m_value->deref();
-           m_value = val;
-           if(m_value) m_value->ref();
-       }
+       if (val) val->ref();
+        if (m_value) m_value->deref();
+        m_value = val;
     }
 
     int id() const { return m_id; }
     bool isImportant() const { return m_bImportant; }
     }
 
     int id() const { return m_id; }
     bool isImportant() const { return m_bImportant; }
-    
     CSSValueImpl *value() const { return m_value; }
     
     DOMString cssText() const;
     CSSValueImpl *value() const { return m_value; }
     
     DOMString cssText() const;
@@ -452,15 +420,76 @@ public:
     // make sure the following fits in 4 bytes.
     int  m_id;
     bool m_bImportant;
     // make sure the following fits in 4 bytes.
     int  m_id;
     bool m_bImportant;
+
 protected:
     CSSValueImpl *m_value;
 protected:
     CSSValueImpl *m_value;
+};
+
+class CSSMutableStyleDeclarationImpl : public CSSStyleDeclarationImpl
+{
+public:
+    CSSMutableStyleDeclarationImpl();
+    CSSMutableStyleDeclarationImpl(CSSRuleImpl *parentRule);
+    CSSMutableStyleDeclarationImpl(CSSRuleImpl *parentRule, const QValueList<CSSProperty> &);
+    CSSMutableStyleDeclarationImpl(CSSRuleImpl *parentRule, const CSSProperty * const *, int numProperties);
+    virtual ~CSSMutableStyleDeclarationImpl();
+
+    CSSMutableStyleDeclarationImpl &operator=(const CSSMutableStyleDeclarationImpl &);
 
 
+    void setNode(NodeImpl *node) { m_node = node; }
+
+    virtual DOMString cssText() const;
+    virtual void setCssText(const DOMString &, int &exceptionCode);
+
+    virtual unsigned long length() const;
+    virtual DOMString item(unsigned long index) const;
+
+    virtual CSSValueImpl *getPropertyCSSValue(int propertyID) const;
+    virtual DOMString getPropertyValue(int propertyID) const;
+    virtual bool getPropertyPriority(int propertyID) const;
+
+    virtual void setProperty(int propertyId, const DOMString &value, bool important, int &exceptionCode);
+    virtual DOMString removeProperty(int propertyID, int &exceptionCode);
+
+    virtual CSSMutableStyleDeclarationImpl *copy() const;
+    virtual CSSMutableStyleDeclarationImpl *makeMutable();
+
+    QValueListConstIterator<CSSProperty> valuesIterator() const { return m_values.begin(); }
+
+    bool setProperty(int propertyID, int value, bool important = false, bool notifyChanged = true);
+    bool setProperty(int propertyID, const DOMString &value, bool important, bool notifyChanged, int &exceptionCode);
+    bool setProperty(int propertyId, const DOMString &value, bool important = false, bool notifyChanged = true)
+        { int exceptionCode; return setProperty(propertyId, value, important, notifyChanged, exceptionCode); }
+
+    DOMString removeProperty(int propertyID, bool notifyChanged, int &exceptionCode);
+    DOMString removeProperty(int propertyID, bool notifyChanged = true)
+        { int exceptionCode; return removeProperty(propertyID, notifyChanged, exceptionCode); }
+
+    void setChanged();
+    // setLengthProperty treats integers as pixels! (Needed for conversion of HTML attributes.)
+    void setLengthProperty(int propertyId, const DOMString &value, bool important, bool multiLength = false);
+    void setStringProperty(int propertyId, const DOMString &value, CSSPrimitiveValue::UnitTypes, bool important = false); // parsed string value
+    void setImageProperty(int propertyId, const DOMString &URL, bool important = false);
+    void parseProperty(const DOMString &propertyString);
+
+    // Besides adding the properties, this also removes any existing properties with these IDs.
+    // It does no notification since it's called by the parser.
+    void addParsedProperties(const CSSProperty * const *, int numProperties);
+    CSSMutableStyleDeclarationImpl *copyBlockProperties() const;
+
+    void merge(CSSMutableStyleDeclarationImpl *, bool argOverridesOnConflict = true);
 private:
 private:
-    CSSProperty &operator=(const CSSProperty&);
+    DOMString getShortHandValue(const int* properties, int number) const;
+    DOMString get4Values(const int* properties) const;
+    QValueList<CSSProperty> m_values;
+    NodeImpl *m_node;
 };
 
 };
 
-typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
-
 } // namespace
 
 #endif
 } // namespace
 
 #endif
index 9d2c362b12848f6b7e644d03aa6e044ac3061fca..76c96ccc101e24cdcaf1ff2fbb0b922694b78b12 100644 (file)
@@ -223,10 +223,7 @@ bool CSSParser::parseValue( CSSMutableStyleDeclarationImpl *declaration, int _id
     bool ok = false;
     if ( numParsedProperties ) {
        ok = true;
     bool ok = false;
     if ( numParsedProperties ) {
        ok = true;
-       for ( int i = 0; i < numParsedProperties; i++ ) {
-           declaration->removeProperty(parsedProperties[i]->m_id);
-           declaration->values()->append( parsedProperties[i] );
-       }
+        declaration->addParsedProperties(parsedProperties, numParsedProperties);
        numParsedProperties = 0;
     }
 
        numParsedProperties = 0;
     }
 
@@ -305,10 +302,7 @@ bool CSSParser::parseDeclaration( CSSMutableStyleDeclarationImpl *declaration, c
     bool ok = false;
     if ( numParsedProperties ) {
        ok = true;
     bool ok = false;
     if ( numParsedProperties ) {
        ok = true;
-       for ( int i = 0; i < numParsedProperties; i++ ) {
-           declaration->removeProperty(parsedProperties[i]->m_id);
-           declaration->values()->append( parsedProperties[i] );
-       }
+        declaration->addParsedProperties(parsedProperties, numParsedProperties);
        numParsedProperties = 0;
     }
 
        numParsedProperties = 0;
     }
 
@@ -333,13 +327,9 @@ void CSSParser::addProperty( int propId, CSSValueImpl *value, bool important )
 
 CSSMutableStyleDeclarationImpl *CSSParser::createStyleDeclaration( CSSStyleRuleImpl *rule )
 {
 
 CSSMutableStyleDeclarationImpl *CSSParser::createStyleDeclaration( CSSStyleRuleImpl *rule )
 {
-    QPtrList<CSSProperty> *propList = new QPtrList<CSSProperty>;
-    propList->setAutoDelete( true );
-    for ( int i = 0; i < numParsedProperties; i++ )
-       propList->append( parsedProperties[i] );
-
+    CSSMutableStyleDeclarationImpl *result = new CSSMutableStyleDeclarationImpl(rule, parsedProperties, numParsedProperties);
     numParsedProperties = 0;
     numParsedProperties = 0;
-    return new CSSMutableStyleDeclarationImpl(rule, propList);
+    return result;
 }
 
 void CSSParser::clearProperties()
 }
 
 void CSSParser::clearProperties()
index c3e3fcbf428ad28578bf8a1c6b31d1e8791a0e9d..d041f322ed17a6315557fee46803827b6db3341a 100644 (file)
@@ -37,7 +37,7 @@ namespace DOM {
     class CSSValueImpl;
     class CSSValueListImpl;
     class CSSPrimitiveValueImpl;
     class CSSValueImpl;
     class CSSValueListImpl;
     class CSSPrimitiveValueImpl;
-    typedef class CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
+    class CSSMutableStyleDeclarationImpl;
     class CSSProperty;
     class CSSRuleListImpl;
 
     class CSSProperty;
     class CSSRuleListImpl;
 
index f79ca78cd01b20303e02a320f2e8e2c6d7d538c4..a9917d03e30a4c87200f9bcee9d4982d37124570 100644 (file)
@@ -191,7 +191,7 @@ findProp (register const char *str, register unsigned int len)
 {
   enum
     {
 {
   enum
     {
-      TOTAL_KEYWORDS = 159,
+      TOTAL_KEYWORDS = 157,
       MIN_WORD_LENGTH = 3,
       MAX_WORD_LENGTH = 32,
       MIN_HASH_VALUE = 3,
       MIN_WORD_LENGTH = 3,
       MAX_WORD_LENGTH = 32,
       MIN_HASH_VALUE = 3,
@@ -200,7 +200,7 @@ findProp (register const char *str, register unsigned int len)
 
   static const struct props wordlist_prop[] =
     {
 
   static const struct props wordlist_prop[] =
     {
-#line 135 "cssproperties.gperf"
+#line 134 "cssproperties.gperf"
       {"top", CSS_PROP_TOP},
 #line 46 "cssproperties.gperf"
       {"clip", CSS_PROP_CLIP},
       {"top", CSS_PROP_TOP},
 #line 46 "cssproperties.gperf"
       {"clip", CSS_PROP_CLIP},
@@ -210,131 +210,131 @@ findProp (register const char *str, register unsigned int len)
       {"bottom", CSS_PROP_BOTTOM},
 #line 45 "cssproperties.gperf"
       {"clear", CSS_PROP_CLEAR},
       {"bottom", CSS_PROP_BOTTOM},
 #line 45 "cssproperties.gperf"
       {"clear", CSS_PROP_CLEAR},
-#line 149 "cssproperties.gperf"
+#line 148 "cssproperties.gperf"
       {"border", CSS_PROP_BORDER},
 #line 48 "cssproperties.gperf"
       {"content", CSS_PROP_CONTENT},
 #line 52 "cssproperties.gperf"
       {"direction", CSS_PROP_DIRECTION},
       {"border", CSS_PROP_BORDER},
 #line 48 "cssproperties.gperf"
       {"content", CSS_PROP_CONTENT},
 #line 52 "cssproperties.gperf"
       {"direction", CSS_PROP_DIRECTION},
-#line 152 "cssproperties.gperf"
+#line 151 "cssproperties.gperf"
       {"border-top", CSS_PROP_BORDER_TOP},
       {"border-top", CSS_PROP_BORDER_TOP},
-#line 150 "cssproperties.gperf"
+#line 149 "cssproperties.gperf"
       {"border-color", CSS_PROP_BORDER_COLOR},
       {"border-color", CSS_PROP_BORDER_COLOR},
-#line 154 "cssproperties.gperf"
+#line 153 "cssproperties.gperf"
       {"border-bottom", CSS_PROP_BORDER_BOTTOM},
 #line 23 "cssproperties.gperf"
       {"border-top-color", CSS_PROP_BORDER_TOP_COLOR},
 #line 25 "cssproperties.gperf"
       {"border-bottom-color", CSS_PROP_BORDER_BOTTOM_COLOR},
       {"border-bottom", CSS_PROP_BORDER_BOTTOM},
 #line 23 "cssproperties.gperf"
       {"border-top-color", CSS_PROP_BORDER_TOP_COLOR},
 #line 25 "cssproperties.gperf"
       {"border-bottom-color", CSS_PROP_BORDER_BOTTOM_COLOR},
-#line 66 "cssproperties.gperf"
+#line 65 "cssproperties.gperf"
       {"-apple-line-clamp", CSS_PROP__APPLE_LINE_CLAMP},
       {"-apple-line-clamp", CSS_PROP__APPLE_LINE_CLAMP},
-#line 159 "cssproperties.gperf"
+#line 158 "cssproperties.gperf"
       {"margin", CSS_PROP_MARGIN},
       {"margin", CSS_PROP_MARGIN},
-#line 161 "cssproperties.gperf"
+#line 160 "cssproperties.gperf"
       {"padding", CSS_PROP_PADDING},
       {"padding", CSS_PROP_PADDING},
-#line 107 "cssproperties.gperf"
+#line 106 "cssproperties.gperf"
       {"position", CSS_PROP_POSITION},
       {"position", CSS_PROP_POSITION},
-#line 103 "cssproperties.gperf"
+#line 102 "cssproperties.gperf"
       {"page", CSS_PROP_PAGE},
       {"page", CSS_PROP_PAGE},
-#line 71 "cssproperties.gperf"
+#line 70 "cssproperties.gperf"
       {"margin-top", CSS_PROP_MARGIN_TOP},
       {"margin-top", CSS_PROP_MARGIN_TOP},
-#line 98 "cssproperties.gperf"
+#line 97 "cssproperties.gperf"
       {"padding-top", CSS_PROP_PADDING_TOP},
       {"padding-top", CSS_PROP_PADDING_TOP},
-#line 73 "cssproperties.gperf"
+#line 72 "cssproperties.gperf"
       {"margin-bottom", CSS_PROP_MARGIN_BOTTOM},
       {"margin-bottom", CSS_PROP_MARGIN_BOTTOM},
-#line 100 "cssproperties.gperf"
+#line 99 "cssproperties.gperf"
       {"padding-bottom", CSS_PROP_PADDING_BOTTOM},
 #line 44 "cssproperties.gperf"
       {"caption-side", CSS_PROP_CAPTION_SIDE},
       {"padding-bottom", CSS_PROP_PADDING_BOTTOM},
 #line 44 "cssproperties.gperf"
       {"caption-side", CSS_PROP_CAPTION_SIDE},
-#line 109 "cssproperties.gperf"
+#line 108 "cssproperties.gperf"
       {"right", CSS_PROP_RIGHT},
       {"right", CSS_PROP_RIGHT},
-#line 92 "cssproperties.gperf"
+#line 91 "cssproperties.gperf"
       {"orphans", CSS_PROP_ORPHANS},
       {"orphans", CSS_PROP_ORPHANS},
-#line 110 "cssproperties.gperf"
+#line 109 "cssproperties.gperf"
       {"size", CSS_PROP_SIZE},
 #line 19 "cssproperties.gperf"
       {"border-collapse", CSS_PROP_BORDER_COLLAPSE},
       {"size", CSS_PROP_SIZE},
 #line 19 "cssproperties.gperf"
       {"border-collapse", CSS_PROP_BORDER_COLLAPSE},
-#line 153 "cssproperties.gperf"
+#line 152 "cssproperties.gperf"
       {"border-right", CSS_PROP_BORDER_RIGHT},
 #line 24 "cssproperties.gperf"
       {"border-right-color", CSS_PROP_BORDER_RIGHT_COLOR},
       {"border-right", CSS_PROP_BORDER_RIGHT},
 #line 24 "cssproperties.gperf"
       {"border-right-color", CSS_PROP_BORDER_RIGHT_COLOR},
-#line 63 "cssproperties.gperf"
+#line 62 "cssproperties.gperf"
       {"height", CSS_PROP_HEIGHT},
 #line 20 "cssproperties.gperf"
       {"border-spacing", CSS_PROP_BORDER_SPACING},
       {"height", CSS_PROP_HEIGHT},
 #line 20 "cssproperties.gperf"
       {"border-spacing", CSS_PROP_BORDER_SPACING},
-#line 88 "cssproperties.gperf"
+#line 87 "cssproperties.gperf"
       {"min-height", CSS_PROP_MIN_HEIGHT},
       {"min-height", CSS_PROP_MIN_HEIGHT},
-#line 167 "cssproperties.gperf"
+#line 166 "cssproperties.gperf"
       {"scrollbar-track-color", CSS_PROP_SCROLLBAR_TRACK_COLOR},
       {"scrollbar-track-color", CSS_PROP_SCROLLBAR_TRACK_COLOR},
-#line 65 "cssproperties.gperf"
+#line 64 "cssproperties.gperf"
       {"letter-spacing", CSS_PROP_LETTER_SPACING},
       {"letter-spacing", CSS_PROP_LETTER_SPACING},
-#line 67 "cssproperties.gperf"
+#line 66 "cssproperties.gperf"
       {"line-height", CSS_PROP_LINE_HEIGHT},
       {"line-height", CSS_PROP_LINE_HEIGHT},
-#line 72 "cssproperties.gperf"
+#line 71 "cssproperties.gperf"
       {"margin-right", CSS_PROP_MARGIN_RIGHT},
       {"margin-right", CSS_PROP_MARGIN_RIGHT},
-#line 99 "cssproperties.gperf"
+#line 98 "cssproperties.gperf"
       {"padding-right", CSS_PROP_PADDING_RIGHT},
 #line 18 "cssproperties.gperf"
       {"-khtml-binding", CSS_PROP__KHTML_BINDING},
       {"padding-right", CSS_PROP_PADDING_RIGHT},
 #line 18 "cssproperties.gperf"
       {"-khtml-binding", CSS_PROP__KHTML_BINDING},
-#line 160 "cssproperties.gperf"
+#line 159 "cssproperties.gperf"
       {"outline", CSS_PROP_OUTLINE},
       {"outline", CSS_PROP_OUTLINE},
-#line 140 "cssproperties.gperf"
+#line 139 "cssproperties.gperf"
       {"vertical-align", CSS_PROP_VERTICAL_ALIGN},
       {"vertical-align", CSS_PROP_VERTICAL_ALIGN},
-#line 90 "cssproperties.gperf"
+#line 89 "cssproperties.gperf"
       {"-khtml-nbsp-mode", CSS_PROP__KHTML_NBSP_MODE},
       {"-khtml-nbsp-mode", CSS_PROP__KHTML_NBSP_MODE},
-#line 136 "cssproperties.gperf"
+#line 135 "cssproperties.gperf"
       {"unicode-bidi", CSS_PROP_UNICODE_BIDI},
       {"unicode-bidi", CSS_PROP_UNICODE_BIDI},
-#line 93 "cssproperties.gperf"
+#line 92 "cssproperties.gperf"
       {"outline-color", CSS_PROP_OUTLINE_COLOR},
       {"outline-color", CSS_PROP_OUTLINE_COLOR},
-#line 75 "cssproperties.gperf"
+#line 74 "cssproperties.gperf"
       {"-khtml-line-break", CSS_PROP__KHTML_LINE_BREAK},
       {"-khtml-line-break", CSS_PROP__KHTML_LINE_BREAK},
-#line 165 "cssproperties.gperf"
+#line 164 "cssproperties.gperf"
       {"scrollbar-3dlight-color", CSS_PROP_SCROLLBAR_3DLIGHT_COLOR},
       {"scrollbar-3dlight-color", CSS_PROP_SCROLLBAR_3DLIGHT_COLOR},
-#line 134 "cssproperties.gperf"
+#line 133 "cssproperties.gperf"
       {"-apple-dashboard-region", CSS_PROP__APPLE_DASHBOARD_REGION},
 #line 51 "cssproperties.gperf"
       {"cursor", CSS_PROP_CURSOR},
 #line 49 "cssproperties.gperf"
       {"counter-increment", CSS_PROP_COUNTER_INCREMENT},
       {"-apple-dashboard-region", CSS_PROP__APPLE_DASHBOARD_REGION},
 #line 51 "cssproperties.gperf"
       {"cursor", CSS_PROP_CURSOR},
 #line 49 "cssproperties.gperf"
       {"counter-increment", CSS_PROP_COUNTER_INCREMENT},
-#line 106 "cssproperties.gperf"
+#line 105 "cssproperties.gperf"
       {"page-break-inside", CSS_PROP_PAGE_BREAK_INSIDE},
       {"page-break-inside", CSS_PROP_PAGE_BREAK_INSIDE},
-#line 79 "cssproperties.gperf"
+#line 78 "cssproperties.gperf"
       {"-khtml-margin-start", CSS_PROP__KHTML_MARGIN_START},
       {"-khtml-margin-start", CSS_PROP__KHTML_MARGIN_START},
-#line 102 "cssproperties.gperf"
+#line 101 "cssproperties.gperf"
       {"-khtml-padding-start", CSS_PROP__KHTML_PADDING_START},
       {"-khtml-padding-start", CSS_PROP__KHTML_PADDING_START},
-#line 76 "cssproperties.gperf"
+#line 75 "cssproperties.gperf"
       {"-khtml-margin-collapse", CSS_PROP__KHTML_MARGIN_COLLAPSE},
       {"-khtml-margin-collapse", CSS_PROP__KHTML_MARGIN_COLLAPSE},
-#line 77 "cssproperties.gperf"
+#line 76 "cssproperties.gperf"
       {"-khtml-margin-top-collapse", CSS_PROP__KHTML_MARGIN_TOP_COLLAPSE},
 #line 50 "cssproperties.gperf"
       {"counter-reset", CSS_PROP_COUNTER_RESET},
       {"-khtml-margin-top-collapse", CSS_PROP__KHTML_MARGIN_TOP_COLLAPSE},
 #line 50 "cssproperties.gperf"
       {"counter-reset", CSS_PROP_COUNTER_RESET},
-#line 78 "cssproperties.gperf"
+#line 77 "cssproperties.gperf"
       {"-khtml-margin-bottom-collapse", CSS_PROP__KHTML_MARGIN_BOTTOM_COLLAPSE},
       {"-khtml-margin-bottom-collapse", CSS_PROP__KHTML_MARGIN_BOTTOM_COLLAPSE},
-#line 148 "cssproperties.gperf"
+#line 147 "cssproperties.gperf"
       {"background", CSS_PROP_BACKGROUND},
       {"background", CSS_PROP_BACKGROUND},
-#line 114 "cssproperties.gperf"
-      {"text-indent", CSS_PROP_TEXT_INDENT},
 #line 113 "cssproperties.gperf"
 #line 113 "cssproperties.gperf"
+      {"text-indent", CSS_PROP_TEXT_INDENT},
+#line 112 "cssproperties.gperf"
       {"text-decoration", CSS_PROP_TEXT_DECORATION},
 #line 11 "cssproperties.gperf"
       {"background-color", CSS_PROP_BACKGROUND_COLOR},
       {"text-decoration", CSS_PROP_TEXT_DECORATION},
 #line 11 "cssproperties.gperf"
       {"background-color", CSS_PROP_BACKGROUND_COLOR},
-#line 147 "cssproperties.gperf"
+#line 146 "cssproperties.gperf"
       {"z-index", CSS_PROP_Z_INDEX},
       {"z-index", CSS_PROP_Z_INDEX},
-#line 157 "cssproperties.gperf"
+#line 156 "cssproperties.gperf"
       {"font", CSS_PROP_FONT},
 #line 55 "cssproperties.gperf"
       {"float", CSS_PROP_FLOAT},
       {"font", CSS_PROP_FONT},
 #line 55 "cssproperties.gperf"
       {"float", CSS_PROP_FLOAT},
-#line 64 "cssproperties.gperf"
+#line 63 "cssproperties.gperf"
       {"left", CSS_PROP_LEFT},
       {"left", CSS_PROP_LEFT},
-#line 164 "cssproperties.gperf"
+#line 163 "cssproperties.gperf"
       {"scrollbar-highlight-color", CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR},
 #line 13 "cssproperties.gperf"
       {"background-repeat", CSS_PROP_BACKGROUND_REPEAT},
       {"scrollbar-highlight-color", CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR},
 #line 13 "cssproperties.gperf"
       {"background-repeat", CSS_PROP_BACKGROUND_REPEAT},
-#line 112 "cssproperties.gperf"
+#line 111 "cssproperties.gperf"
       {"text-align", CSS_PROP_TEXT_ALIGN},
       {"text-align", CSS_PROP_TEXT_ALIGN},
-#line 108 "cssproperties.gperf"
+#line 107 "cssproperties.gperf"
       {"quotes", CSS_PROP_QUOTES},
       {"quotes", CSS_PROP_QUOTES},
-#line 155 "cssproperties.gperf"
+#line 154 "cssproperties.gperf"
       {"border-left", CSS_PROP_BORDER_LEFT},
 #line 21 "cssproperties.gperf"
       {"-khtml-border-horizontal-spacing", CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING},
       {"border-left", CSS_PROP_BORDER_LEFT},
 #line 21 "cssproperties.gperf"
       {"-khtml-border-horizontal-spacing", CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING},
@@ -352,25 +352,25 @@ findProp (register const char *str, register unsigned int len)
       {"-khtml-box-orient", CSS_PROP__KHTML_BOX_ORIENT},
 #line 37 "cssproperties.gperf"
       {"-khtml-box-direction", CSS_PROP__KHTML_BOX_DIRECTION},
       {"-khtml-box-orient", CSS_PROP__KHTML_BOX_ORIENT},
 #line 37 "cssproperties.gperf"
       {"-khtml-box-direction", CSS_PROP__KHTML_BOX_DIRECTION},
-#line 74 "cssproperties.gperf"
+#line 73 "cssproperties.gperf"
       {"margin-left", CSS_PROP_MARGIN_LEFT},
       {"margin-left", CSS_PROP_MARGIN_LEFT},
-#line 101 "cssproperties.gperf"
+#line 100 "cssproperties.gperf"
       {"padding-left", CSS_PROP_PADDING_LEFT},
       {"padding-left", CSS_PROP_PADDING_LEFT},
-#line 121 "cssproperties.gperf"
+#line 120 "cssproperties.gperf"
       {"text-overline", CSS_PROP_TEXT_OVERLINE},
       {"text-overline", CSS_PROP_TEXT_OVERLINE},
-#line 80 "cssproperties.gperf"
+#line 79 "cssproperties.gperf"
       {"-khtml-marquee", CSS_PROP__KHTML_MARQUEE},
       {"-khtml-marquee", CSS_PROP__KHTML_MARQUEE},
-#line 86 "cssproperties.gperf"
+#line 85 "cssproperties.gperf"
       {"max-height", CSS_PROP_MAX_HEIGHT},
       {"max-height", CSS_PROP_MAX_HEIGHT},
-#line 137 "cssproperties.gperf"
+#line 136 "cssproperties.gperf"
       {"-khtml-user-drag", CSS_PROP__KHTML_USER_DRAG},
       {"-khtml-user-drag", CSS_PROP__KHTML_USER_DRAG},
-#line 122 "cssproperties.gperf"
+#line 121 "cssproperties.gperf"
       {"text-overline-color", CSS_PROP_TEXT_OVERLINE_COLOR},
       {"text-overline-color", CSS_PROP_TEXT_OVERLINE_COLOR},
-#line 162 "cssproperties.gperf"
+#line 161 "cssproperties.gperf"
       {"scrollbar-face-color", CSS_PROP_SCROLLBAR_FACE_COLOR},
       {"scrollbar-face-color", CSS_PROP_SCROLLBAR_FACE_COLOR},
-#line 61 "cssproperties.gperf"
+#line 60 "cssproperties.gperf"
       {"font-variant", CSS_PROP_FONT_VARIANT},
       {"font-variant", CSS_PROP_FONT_VARIANT},
-#line 123 "cssproperties.gperf"
+#line 122 "cssproperties.gperf"
       {"text-overline-mode", CSS_PROP_TEXT_OVERLINE_MODE},
 #line 57 "cssproperties.gperf"
       {"font-size", CSS_PROP_FONT_SIZE},
       {"text-overline-mode", CSS_PROP_TEXT_OVERLINE_MODE},
 #line 57 "cssproperties.gperf"
       {"font-size", CSS_PROP_FONT_SIZE},
@@ -378,37 +378,37 @@ findProp (register const char *str, register unsigned int len)
       {"-khtml-box-pack", CSS_PROP__KHTML_BOX_PACK},
 #line 36 "cssproperties.gperf"
       {"-khtml-box-align", CSS_PROP__KHTML_BOX_ALIGN},
       {"-khtml-box-pack", CSS_PROP__KHTML_BOX_PACK},
 #line 36 "cssproperties.gperf"
       {"-khtml-box-align", CSS_PROP__KHTML_BOX_ALIGN},
-#line 59 "cssproperties.gperf"
+#line 58 "cssproperties.gperf"
       {"font-stretch", CSS_PROP_FONT_STRETCH},
       {"font-stretch", CSS_PROP_FONT_STRETCH},
-#line 139 "cssproperties.gperf"
+#line 138 "cssproperties.gperf"
       {"-khtml-user-select", CSS_PROP__KHTML_USER_SELECT},
       {"-khtml-user-select", CSS_PROP__KHTML_USER_SELECT},
-#line 81 "cssproperties.gperf"
+#line 80 "cssproperties.gperf"
       {"-khtml-marquee-direction", CSS_PROP__KHTML_MARQUEE_DIRECTION},
 #line 40 "cssproperties.gperf"
       {"-khtml-box-lines", CSS_PROP__KHTML_BOX_LINES},
       {"-khtml-marquee-direction", CSS_PROP__KHTML_MARQUEE_DIRECTION},
 #line 40 "cssproperties.gperf"
       {"-khtml-box-lines", CSS_PROP__KHTML_BOX_LINES},
-#line 82 "cssproperties.gperf"
+#line 81 "cssproperties.gperf"
       {"-khtml-marquee-increment", CSS_PROP__KHTML_MARQUEE_INCREMENT},
       {"-khtml-marquee-increment", CSS_PROP__KHTML_MARQUEE_INCREMENT},
-#line 83 "cssproperties.gperf"
+#line 82 "cssproperties.gperf"
       {"-khtml-marquee-repetition", CSS_PROP__KHTML_MARQUEE_REPETITION},
       {"-khtml-marquee-repetition", CSS_PROP__KHTML_MARQUEE_REPETITION},
-#line 128 "cssproperties.gperf"
+#line 127 "cssproperties.gperf"
       {"text-underline", CSS_PROP_TEXT_UNDERLINE},
       {"text-underline", CSS_PROP_TEXT_UNDERLINE},
-#line 129 "cssproperties.gperf"
+#line 128 "cssproperties.gperf"
       {"text-underline-color", CSS_PROP_TEXT_UNDERLINE_COLOR},
       {"text-underline-color", CSS_PROP_TEXT_UNDERLINE_COLOR},
-#line 104 "cssproperties.gperf"
+#line 103 "cssproperties.gperf"
       {"page-break-after", CSS_PROP_PAGE_BREAK_AFTER},
       {"page-break-after", CSS_PROP_PAGE_BREAK_AFTER},
-#line 91 "cssproperties.gperf"
+#line 90 "cssproperties.gperf"
       {"opacity", CSS_PROP_OPACITY},
       {"opacity", CSS_PROP_OPACITY},
-#line 130 "cssproperties.gperf"
+#line 129 "cssproperties.gperf"
       {"text-underline-mode", CSS_PROP_TEXT_UNDERLINE_MODE},
       {"text-underline-mode", CSS_PROP_TEXT_UNDERLINE_MODE},
-#line 84 "cssproperties.gperf"
+#line 83 "cssproperties.gperf"
       {"-khtml-marquee-speed", CSS_PROP__KHTML_MARQUEE_SPEED},
       {"-khtml-marquee-speed", CSS_PROP__KHTML_MARQUEE_SPEED},
-#line 105 "cssproperties.gperf"
+#line 104 "cssproperties.gperf"
       {"page-break-before", CSS_PROP_PAGE_BREAK_BEFORE},
       {"page-break-before", CSS_PROP_PAGE_BREAK_BEFORE},
-#line 144 "cssproperties.gperf"
+#line 143 "cssproperties.gperf"
       {"width", CSS_PROP_WIDTH},
       {"width", CSS_PROP_WIDTH},
-#line 89 "cssproperties.gperf"
+#line 88 "cssproperties.gperf"
       {"min-width", CSS_PROP_MIN_WIDTH},
       {"min-width", CSS_PROP_MIN_WIDTH},
-#line 156 "cssproperties.gperf"
+#line 155 "cssproperties.gperf"
       {"border-width", CSS_PROP_BORDER_WIDTH},
 #line 31 "cssproperties.gperf"
       {"border-top-width", CSS_PROP_BORDER_TOP_WIDTH},
       {"border-width", CSS_PROP_BORDER_WIDTH},
 #line 31 "cssproperties.gperf"
       {"border-top-width", CSS_PROP_BORDER_TOP_WIDTH},
@@ -416,105 +416,101 @@ findProp (register const char *str, register unsigned int len)
       {"display", CSS_PROP_DISPLAY},
 #line 33 "cssproperties.gperf"
       {"border-bottom-width", CSS_PROP_BORDER_BOTTOM_WIDTH},
       {"display", CSS_PROP_DISPLAY},
 #line 33 "cssproperties.gperf"
       {"border-bottom-width", CSS_PROP_BORDER_BOTTOM_WIDTH},
-#line 168 "cssproperties.gperf"
+#line 167 "cssproperties.gperf"
       {"scrollbar-arrow-color", CSS_PROP_SCROLLBAR_ARROW_COLOR},
 #line 54 "cssproperties.gperf"
       {"empty-cells", CSS_PROP_EMPTY_CELLS},
       {"scrollbar-arrow-color", CSS_PROP_SCROLLBAR_ARROW_COLOR},
 #line 54 "cssproperties.gperf"
       {"empty-cells", CSS_PROP_EMPTY_CELLS},
-#line 151 "cssproperties.gperf"
+#line 150 "cssproperties.gperf"
       {"border-style", CSS_PROP_BORDER_STYLE},
 #line 27 "cssproperties.gperf"
       {"border-top-style", CSS_PROP_BORDER_TOP_STYLE},
       {"border-style", CSS_PROP_BORDER_STYLE},
 #line 27 "cssproperties.gperf"
       {"border-top-style", CSS_PROP_BORDER_TOP_STYLE},
-#line 115 "cssproperties.gperf"
+#line 114 "cssproperties.gperf"
       {"text-line-through", CSS_PROP_TEXT_LINE_THROUGH},
 #line 29 "cssproperties.gperf"
       {"border-bottom-style", CSS_PROP_BORDER_BOTTOM_STYLE},
       {"text-line-through", CSS_PROP_TEXT_LINE_THROUGH},
 #line 29 "cssproperties.gperf"
       {"border-bottom-style", CSS_PROP_BORDER_BOTTOM_STYLE},
-#line 142 "cssproperties.gperf"
+#line 141 "cssproperties.gperf"
       {"white-space", CSS_PROP_WHITE_SPACE},
       {"white-space", CSS_PROP_WHITE_SPACE},
-#line 146 "cssproperties.gperf"
+#line 145 "cssproperties.gperf"
       {"word-spacing", CSS_PROP_WORD_SPACING},
       {"word-spacing", CSS_PROP_WORD_SPACING},
-#line 116 "cssproperties.gperf"
+#line 115 "cssproperties.gperf"
       {"text-line-through-color", CSS_PROP_TEXT_LINE_THROUGH_COLOR},
 #line 41 "cssproperties.gperf"
       {"-khtml-box-ordinal-group", CSS_PROP__KHTML_BOX_ORDINAL_GROUP},
       {"text-line-through-color", CSS_PROP_TEXT_LINE_THROUGH_COLOR},
 #line 41 "cssproperties.gperf"
       {"-khtml-box-ordinal-group", CSS_PROP__KHTML_BOX_ORDINAL_GROUP},
-#line 117 "cssproperties.gperf"
+#line 116 "cssproperties.gperf"
       {"text-line-through-mode", CSS_PROP_TEXT_LINE_THROUGH_MODE},
       {"text-line-through-mode", CSS_PROP_TEXT_LINE_THROUGH_MODE},
-#line 158 "cssproperties.gperf"
+#line 157 "cssproperties.gperf"
       {"list-style", CSS_PROP_LIST_STYLE},
 #line 16 "cssproperties.gperf"
       {"background-position-x", CSS_PROP_BACKGROUND_POSITION_X},
 #line 32 "cssproperties.gperf"
       {"border-right-width", CSS_PROP_BORDER_RIGHT_WIDTH},
       {"list-style", CSS_PROP_LIST_STYLE},
 #line 16 "cssproperties.gperf"
       {"background-position-x", CSS_PROP_BACKGROUND_POSITION_X},
 #line 32 "cssproperties.gperf"
       {"border-right-width", CSS_PROP_BORDER_RIGHT_WIDTH},
-#line 141 "cssproperties.gperf"
+#line 140 "cssproperties.gperf"
       {"visibility", CSS_PROP_VISIBILITY},
       {"visibility", CSS_PROP_VISIBILITY},
-#line 133 "cssproperties.gperf"
+#line 132 "cssproperties.gperf"
       {"-apple-text-size-adjust", CSS_PROP__APPLE_TEXT_SIZE_ADJUST},
       {"-apple-text-size-adjust", CSS_PROP__APPLE_TEXT_SIZE_ADJUST},
-#line 127 "cssproperties.gperf"
+#line 126 "cssproperties.gperf"
       {"text-transform", CSS_PROP_TEXT_TRANSFORM},
       {"text-transform", CSS_PROP_TEXT_TRANSFORM},
-#line 163 "cssproperties.gperf"
+#line 162 "cssproperties.gperf"
       {"scrollbar-shadow-color", CSS_PROP_SCROLLBAR_SHADOW_COLOR},
       {"scrollbar-shadow-color", CSS_PROP_SCROLLBAR_SHADOW_COLOR},
-#line 58 "cssproperties.gperf"
-      {"font-size-adjust", CSS_PROP_FONT_SIZE_ADJUST},
-#line 111 "cssproperties.gperf"
+#line 110 "cssproperties.gperf"
       {"table-layout", CSS_PROP_TABLE_LAYOUT},
 #line 28 "cssproperties.gperf"
       {"border-right-style", CSS_PROP_BORDER_RIGHT_STYLE},
       {"table-layout", CSS_PROP_TABLE_LAYOUT},
 #line 28 "cssproperties.gperf"
       {"border-right-style", CSS_PROP_BORDER_RIGHT_STYLE},
-#line 96 "cssproperties.gperf"
+#line 95 "cssproperties.gperf"
       {"outline-width", CSS_PROP_OUTLINE_WIDTH},
       {"outline-width", CSS_PROP_OUTLINE_WIDTH},
-#line 69 "cssproperties.gperf"
-      {"list-style-position", CSS_PROP_LIST_STYLE_POSITION},
 #line 68 "cssproperties.gperf"
 #line 68 "cssproperties.gperf"
+      {"list-style-position", CSS_PROP_LIST_STYLE_POSITION},
+#line 67 "cssproperties.gperf"
       {"list-style-image", CSS_PROP_LIST_STYLE_IMAGE},
       {"list-style-image", CSS_PROP_LIST_STYLE_IMAGE},
-#line 166 "cssproperties.gperf"
+#line 165 "cssproperties.gperf"
       {"scrollbar-darkshadow-color", CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR},
       {"scrollbar-darkshadow-color", CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR},
-#line 95 "cssproperties.gperf"
+#line 94 "cssproperties.gperf"
       {"outline-style", CSS_PROP_OUTLINE_STYLE},
       {"outline-style", CSS_PROP_OUTLINE_STYLE},
-#line 87 "cssproperties.gperf"
+#line 86 "cssproperties.gperf"
       {"max-width", CSS_PROP_MAX_WIDTH},
       {"max-width", CSS_PROP_MAX_WIDTH},
-#line 126 "cssproperties.gperf"
+#line 125 "cssproperties.gperf"
       {"text-shadow", CSS_PROP_TEXT_SHADOW},
 #line 17 "cssproperties.gperf"
       {"background-position-y", CSS_PROP_BACKGROUND_POSITION_Y},
 #line 34 "cssproperties.gperf"
       {"border-left-width", CSS_PROP_BORDER_LEFT_WIDTH},
       {"text-shadow", CSS_PROP_TEXT_SHADOW},
 #line 17 "cssproperties.gperf"
       {"background-position-y", CSS_PROP_BACKGROUND_POSITION_Y},
 #line 34 "cssproperties.gperf"
       {"border-left-width", CSS_PROP_BORDER_LEFT_WIDTH},
-#line 60 "cssproperties.gperf"
+#line 59 "cssproperties.gperf"
       {"font-style", CSS_PROP_FONT_STYLE},
       {"font-style", CSS_PROP_FONT_STYLE},
-#line 94 "cssproperties.gperf"
+#line 93 "cssproperties.gperf"
       {"outline-offset", CSS_PROP_OUTLINE_OFFSET},
       {"outline-offset", CSS_PROP_OUTLINE_OFFSET},
-#line 97 "cssproperties.gperf"
+#line 96 "cssproperties.gperf"
       {"overflow", CSS_PROP_OVERFLOW},
       {"overflow", CSS_PROP_OVERFLOW},
-#line 62 "cssproperties.gperf"
+#line 61 "cssproperties.gperf"
       {"font-weight", CSS_PROP_FONT_WEIGHT},
       {"font-weight", CSS_PROP_FONT_WEIGHT},
-#line 169 "cssproperties.gperf"
-      {"-khtml-flow-mode", CSS_PROP__KHTML_FLOW_MODE},
 #line 30 "cssproperties.gperf"
       {"border-left-style", CSS_PROP_BORDER_LEFT_STYLE},
 #line 30 "cssproperties.gperf"
       {"border-left-style", CSS_PROP_BORDER_LEFT_STYLE},
-#line 125 "cssproperties.gperf"
+#line 124 "cssproperties.gperf"
       {"text-overline-width", CSS_PROP_TEXT_OVERLINE_WIDTH},
 #line 38 "cssproperties.gperf"
       {"-khtml-box-flex", CSS_PROP__KHTML_BOX_FLEX},
       {"text-overline-width", CSS_PROP_TEXT_OVERLINE_WIDTH},
 #line 38 "cssproperties.gperf"
       {"-khtml-box-flex", CSS_PROP__KHTML_BOX_FLEX},
-#line 145 "cssproperties.gperf"
+#line 144 "cssproperties.gperf"
       {"word-wrap", CSS_PROP_WORD_WRAP},
       {"word-wrap", CSS_PROP_WORD_WRAP},
-#line 124 "cssproperties.gperf"
+#line 123 "cssproperties.gperf"
       {"text-overline-style", CSS_PROP_TEXT_OVERLINE_STYLE},
       {"text-overline-style", CSS_PROP_TEXT_OVERLINE_STYLE},
-#line 85 "cssproperties.gperf"
+#line 84 "cssproperties.gperf"
       {"-khtml-marquee-style", CSS_PROP__KHTML_MARQUEE_STYLE},
       {"-khtml-marquee-style", CSS_PROP__KHTML_MARQUEE_STYLE},
-#line 132 "cssproperties.gperf"
+#line 131 "cssproperties.gperf"
       {"text-underline-width", CSS_PROP_TEXT_UNDERLINE_WIDTH},
       {"text-underline-width", CSS_PROP_TEXT_UNDERLINE_WIDTH},
-#line 143 "cssproperties.gperf"
+#line 142 "cssproperties.gperf"
       {"widows", CSS_PROP_WIDOWS},
       {"widows", CSS_PROP_WIDOWS},
-#line 131 "cssproperties.gperf"
+#line 130 "cssproperties.gperf"
       {"text-underline-style", CSS_PROP_TEXT_UNDERLINE_STYLE},
       {"text-underline-style", CSS_PROP_TEXT_UNDERLINE_STYLE},
-#line 119 "cssproperties.gperf"
+#line 118 "cssproperties.gperf"
       {"text-line-through-width", CSS_PROP_TEXT_LINE_THROUGH_WIDTH},
 #line 56 "cssproperties.gperf"
       {"font-family", CSS_PROP_FONT_FAMILY},
       {"text-line-through-width", CSS_PROP_TEXT_LINE_THROUGH_WIDTH},
 #line 56 "cssproperties.gperf"
       {"font-family", CSS_PROP_FONT_FAMILY},
-#line 70 "cssproperties.gperf"
+#line 69 "cssproperties.gperf"
       {"list-style-type", CSS_PROP_LIST_STYLE_TYPE},
       {"list-style-type", CSS_PROP_LIST_STYLE_TYPE},
-#line 138 "cssproperties.gperf"
+#line 137 "cssproperties.gperf"
       {"-khtml-user-modify", CSS_PROP__KHTML_USER_MODIFY},
       {"-khtml-user-modify", CSS_PROP__KHTML_USER_MODIFY},
-#line 118 "cssproperties.gperf"
+#line 117 "cssproperties.gperf"
       {"text-line-through-style", CSS_PROP_TEXT_LINE_THROUGH_STYLE},
       {"text-line-through-style", CSS_PROP_TEXT_LINE_THROUGH_STYLE},
-#line 120 "cssproperties.gperf"
+#line 119 "cssproperties.gperf"
       {"text-overflow", CSS_PROP_TEXT_OVERFLOW},
 #line 39 "cssproperties.gperf"
       {"-khtml-box-flex-group", CSS_PROP__KHTML_BOX_FLEX_GROUP}
       {"text-overflow", CSS_PROP_TEXT_OVERFLOW},
 #line 39 "cssproperties.gperf"
       {"-khtml-box-flex-group", CSS_PROP__KHTML_BOX_FLEX_GROUP}
@@ -551,29 +547,29 @@ findProp (register const char *str, register unsigned int len)
        -1, 111, 112,  -1, 113,  -1, 114, 115, 116, 117,
        -1,  -1, 118,  -1,  -1, 119, 120,  -1,  -1,  -1,
        -1,  -1,  -1, 121,  -1, 122,  -1,  -1, 123, 124,
        -1, 111, 112,  -1, 113,  -1, 114, 115, 116, 117,
        -1,  -1, 118,  -1,  -1, 119, 120,  -1,  -1,  -1,
        -1,  -1,  -1, 121,  -1, 122,  -1,  -1, 123, 124,
-       -1,  -1, 125,  -1,  -1,  -1, 126, 127,  -1,  -1,
-       -1,  -1,  -1, 128,  -1,  -1,  -1,  -1, 129, 130,
-       -1, 131,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-       -1, 132,  -1,  -1,  -1,  -1,  -1,  -1, 133,  -1,
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 134,
+       -1,  -1, 125,  -1,  -1,  -1,  -1, 126,  -1,  -1,
+       -1,  -1,  -1, 127,  -1,  -1,  -1,  -1, 128, 129,
+       -1, 130,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1, 131,  -1,  -1,  -1,  -1,  -1,  -1, 132,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 133,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-       -1, 135,  -1,  -1,  -1,  -1, 136,  -1,  -1,  -1,
-       -1,  -1, 137,  -1,  -1, 138,  -1,  -1,  -1, 139,
-       -1,  -1,  -1, 140,  -1,  -1, 141,  -1,  -1,  -1,
-       -1, 142, 143,  -1, 144,  -1,  -1,  -1,  -1,  -1,
-       -1,  -1,  -1,  -1,  -1, 145,  -1,  -1,  -1, 146,
-       -1,  -1,  -1,  -1, 147, 148,  -1,  -1,  -1,  -1,
+       -1, 134,  -1,  -1,  -1,  -1, 135,  -1,  -1,  -1,
+       -1,  -1, 136,  -1,  -1, 137,  -1,  -1,  -1, 138,
+       -1,  -1,  -1, 139,  -1,  -1, 140,  -1,  -1,  -1,
+       -1,  -1, 141,  -1, 142,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 143,  -1,  -1,  -1, 144,
+       -1,  -1,  -1,  -1, 145, 146,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 147,  -1,  -1,  -1,  -1,
+       -1, 148,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1, 149,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1, 149,  -1,  -1,  -1,  -1,
-       -1, 150,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-       -1,  -1,  -1,  -1,  -1, 151,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
        -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 152,  -1,
-       -1, 153,  -1,  -1,  -1, 154,  -1,  -1,  -1,  -1,
-       -1,  -1,  -1, 155,  -1,  -1,  -1,  -1, 156,  -1,
-       -1,  -1,  -1, 157,  -1,  -1, 158
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 150,  -1,
+       -1, 151,  -1,  -1,  -1, 152,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 153,  -1,  -1,  -1,  -1, 154,  -1,
+       -1,  -1,  -1, 155,  -1,  -1, 156
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
@@ -595,7 +591,7 @@ findProp (register const char *str, register unsigned int len)
     }
   return 0;
 }
     }
   return 0;
 }
-#line 170 "cssproperties.gperf"
+#line 168 "cssproperties.gperf"
 
 static const char * const propertyList[] = {
 "",
 
 static const char * const propertyList[] = {
 "",
@@ -646,7 +642,6 @@ static const char * const propertyList[] = {
 "float", 
 "font-family", 
 "font-size", 
 "float", 
 "font-family", 
 "font-size", 
-"font-size-adjust", 
 "font-stretch", 
 "font-style", 
 "font-variant", 
 "font-stretch", 
 "font-style", 
 "font-variant", 
@@ -757,7 +752,6 @@ static const char * const propertyList[] = {
 "scrollbar-darkshadow-color", 
 "scrollbar-track-color", 
 "scrollbar-arrow-color", 
 "scrollbar-darkshadow-color", 
 "scrollbar-track-color", 
 "scrollbar-arrow-color", 
-"-khtml-flow-mode", 
     0
 };
 DOMString getPropertyName(unsigned short id)
     0
 };
 DOMString getPropertyName(unsigned short id)
index d17fd250e1cd1d264a514879b53523182a6742f6..ece970030ec443d9506e2e9202fb342ae52da8ac 100644 (file)
 #define CSS_PROP_FLOAT 45
 #define CSS_PROP_FONT_FAMILY 46
 #define CSS_PROP_FONT_SIZE 47
 #define CSS_PROP_FLOAT 45
 #define CSS_PROP_FONT_FAMILY 46
 #define CSS_PROP_FONT_SIZE 47
-#define CSS_PROP_FONT_SIZE_ADJUST 48
-#define CSS_PROP_FONT_STRETCH 49
-#define CSS_PROP_FONT_STYLE 50
-#define CSS_PROP_FONT_VARIANT 51
-#define CSS_PROP_FONT_WEIGHT 52
-#define CSS_PROP_HEIGHT 53
-#define CSS_PROP_LEFT 54
-#define CSS_PROP_LETTER_SPACING 55
-#define CSS_PROP__APPLE_LINE_CLAMP 56
-#define CSS_PROP_LINE_HEIGHT 57
-#define CSS_PROP_LIST_STYLE_IMAGE 58
-#define CSS_PROP_LIST_STYLE_POSITION 59
-#define CSS_PROP_LIST_STYLE_TYPE 60
-#define CSS_PROP_MARGIN_TOP 61
-#define CSS_PROP_MARGIN_RIGHT 62
-#define CSS_PROP_MARGIN_BOTTOM 63
-#define CSS_PROP_MARGIN_LEFT 64
-#define CSS_PROP__KHTML_LINE_BREAK 65
-#define CSS_PROP__KHTML_MARGIN_COLLAPSE 66
-#define CSS_PROP__KHTML_MARGIN_TOP_COLLAPSE 67
-#define CSS_PROP__KHTML_MARGIN_BOTTOM_COLLAPSE 68
-#define CSS_PROP__KHTML_MARGIN_START 69
-#define CSS_PROP__KHTML_MARQUEE 70
-#define CSS_PROP__KHTML_MARQUEE_DIRECTION 71
-#define CSS_PROP__KHTML_MARQUEE_INCREMENT 72
-#define CSS_PROP__KHTML_MARQUEE_REPETITION 73
-#define CSS_PROP__KHTML_MARQUEE_SPEED 74
-#define CSS_PROP__KHTML_MARQUEE_STYLE 75
-#define CSS_PROP_MAX_HEIGHT 76
-#define CSS_PROP_MAX_WIDTH 77
-#define CSS_PROP_MIN_HEIGHT 78
-#define CSS_PROP_MIN_WIDTH 79
-#define CSS_PROP__KHTML_NBSP_MODE 80
-#define CSS_PROP_OPACITY 81
-#define CSS_PROP_ORPHANS 82
-#define CSS_PROP_OUTLINE_COLOR 83
-#define CSS_PROP_OUTLINE_OFFSET 84
-#define CSS_PROP_OUTLINE_STYLE 85
-#define CSS_PROP_OUTLINE_WIDTH 86
-#define CSS_PROP_OVERFLOW 87
-#define CSS_PROP_PADDING_TOP 88
-#define CSS_PROP_PADDING_RIGHT 89
-#define CSS_PROP_PADDING_BOTTOM 90
-#define CSS_PROP_PADDING_LEFT 91
-#define CSS_PROP__KHTML_PADDING_START 92
-#define CSS_PROP_PAGE 93
-#define CSS_PROP_PAGE_BREAK_AFTER 94
-#define CSS_PROP_PAGE_BREAK_BEFORE 95
-#define CSS_PROP_PAGE_BREAK_INSIDE 96
-#define CSS_PROP_POSITION 97
-#define CSS_PROP_QUOTES 98
-#define CSS_PROP_RIGHT 99
-#define CSS_PROP_SIZE 100
-#define CSS_PROP_TABLE_LAYOUT 101
-#define CSS_PROP_TEXT_ALIGN 102
-#define CSS_PROP_TEXT_DECORATION 103
-#define CSS_PROP_TEXT_INDENT 104
-#define CSS_PROP_TEXT_LINE_THROUGH 105
-#define CSS_PROP_TEXT_LINE_THROUGH_COLOR 106
-#define CSS_PROP_TEXT_LINE_THROUGH_MODE 107
-#define CSS_PROP_TEXT_LINE_THROUGH_STYLE 108
-#define CSS_PROP_TEXT_LINE_THROUGH_WIDTH 109
-#define CSS_PROP_TEXT_OVERFLOW 110
-#define CSS_PROP_TEXT_OVERLINE 111
-#define CSS_PROP_TEXT_OVERLINE_COLOR 112
-#define CSS_PROP_TEXT_OVERLINE_MODE 113
-#define CSS_PROP_TEXT_OVERLINE_STYLE 114
-#define CSS_PROP_TEXT_OVERLINE_WIDTH 115
-#define CSS_PROP_TEXT_SHADOW 116
-#define CSS_PROP_TEXT_TRANSFORM 117
-#define CSS_PROP_TEXT_UNDERLINE 118
-#define CSS_PROP_TEXT_UNDERLINE_COLOR 119
-#define CSS_PROP_TEXT_UNDERLINE_MODE 120
-#define CSS_PROP_TEXT_UNDERLINE_STYLE 121
-#define CSS_PROP_TEXT_UNDERLINE_WIDTH 122
-#define CSS_PROP__APPLE_TEXT_SIZE_ADJUST 123
-#define CSS_PROP__APPLE_DASHBOARD_REGION 124
-#define CSS_PROP_TOP 125
-#define CSS_PROP_UNICODE_BIDI 126
-#define CSS_PROP__KHTML_USER_DRAG 127
-#define CSS_PROP__KHTML_USER_MODIFY 128
-#define CSS_PROP__KHTML_USER_SELECT 129
-#define CSS_PROP_VERTICAL_ALIGN 130
-#define CSS_PROP_VISIBILITY 131
-#define CSS_PROP_WHITE_SPACE 132
-#define CSS_PROP_WIDOWS 133
-#define CSS_PROP_WIDTH 134
-#define CSS_PROP_WORD_WRAP 135
-#define CSS_PROP_WORD_SPACING 136
-#define CSS_PROP_Z_INDEX 137
-#define CSS_PROP_BACKGROUND 138
-#define CSS_PROP_BORDER 139
-#define CSS_PROP_BORDER_COLOR 140
-#define CSS_PROP_BORDER_STYLE 141
-#define CSS_PROP_BORDER_TOP 142
-#define CSS_PROP_BORDER_RIGHT 143
-#define CSS_PROP_BORDER_BOTTOM 144
-#define CSS_PROP_BORDER_LEFT 145
-#define CSS_PROP_BORDER_WIDTH 146
-#define CSS_PROP_FONT 147
-#define CSS_PROP_LIST_STYLE 148
-#define CSS_PROP_MARGIN 149
-#define CSS_PROP_OUTLINE 150
-#define CSS_PROP_PADDING 151
-#define CSS_PROP_SCROLLBAR_FACE_COLOR 152
-#define CSS_PROP_SCROLLBAR_SHADOW_COLOR 153
-#define CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR 154
-#define CSS_PROP_SCROLLBAR_3DLIGHT_COLOR 155
-#define CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR 156
-#define CSS_PROP_SCROLLBAR_TRACK_COLOR 157
-#define CSS_PROP_SCROLLBAR_ARROW_COLOR 158
-#define CSS_PROP__KHTML_FLOW_MODE 159
+#define CSS_PROP_FONT_STRETCH 48
+#define CSS_PROP_FONT_STYLE 49
+#define CSS_PROP_FONT_VARIANT 50
+#define CSS_PROP_FONT_WEIGHT 51
+#define CSS_PROP_HEIGHT 52
+#define CSS_PROP_LEFT 53
+#define CSS_PROP_LETTER_SPACING 54
+#define CSS_PROP__APPLE_LINE_CLAMP 55
+#define CSS_PROP_LINE_HEIGHT 56
+#define CSS_PROP_LIST_STYLE_IMAGE 57
+#define CSS_PROP_LIST_STYLE_POSITION 58
+#define CSS_PROP_LIST_STYLE_TYPE 59
+#define CSS_PROP_MARGIN_TOP 60
+#define CSS_PROP_MARGIN_RIGHT 61
+#define CSS_PROP_MARGIN_BOTTOM 62
+#define CSS_PROP_MARGIN_LEFT 63
+#define CSS_PROP__KHTML_LINE_BREAK 64
+#define CSS_PROP__KHTML_MARGIN_COLLAPSE 65
+#define CSS_PROP__KHTML_MARGIN_TOP_COLLAPSE 66
+#define CSS_PROP__KHTML_MARGIN_BOTTOM_COLLAPSE 67
+#define CSS_PROP__KHTML_MARGIN_START 68
+#define CSS_PROP__KHTML_MARQUEE 69
+#define CSS_PROP__KHTML_MARQUEE_DIRECTION 70
+#define CSS_PROP__KHTML_MARQUEE_INCREMENT 71
+#define CSS_PROP__KHTML_MARQUEE_REPETITION 72
+#define CSS_PROP__KHTML_MARQUEE_SPEED 73
+#define CSS_PROP__KHTML_MARQUEE_STYLE 74
+#define CSS_PROP_MAX_HEIGHT 75
+#define CSS_PROP_MAX_WIDTH 76
+#define CSS_PROP_MIN_HEIGHT 77
+#define CSS_PROP_MIN_WIDTH 78
+#define CSS_PROP__KHTML_NBSP_MODE 79
+#define CSS_PROP_OPACITY 80
+#define CSS_PROP_ORPHANS 81
+#define CSS_PROP_OUTLINE_COLOR 82
+#define CSS_PROP_OUTLINE_OFFSET 83
+#define CSS_PROP_OUTLINE_STYLE 84
+#define CSS_PROP_OUTLINE_WIDTH 85
+#define CSS_PROP_OVERFLOW 86
+#define CSS_PROP_PADDING_TOP 87
+#define CSS_PROP_PADDING_RIGHT 88
+#define CSS_PROP_PADDING_BOTTOM 89
+#define CSS_PROP_PADDING_LEFT 90
+#define CSS_PROP__KHTML_PADDING_START 91
+#define CSS_PROP_PAGE 92
+#define CSS_PROP_PAGE_BREAK_AFTER 93
+#define CSS_PROP_PAGE_BREAK_BEFORE 94
+#define CSS_PROP_PAGE_BREAK_INSIDE 95
+#define CSS_PROP_POSITION 96
+#define CSS_PROP_QUOTES 97
+#define CSS_PROP_RIGHT 98
+#define CSS_PROP_SIZE 99
+#define CSS_PROP_TABLE_LAYOUT 100
+#define CSS_PROP_TEXT_ALIGN 101
+#define CSS_PROP_TEXT_DECORATION 102
+#define CSS_PROP_TEXT_INDENT 103
+#define CSS_PROP_TEXT_LINE_THROUGH 104
+#define CSS_PROP_TEXT_LINE_THROUGH_COLOR 105
+#define CSS_PROP_TEXT_LINE_THROUGH_MODE 106
+#define CSS_PROP_TEXT_LINE_THROUGH_STYLE 107
+#define CSS_PROP_TEXT_LINE_THROUGH_WIDTH 108
+#define CSS_PROP_TEXT_OVERFLOW 109
+#define CSS_PROP_TEXT_OVERLINE 110
+#define CSS_PROP_TEXT_OVERLINE_COLOR 111
+#define CSS_PROP_TEXT_OVERLINE_MODE 112
+#define CSS_PROP_TEXT_OVERLINE_STYLE 113
+#define CSS_PROP_TEXT_OVERLINE_WIDTH 114
+#define CSS_PROP_TEXT_SHADOW 115
+#define CSS_PROP_TEXT_TRANSFORM 116
+#define CSS_PROP_TEXT_UNDERLINE 117
+#define CSS_PROP_TEXT_UNDERLINE_COLOR 118
+#define CSS_PROP_TEXT_UNDERLINE_MODE 119
+#define CSS_PROP_TEXT_UNDERLINE_STYLE 120
+#define CSS_PROP_TEXT_UNDERLINE_WIDTH 121
+#define CSS_PROP__APPLE_TEXT_SIZE_ADJUST 122
+#define CSS_PROP__APPLE_DASHBOARD_REGION 123
+#define CSS_PROP_TOP 124
+#define CSS_PROP_UNICODE_BIDI 125
+#define CSS_PROP__KHTML_USER_DRAG 126
+#define CSS_PROP__KHTML_USER_MODIFY 127
+#define CSS_PROP__KHTML_USER_SELECT 128
+#define CSS_PROP_VERTICAL_ALIGN 129
+#define CSS_PROP_VISIBILITY 130
+#define CSS_PROP_WHITE_SPACE 131
+#define CSS_PROP_WIDOWS 132
+#define CSS_PROP_WIDTH 133
+#define CSS_PROP_WORD_WRAP 134
+#define CSS_PROP_WORD_SPACING 135
+#define CSS_PROP_Z_INDEX 136
+#define CSS_PROP_BACKGROUND 137
+#define CSS_PROP_BORDER 138
+#define CSS_PROP_BORDER_COLOR 139
+#define CSS_PROP_BORDER_STYLE 140
+#define CSS_PROP_BORDER_TOP 141
+#define CSS_PROP_BORDER_RIGHT 142
+#define CSS_PROP_BORDER_BOTTOM 143
+#define CSS_PROP_BORDER_LEFT 144
+#define CSS_PROP_BORDER_WIDTH 145
+#define CSS_PROP_FONT 146
+#define CSS_PROP_LIST_STYLE 147
+#define CSS_PROP_MARGIN 148
+#define CSS_PROP_OUTLINE 149
+#define CSS_PROP_PADDING 150
+#define CSS_PROP_SCROLLBAR_FACE_COLOR 151
+#define CSS_PROP_SCROLLBAR_SHADOW_COLOR 152
+#define CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR 153
+#define CSS_PROP_SCROLLBAR_3DLIGHT_COLOR 154
+#define CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR 155
+#define CSS_PROP_SCROLLBAR_TRACK_COLOR 156
+#define CSS_PROP_SCROLLBAR_ARROW_COLOR 157
 
 #define CSS_PROP_MAX CSS_PROP_Z_INDEX
 
 #define CSS_PROP_MAX CSS_PROP_Z_INDEX
-#define CSS_PROP_TOTAL 160
+#define CSS_PROP_TOTAL 158
 #endif
 
 #endif
 
index 94499614ac991fd5da2e87f22c49ab017b7edbf3..9cc154d6b0af76c1e42ab6fe9ee7292d9d0a3b29 100644 (file)
@@ -59,7 +59,6 @@ empty-cells
 float
 font-family
 font-size
 float
 font-family
 font-size
-font-size-adjust
 font-stretch
 font-style
 font-variant
 font-stretch
 font-style
 font-variant
@@ -170,4 +169,3 @@ scrollbar-3dlight-color
 scrollbar-darkshadow-color
 scrollbar-track-color
 scrollbar-arrow-color
 scrollbar-darkshadow-color
 scrollbar-track-color
 scrollbar-arrow-color
--khtml-flow-mode
index 173f7ad554efe8c3d04d3364dd7d0ea5558e5f19..796bbac9c59663c3ff55df9ca01d63911c387950 100644 (file)
@@ -1718,41 +1718,38 @@ void CSSStyleSelector::applyDeclarations(bool applyFirst, bool isImportant,
     if (startIndex == -1) return;
     for (int i = startIndex; i <= endIndex; i++) {
         CSSMutableStyleDeclarationImpl* decl = m_matchedDecls[i];
     if (startIndex == -1) return;
     for (int i = startIndex; i <= endIndex; i++) {
         CSSMutableStyleDeclarationImpl* decl = m_matchedDecls[i];
-        QPtrList<CSSProperty>* props = decl->values();
-        if (props) {
-            QPtrListIterator<CSSProperty> propertyIt(*props);
-            CSSProperty* current;
-            for (propertyIt.toFirst(); (current = propertyIt.current()); ++propertyIt) {
-                // give special priority to font-xxx, color properties
-                if (isImportant == current->isImportant()) {
-                    bool first;
-                    switch(current->id())
-                    {
-                        case CSS_PROP_BACKGROUND:
-                        case CSS_PROP_BACKGROUND_IMAGE:
-                        case CSS_PROP_COLOR:
-                        case CSS_PROP_DIRECTION:
-                        case CSS_PROP_DISPLAY:
-                        case CSS_PROP_FONT:
-                        case CSS_PROP_FONT_SIZE:
-                        case CSS_PROP_FONT_STYLE:
-                        case CSS_PROP_FONT_FAMILY:
-                        case CSS_PROP_FONT_WEIGHT:
+        QValueListConstIterator<CSSProperty> end;
+        for (QValueListConstIterator<CSSProperty> it = decl->valuesIterator(); it != end; ++it) {
+            const CSSProperty& current = *it;
+            // give special priority to font-xxx, color properties
+            if (isImportant == current.isImportant()) {
+                bool first;
+                switch(current.id())
+                {
+                    case CSS_PROP_BACKGROUND:
+                    case CSS_PROP_BACKGROUND_IMAGE:
+                    case CSS_PROP_COLOR:
+                    case CSS_PROP_DIRECTION:
+                    case CSS_PROP_DISPLAY:
+                    case CSS_PROP_FONT:
+                    case CSS_PROP_FONT_SIZE:
+                    case CSS_PROP_FONT_STYLE:
+                    case CSS_PROP_FONT_FAMILY:
+                    case CSS_PROP_FONT_WEIGHT:
 #if APPLE_CHANGES
 #if APPLE_CHANGES
-                        case CSS_PROP__APPLE_TEXT_SIZE_ADJUST:
+                    case CSS_PROP__APPLE_TEXT_SIZE_ADJUST:
 #endif
 #endif
-                            // these have to be applied first, because other properties use the computed
-                            // values of these porperties.
-                            first = true;
-                            break;
-                        default:
-                            first = false;
-                            break;
-                    }
-                    
-                    if (first == applyFirst)
-                        applyProperty(current->id(), current->value());
+                        // these have to be applied first, because other properties use the computed
+                        // values of these porperties.
+                        first = true;
+                        break;
+                    default:
+                        first = false;
+                        break;
                 }
                 }
+                
+                if (first == applyFirst)
+                    applyProperty(current.id(), current.value());
             }
         }
     }
             }
         }
     }
index 14cff7ed8a370682719563f234a7f597368ed9d2..6ccc8711b20ce8cc93497e6678eae6464a09b976 100644 (file)
@@ -62,7 +62,7 @@ CSSStyleDeclaration::~CSSStyleDeclaration()
 DOMString CSSStyleDeclaration::cssText() const
 {
     if(!impl) return DOMString();
 DOMString CSSStyleDeclaration::cssText() const
 {
     if(!impl) return DOMString();
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText();
+    return impl->cssText();
 }
 
 static void throwException(int exceptioncode)
 }
 
 static void throwException(int exceptioncode)
@@ -77,15 +77,16 @@ void CSSStyleDeclaration::setCssText( const DOMString &value )
 {
     if(!impl) return;
     int exceptionCode = 0;
 {
     if(!impl) return;
     int exceptionCode = 0;
-    impl->setCssText(value);
+    impl->setCssText(value, exceptionCode);
     throwException(exceptionCode);
 }
 
 DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName )
 {
     if(!impl) return DOMString();
     throwException(exceptionCode);
 }
 
 DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName )
 {
     if(!impl) return DOMString();
-    CSSValue v(getPropertyCSSValue(propertyName));
-    return v.cssText();
+    int id = getPropertyID(propertyName.string().ascii(), propertyName.length());
+    if (!id) return DOMString();
+    return impl->getPropertyValue(id);
 }
 
 CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName )
 }
 
 CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName )
@@ -93,14 +94,17 @@ CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName
     if(!impl) return 0;
     int id = getPropertyID(propertyName.string().ascii(), propertyName.length());
     if (!id) return 0;
     if(!impl) return 0;
     int id = getPropertyID(propertyName.string().ascii(), propertyName.length());
     if (!id) return 0;
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyCSSValue(id);
+    return impl->getPropertyCSSValue(id);
 }
 
 DOMString CSSStyleDeclaration::removeProperty( const DOMString &property )
 {
     int id = getPropertyID(property.string().ascii(), property.length());
     if(!impl || !id) return DOMString();
 }
 
 DOMString CSSStyleDeclaration::removeProperty( const DOMString &property )
 {
     int id = getPropertyID(property.string().ascii(), property.length());
     if(!impl || !id) return DOMString();
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty( id );
+    int exceptionCode = 0;
+    DOMString result = impl->removeProperty( id, exceptionCode );
+    throwException(exceptionCode);
+    return result;
 }
 
 DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName )
 }
 
 DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName )
@@ -122,25 +126,27 @@ void CSSStyleDeclaration::setProperty( const DOMString &propName, const DOMStrin
     if (str.find("important", 0, false) != -1)
         important = true;
 
     if (str.find("important", 0, false) != -1)
         important = true;
 
-    static_cast<CSSStyleDeclarationImpl *>(impl)->setProperty( id, value, important );
+    int exceptionCode;
+    impl->setProperty( id, value, important, exceptionCode );
+    throwException(exceptionCode);
 }
 
 unsigned long CSSStyleDeclaration::length() const
 {
     if(!impl) return 0;
 }
 
 unsigned long CSSStyleDeclaration::length() const
 {
     if(!impl) return 0;
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->length();
+    return impl->length();
 }
 
 DOMString CSSStyleDeclaration::item( unsigned long index )
 {
     if(!impl) return DOMString();
 }
 
 DOMString CSSStyleDeclaration::item( unsigned long index )
 {
     if(!impl) return DOMString();
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->item( index );
+    return impl->item( index );
 }
 
 CSSRule CSSStyleDeclaration::parentRule() const
 {
     if(!impl) return 0;
 }
 
 CSSRule CSSStyleDeclaration::parentRule() const
 {
     if(!impl) return 0;
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule();
+    return impl->parentRule();
 }
 
 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
 }
 
 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
@@ -193,10 +199,9 @@ DOMString CSSValue::cssText() const
     return ((CSSValueImpl *)impl)->cssText();
 }
 
     return ((CSSValueImpl *)impl)->cssText();
 }
 
-void CSSValue::setCssText( const DOMString &/*value*/ )
+void CSSValue::setCssText(const DOMString &)
 {
 {
-    if(!impl) return;
-    ((CSSValueImpl *)impl)->cssText();
+    // ### not implemented
 }
 
 unsigned short CSSValue::cssValueType() const
 }
 
 unsigned short CSSValue::cssValueType() const
index 6784da9d9c55fb3d25903f71840fd12f7947beab..9e4d34f785f3e966cef4fbcbb14b800f2635971c 100644 (file)
@@ -410,16 +410,6 @@ QRect Node::getRect()
     return impl->getRect();
 }
 
     return impl->getRect();
 }
 
-bool Node::isNull() const
-{
-    return (impl == 0);
-}
-
-NodeImpl *Node::handle() const
-{
-    return impl;
-}
-
 bool Node::isContentEditable() const
 {
     if (!impl) return false;
 bool Node::isContentEditable() const
 {
     if (!impl) return false;
index f42b88c2484d2454cc358ee60f13ba4301a19534..34dffed55ba85f63e48ab9be0ff24f2a752eed0d 100644 (file)
@@ -855,12 +855,12 @@ public:
      *   kdDebug(300) << "node isn't an element node" << endl;
      * </pre>
      */
      *   kdDebug(300) << "node isn't an element node" << endl;
      * </pre>
      */
-    bool isNull() const;
+    bool isNull() const { return impl == 0; }
 
     /**
      * @internal handle to the implementation object
      */
 
     /**
      * @internal handle to the implementation object
      */
-    NodeImpl *handle() const;
+    NodeImpl *handle() const { return impl; }
 
     /**
      * @internal returns the index of a node
 
     /**
      * @internal returns the index of a node
index 1b253b72305c29a9e3e4c79903c0819864accbcd..52ca14f1809c489e0185bf05f4ff5584b15d264b 100644 (file)
@@ -1,7 +1,7 @@
 // -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
 // -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 2003 Apple Computer, Inc.
+ *  Copyright (C) 2004 Apple Computer, Inc.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -19,6 +19,7 @@
  */
 
 #include "xmlhttprequest.h"
  */
 
 #include "xmlhttprequest.h"
+
 #include "xmlhttprequest.lut.h"
 #include "kjs_window.h"
 #include "kjs_events.h"
 #include "xmlhttprequest.lut.h"
 #include "kjs_window.h"
 #include "kjs_events.h"
@@ -505,8 +506,9 @@ void XMLHttpRequest::slotFinished(KIO::Job *)
     response += decoder->flush();
   }
 
     response += decoder->flush();
   }
 
-  changeState(Completed);
   job = 0;
   job = 0;
+
+  changeState(Completed);
   
   if (decoder) {
     decoder->deref();
   
   if (decoder) {
     decoder->deref();
@@ -668,4 +670,4 @@ Value XMLHttpRequestProtoFunc::tryCall(ExecState *exec, Object &thisObj, const L
   return Undefined();
 }
 
   return Undefined();
 }
 
-}; // end namespace
+} // end namespace
index 8a9d21e835e8465094557bd37add115ade2e8c48..db603c2d269324cacdf13f421632e5e4a65f3908 100644 (file)
@@ -55,6 +55,7 @@
 
 using DOM::AttrImpl;
 using DOM::CSSComputedStyleDeclarationImpl;
 
 using DOM::AttrImpl;
 using DOM::CSSComputedStyleDeclarationImpl;
+using DOM::CSSMutableStyleDeclarationImpl;
 using DOM::CSSPrimitiveValue;
 using DOM::CSSPrimitiveValueImpl;
 using DOM::CSSProperty;
 using DOM::CSSPrimitiveValue;
 using DOM::CSSPrimitiveValueImpl;
 using DOM::CSSProperty;
@@ -292,13 +293,13 @@ void EditCommandPtr::setEndingSelection(const Selection &s) const
     get()->setEndingSelection(s);
 }
 
     get()->setEndingSelection(s);
 }
 
-CSSStyleDeclarationImpl *EditCommandPtr::typingStyle() const
+CSSMutableStyleDeclarationImpl *EditCommandPtr::typingStyle() const
 {
     IF_IMPL_NULL_RETURN_ARG(0);
     return get()->typingStyle();
 }
 
 {
     IF_IMPL_NULL_RETURN_ARG(0);
     return get()->typingStyle();
 }
 
-void EditCommandPtr::setTypingStyle(CSSStyleDeclarationImpl *style) const
+void EditCommandPtr::setTypingStyle(CSSMutableStyleDeclarationImpl *style) const
 {
     IF_IMPL_NULL_RETURN;
     get()->setTypingStyle(style);
 {
     IF_IMPL_NULL_RETURN;
     get()->setTypingStyle(style);
@@ -339,10 +340,16 @@ StyleChange::StyleChange(CSSStyleDeclarationImpl *style, const Position &positio
 
 void StyleChange::init(CSSStyleDeclarationImpl *style, const Position &position)
 {
 
 void StyleChange::init(CSSStyleDeclarationImpl *style, const Position &position)
 {
-    QString styleText;
+    style->ref();
+    CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
+    mutableStyle->ref();
+    style->deref();
+    
+    QString styleText("");
 
 
-    for (QPtrListIterator<CSSProperty> it(*(style->values())); it.current(); ++it) {
-        CSSProperty *property = it.current();
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = mutableStyle->valuesIterator(); it != end; ++it) {
+        const CSSProperty *property = &*it;
 
         // If position is empty or the position passed in already has the 
         // style, just move on.
 
         // If position is empty or the position passed in already has the 
         // style, just move on.
@@ -356,6 +363,8 @@ void StyleChange::init(CSSStyleDeclarationImpl *style, const Position &position)
         styleText += property->cssText().string();
     }
 
         styleText += property->cssText().string();
     }
 
+    mutableStyle->deref();
+
     m_cssStyle = styleText.stripWhiteSpace();
 }
 
     m_cssStyle = styleText.stripWhiteSpace();
 }
 
@@ -513,12 +522,12 @@ void EditCommand::setEndingSelection(const Selection &s)
         cmd->m_endingSelection = s;
 }
 
         cmd->m_endingSelection = s;
 }
 
-void EditCommand::assignTypingStyle(CSSStyleDeclarationImpl *style)
+void EditCommand::assignTypingStyle(CSSMutableStyleDeclarationImpl *style)
 {
     if (m_typingStyle == style)
         return;
         
 {
     if (m_typingStyle == style)
         return;
         
-    CSSStyleDeclarationImpl *old = m_typingStyle;
+    CSSMutableStyleDeclarationImpl *old = m_typingStyle;
     m_typingStyle = style;
     if (m_typingStyle)
         m_typingStyle->ref();
     m_typingStyle = style;
     if (m_typingStyle)
         m_typingStyle->ref();
@@ -526,7 +535,7 @@ void EditCommand::assignTypingStyle(CSSStyleDeclarationImpl *style)
         old->deref();
 }
 
         old->deref();
 }
 
-void EditCommand::setTypingStyle(CSSStyleDeclarationImpl *style)
+void EditCommand::setTypingStyle(CSSMutableStyleDeclarationImpl *style)
 {
     // FIXME: Improve typing style.
     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
 {
     // FIXME: Improve typing style.
     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
@@ -978,7 +987,7 @@ void AppendNodeCommand::doUnapply()
 // ApplyStyleCommand
 
 ApplyStyleCommand::ApplyStyleCommand(DocumentImpl *document, CSSStyleDeclarationImpl *style)
 // ApplyStyleCommand
 
 ApplyStyleCommand::ApplyStyleCommand(DocumentImpl *document, CSSStyleDeclarationImpl *style)
-    : CompositeEditCommand(document), m_style(style)
+    : CompositeEditCommand(document), m_style(style->makeMutable())
 {   
     ASSERT(m_style);
     m_style->ref();
 {   
     ASSERT(m_style);
     m_style->ref();
@@ -992,12 +1001,12 @@ ApplyStyleCommand::~ApplyStyleCommand()
 
 void ApplyStyleCommand::doApply()
 {
 
 void ApplyStyleCommand::doApply()
 {
-    CSSStyleDeclarationImpl *blockStyle = m_style->copyBlockProperties();
+    CSSMutableStyleDeclarationImpl *blockStyle = m_style->copyBlockProperties();
     blockStyle->ref();
     applyBlockStyle(blockStyle);
 
     if (blockStyle->length() < m_style->length()) {
     blockStyle->ref();
     applyBlockStyle(blockStyle);
 
     if (blockStyle->length() < m_style->length()) {
-        CSSStyleDeclarationImpl *inlineStyle = new CSSStyleDeclarationImpl(0, m_style->values());
+        CSSMutableStyleDeclarationImpl *inlineStyle = m_style->copy();
         inlineStyle->ref();
         blockStyle->diff(inlineStyle);
         applyInlineStyle(inlineStyle);
         inlineStyle->ref();
         blockStyle->diff(inlineStyle);
         applyInlineStyle(inlineStyle);
@@ -1009,7 +1018,7 @@ void ApplyStyleCommand::doApply()
     setEndingSelectionNeedsLayout();
 }
 
     setEndingSelectionNeedsLayout();
 }
 
-void ApplyStyleCommand::applyBlockStyle(CSSStyleDeclarationImpl *style)
+void ApplyStyleCommand::applyBlockStyle(CSSMutableStyleDeclarationImpl *style)
 {
     // update document layout once before removing styles
     // so that we avoid the expense of updating before each and every call
 {
     // update document layout once before removing styles
     // so that we avoid the expense of updating before each and every call
@@ -1042,7 +1051,7 @@ void ApplyStyleCommand::applyBlockStyle(CSSStyleDeclarationImpl *style)
     }
 }
 
     }
 }
 
-void ApplyStyleCommand::applyInlineStyle(CSSStyleDeclarationImpl *style)
+void ApplyStyleCommand::applyInlineStyle(CSSMutableStyleDeclarationImpl *style)
 {
     // adjust to the positions we want to use for applying style
     Position start(endingSelection().start().downstream(StayInBlock).equivalentRangeCompliantPosition());
 {
     // adjust to the positions we want to use for applying style
     Position start(endingSelection().start().downstream(StayInBlock).equivalentRangeCompliantPosition());
@@ -1107,11 +1116,11 @@ void ApplyStyleCommand::applyInlineStyle(CSSStyleDeclarationImpl *style)
 //------------------------------------------------------------------------------------------
 // ApplyStyleCommand: style-removal helpers
 
 //------------------------------------------------------------------------------------------
 // ApplyStyleCommand: style-removal helpers
 
-bool ApplyStyleCommand::isHTMLStyleNode(CSSStyleDeclarationImpl *style, HTMLElementImpl *elem)
+bool ApplyStyleCommand::isHTMLStyleNode(CSSMutableStyleDeclarationImpl *style, HTMLElementImpl *elem)
 {
 {
-    for (QPtrListIterator<CSSProperty> it(*(style->values())); it.current(); ++it) {
-        CSSProperty *property = it.current();
-        switch (property->id()) {
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = style->valuesIterator(); it != end; ++it) {
+        switch ((*it).id()) {
             case CSS_PROP_FONT_WEIGHT:
                 if (elem->id() == ID_B)
                     return true;
             case CSS_PROP_FONT_WEIGHT:
                 if (elem->id() == ID_B)
                     return true;
@@ -1136,21 +1145,22 @@ void ApplyStyleCommand::removeHTMLStyleNode(HTMLElementImpl *elem)
     removeNodePreservingChildren(elem);
 }
 
     removeNodePreservingChildren(elem);
 }
 
-void ApplyStyleCommand::removeCSSStyle(CSSStyleDeclarationImpl *style, HTMLElementImpl *elem)
+void ApplyStyleCommand::removeCSSStyle(CSSMutableStyleDeclarationImpl *style, HTMLElementImpl *elem)
 {
     ASSERT(style);
     ASSERT(elem);
 
 {
     ASSERT(style);
     ASSERT(elem);
 
-    CSSStyleDeclarationImpl *decl = elem->inlineStyleDecl();
+    CSSMutableStyleDeclarationImpl *decl = elem->inlineStyleDecl();
     if (!decl)
         return;
 
     if (!decl)
         return;
 
-    for (QPtrListIterator<CSSProperty> it(*(style->values())); it.current(); ++it) {
-        CSSProperty *property = it.current();
-        CSSValueImpl *value = decl->getPropertyCSSValue(property->id());
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = style->valuesIterator(); it != end; ++it) {
+        int propertyID = (*it).id();
+        CSSValueImpl *value = decl->getPropertyCSSValue(propertyID);
         if (value) {
             value->ref();
         if (value) {
             value->ref();
-            removeCSSProperty(decl, property->id());
+            removeCSSProperty(decl, propertyID);
             value->deref();
         }
     }
             value->deref();
         }
     }
@@ -1159,7 +1169,7 @@ void ApplyStyleCommand::removeCSSStyle(CSSStyleDeclarationImpl *style, HTMLEleme
         // Check to see if the span is one we added to apply style.
         // If it is, and there are no more attributes on the span other than our
         // class marker, remove the span.
         // Check to see if the span is one we added to apply style.
         // If it is, and there are no more attributes on the span other than our
         // class marker, remove the span.
-        if (decl->values()->count() == 0) {
+        if (decl->length() == 0) {
             removeNodeAttribute(elem, ATTR_STYLE);
             NamedAttrMapImpl *map = elem->attributes();
             if (map && map->length() == 1 && elem->getAttribute(ATTR_CLASS) == styleSpanClassString())
             removeNodeAttribute(elem, ATTR_STYLE);
             NamedAttrMapImpl *map = elem->attributes();
             if (map && map->length() == 1 && elem->getAttribute(ATTR_CLASS) == styleSpanClassString())
@@ -1168,7 +1178,7 @@ void ApplyStyleCommand::removeCSSStyle(CSSStyleDeclarationImpl *style, HTMLEleme
     }
 }
 
     }
 }
 
-void ApplyStyleCommand::removeBlockStyle(CSSStyleDeclarationImpl *style, const Position &start, const Position &end)
+void ApplyStyleCommand::removeBlockStyle(CSSMutableStyleDeclarationImpl *style, const Position &start, const Position &end)
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
@@ -1178,7 +1188,7 @@ void ApplyStyleCommand::removeBlockStyle(CSSStyleDeclarationImpl *style, const P
     
 }
 
     
 }
 
-void ApplyStyleCommand::removeInlineStyle(CSSStyleDeclarationImpl *style, const Position &start, const Position &end)
+void ApplyStyleCommand::removeInlineStyle(CSSMutableStyleDeclarationImpl *style, const Position &start, const Position &end)
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
@@ -1262,21 +1272,21 @@ void ApplyStyleCommand::surroundNodeRangeWithElement(NodeImpl *startNode, NodeIm
     }
 }
 
     }
 }
 
-void ApplyStyleCommand::addBlockStyleIfNeeded(CSSStyleDeclarationImpl *style, HTMLElementImpl *block)
+void ApplyStyleCommand::addBlockStyleIfNeeded(CSSMutableStyleDeclarationImpl *style, HTMLElementImpl *block)
 {
     // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
     // inline content.
     StyleChange styleChange(style, Position(block, 0), StyleChange::DoNotUseLegacyHTMLStyles);
     if (styleChange.cssStyle().length() > 0) {
         DOMString cssText = styleChange.cssStyle();
 {
     // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
     // inline content.
     StyleChange styleChange(style, Position(block, 0), StyleChange::DoNotUseLegacyHTMLStyles);
     if (styleChange.cssStyle().length() > 0) {
         DOMString cssText = styleChange.cssStyle();
-        CSSStyleDeclarationImpl *decl = block->inlineStyleDecl();
+        CSSMutableStyleDeclarationImpl *decl = block->inlineStyleDecl();
         if (decl)
             cssText += decl->cssText();
         block->setAttribute(ATTR_STYLE, cssText);
     }
 }
 
         if (decl)
             cssText += decl->cssText();
         block->setAttribute(ATTR_STYLE, cssText);
     }
 }
 
-void ApplyStyleCommand::addInlineStyleIfNeeded(CSSStyleDeclarationImpl *style, NodeImpl *startNode, NodeImpl *endNode)
+void ApplyStyleCommand::addInlineStyleIfNeeded(CSSMutableStyleDeclarationImpl *style, NodeImpl *startNode, NodeImpl *endNode)
 {
     // FIXME: This function should share code with CompositeEditCommand::applyTypingStyle.
     // Both functions do similar work, and the common parts could be factored out.
 {
     // FIXME: This function should share code with CompositeEditCommand::applyTypingStyle.
     // Both functions do similar work, and the common parts could be factored out.
@@ -1979,7 +1989,7 @@ void InsertLineBreakCommand::doApply()
     // Handle the case where there is a typing style.
     // FIXME: Improve typing style.
     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
     // Handle the case where there is a typing style.
     // FIXME: Improve typing style.
     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
-    CSSStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
+    CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
     if (typingStyle && typingStyle->length() > 0)
         nodeToInsert = applyTypingStyle(breakNode);
     
     if (typingStyle && typingStyle->length() > 0)
         nodeToInsert = applyTypingStyle(breakNode);
     
@@ -2413,7 +2423,7 @@ Position InsertTextCommand::prepareForTextInsertion(bool adjustDownstream)
         // Handle the case where there is a typing style.
         // FIXME: Improve typing style.
         // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
         // Handle the case where there is a typing style.
         // FIXME: Improve typing style.
         // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
-        CSSStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
+        CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
         if (typingStyle && typingStyle->length() > 0)
             nodeToInsert = applyTypingStyle(textNode);
         
         if (typingStyle && typingStyle->length() > 0)
             nodeToInsert = applyTypingStyle(textNode);
         
@@ -2439,7 +2449,7 @@ Position InsertTextCommand::prepareForTextInsertion(bool adjustDownstream)
         // Handle the case where there is a typing style.
         // FIXME: Improve typing style.
         // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
         // Handle the case where there is a typing style.
         // FIXME: Improve typing style.
         // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
-        CSSStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
+        CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
         if (typingStyle && typingStyle->length() > 0) {
             if (pos.node()->isTextNode() && pos.offset() > pos.node()->caretMinOffset() && pos.offset() < pos.node()->caretMaxOffset()) {
                 // Need to split current text node in order to insert a span.
         if (typingStyle && typingStyle->length() > 0) {
             if (pos.node()->isTextNode() && pos.offset() > pos.node()->caretMinOffset() && pos.offset() < pos.node()->caretMaxOffset()) {
                 // Need to split current text node in order to insert a span.
@@ -2822,7 +2832,7 @@ void MoveSelectionCommand::doApply()
 // RemoveCSSPropertyCommand
 
 RemoveCSSPropertyCommand::RemoveCSSPropertyCommand(DocumentImpl *document, CSSStyleDeclarationImpl *decl, int property)
 // RemoveCSSPropertyCommand
 
 RemoveCSSPropertyCommand::RemoveCSSPropertyCommand(DocumentImpl *document, CSSStyleDeclarationImpl *decl, int property)
-    : EditCommand(document), m_decl(decl), m_property(property), m_important(false)
+    : EditCommand(document), m_decl(decl->makeMutable()), m_property(property), m_important(false)
 {
     ASSERT(m_decl);
     m_decl->ref();
 {
     ASSERT(m_decl);
     m_decl->ref();
index f2904e5c89415776eaa7bbb347b884cf525ad196..9ddda31ffa7059e7549bfc53e14f3108d8d5c54b 100644 (file)
@@ -33,6 +33,7 @@
 #include "shared.h"
 
 namespace DOM {
 #include "shared.h"
 
 namespace DOM {
+    class CSSMutableStyleDeclarationImpl;
     class CSSProperty;
     class DocumentFragmentImpl;
     class HTMLElementImpl;
     class CSSProperty;
     class DocumentFragmentImpl;
     class HTMLElementImpl;
@@ -72,8 +73,8 @@ public:
     void setStartingSelection(const khtml::Selection &s) const;
     void setEndingSelection(const khtml::Selection &s) const;
 
     void setStartingSelection(const khtml::Selection &s) const;
     void setEndingSelection(const khtml::Selection &s) const;
 
-    DOM::CSSStyleDeclarationImpl *typingStyle() const;
-    void setTypingStyle(DOM::CSSStyleDeclarationImpl *) const;
+    DOM::CSSMutableStyleDeclarationImpl *typingStyle() const;
+    void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *) const;
 
     EditCommandPtr parent() const;
     void setParent(const EditCommandPtr &) const;
 
     EditCommandPtr parent() const;
     void setParent(const EditCommandPtr &) const;
@@ -147,14 +148,14 @@ public:
     void setStartingSelection(const khtml::Selection &s);
     void setEndingSelection(const khtml::Selection &s);
 
     void setStartingSelection(const khtml::Selection &s);
     void setEndingSelection(const khtml::Selection &s);
 
-    DOM::CSSStyleDeclarationImpl *typingStyle() const { return m_typingStyle; };
-    void setTypingStyle(DOM::CSSStyleDeclarationImpl *);
+    DOM::CSSMutableStyleDeclarationImpl *typingStyle() const { return m_typingStyle; };
+    void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
     
     virtual bool isInsertTextCommand() const;
     virtual bool isTypingCommand() const;
 
 private:
     
     virtual bool isInsertTextCommand() const;
     virtual bool isTypingCommand() const;
 
 private:
-    void assignTypingStyle(DOM::CSSStyleDeclarationImpl *);
+    void assignTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 
     virtual bool preservesTypingStyle() const;
 
 
     virtual bool preservesTypingStyle() const;
 
@@ -162,7 +163,7 @@ private:
     ECommandState m_state;
     khtml::Selection m_startingSelection;
     khtml::Selection m_endingSelection;
     ECommandState m_state;
     khtml::Selection m_startingSelection;
     khtml::Selection m_endingSelection;
-    DOM::CSSStyleDeclarationImpl *m_typingStyle;
+    DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
     EditCommand *m_parent;
 };
 
     EditCommand *m_parent;
 };
 
@@ -247,28 +248,28 @@ public:
        
     virtual void doApply();
 
        
     virtual void doApply();
 
-    DOM::CSSStyleDeclarationImpl *style() const { return m_style; }
+    DOM::CSSMutableStyleDeclarationImpl *style() const { return m_style; }
 
 private:
     // style-removal helpers
 
 private:
     // style-removal helpers
-    bool isHTMLStyleNode(DOM::CSSStyleDeclarationImpl *, DOM::HTMLElementImpl *);
+    bool isHTMLStyleNode(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
     void removeHTMLStyleNode(DOM::HTMLElementImpl *);
     void removeHTMLStyleNode(DOM::HTMLElementImpl *);
-    void removeCSSStyle(DOM::CSSStyleDeclarationImpl *, DOM::HTMLElementImpl *);
-    void removeBlockStyle(DOM::CSSStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
-    void removeInlineStyle(DOM::CSSStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
+    void removeCSSStyle(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
+    void removeBlockStyle(DOM::CSSMutableStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
+    void removeInlineStyle(DOM::CSSMutableStyleDeclarationImpl *, const DOM::Position &start, const DOM::Position &end);
     bool nodeFullySelected(DOM::NodeImpl *, const DOM::Position &start, const DOM::Position &end) const;
 
     // style-application helpers
     bool nodeFullySelected(DOM::NodeImpl *, const DOM::Position &start, const DOM::Position &end) const;
 
     // style-application helpers
-    void applyBlockStyle(DOM::CSSStyleDeclarationImpl *);
-    void applyInlineStyle(DOM::CSSStyleDeclarationImpl *);
-    void addBlockStyleIfNeeded(DOM::CSSStyleDeclarationImpl *, DOM::HTMLElementImpl *);
-    void addInlineStyleIfNeeded(DOM::CSSStyleDeclarationImpl *, DOM::NodeImpl *start, DOM::NodeImpl *end);
+    void applyBlockStyle(DOM::CSSMutableStyleDeclarationImpl *);
+    void applyInlineStyle(DOM::CSSMutableStyleDeclarationImpl *);
+    void addBlockStyleIfNeeded(DOM::CSSMutableStyleDeclarationImpl *, DOM::HTMLElementImpl *);
+    void addInlineStyleIfNeeded(DOM::CSSMutableStyleDeclarationImpl *, DOM::NodeImpl *start, DOM::NodeImpl *end);
     bool splitTextAtStartIfNeeded(const DOM::Position &start, const DOM::Position &end);
     DOM::NodeImpl *splitTextAtEndIfNeeded(const DOM::Position &start, const DOM::Position &end);
     void surroundNodeRangeWithElement(DOM::NodeImpl *start, DOM::NodeImpl *end, DOM::ElementImpl *element);
     DOM::Position positionInsertionPoint(DOM::Position);
     
     bool splitTextAtStartIfNeeded(const DOM::Position &start, const DOM::Position &end);
     DOM::NodeImpl *splitTextAtEndIfNeeded(const DOM::Position &start, const DOM::Position &end);
     void surroundNodeRangeWithElement(DOM::NodeImpl *start, DOM::NodeImpl *end, DOM::ElementImpl *element);
     DOM::Position positionInsertionPoint(DOM::Position);
     
-    DOM::CSSStyleDeclarationImpl *m_style;
+    DOM::CSSMutableStyleDeclarationImpl *m_style;
 };
 
 //------------------------------------------------------------------------------------------
 };
 
 //------------------------------------------------------------------------------------------
@@ -336,7 +337,7 @@ private:
     DOM::NodeImpl *m_startBlock;
     DOM::NodeImpl *m_endBlock;
     DOM::NodeImpl *m_startNode;
     DOM::NodeImpl *m_startBlock;
     DOM::NodeImpl *m_endBlock;
     DOM::NodeImpl *m_startNode;
-    DOM::CSSStyleDeclarationImpl *m_typingStyle;
+    DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
 };
 
 //------------------------------------------------------------------------------------------
 };
 
 //------------------------------------------------------------------------------------------
@@ -522,11 +523,11 @@ public:
     virtual void doApply();
     virtual void doUnapply();
 
     virtual void doApply();
     virtual void doUnapply();
 
-    DOM::CSSStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
+    DOM::CSSMutableStyleDeclarationImpl *styleDeclaration() const { return m_decl; }
     int property() const { return m_property; }
     
 private:
     int property() const { return m_property; }
     
 private:
-    DOM::CSSStyleDeclarationImpl *m_decl;
+    DOM::CSSMutableStyleDeclarationImpl *m_decl;
     int m_property;
     DOM::DOMString m_oldValue;
     bool m_important;
     int m_property;
     DOM::DOMString m_oldValue;
     bool m_important;
index 07fde0544002b8902fcad1cc2367f9195058be33..eb03cdfad993822740941a964474d7ba05369b4c 100644 (file)
@@ -133,7 +133,7 @@ namespace {
 
 bool execStyleChange(KHTMLPart *part, int propertyID, const DOMString &propertyValue)
 {
 
 bool execStyleChange(KHTMLPart *part, int propertyID, const DOMString &propertyValue)
 {
-    CSSStyleDeclarationImpl *style = new CSSStyleDeclarationImpl(0);
+    CSSMutableStyleDeclarationImpl *style = new CSSMutableStyleDeclarationImpl;
     style->setProperty(propertyID, propertyValue);
     style->ref();
     part->applyStyle(style);
     style->setProperty(propertyID, propertyValue);
     style->ref();
     part->applyStyle(style);
@@ -148,7 +148,7 @@ bool execStyleChange(KHTMLPart *part, int propertyID, const char *propertyValue)
 
 KHTMLPart::TriState stateStyle(KHTMLPart *part, int propertyID, const char *desiredValue)
 {
 
 KHTMLPart::TriState stateStyle(KHTMLPart *part, int propertyID, const char *desiredValue)
 {
-    CSSStyleDeclarationImpl *style = new CSSStyleDeclarationImpl(0);
+    CSSMutableStyleDeclarationImpl *style = new CSSMutableStyleDeclarationImpl;
     style->setProperty(propertyID, desiredValue);
     style->ref();
     KHTMLPart::TriState state = part->selectionHasStyle(style);
     style->setProperty(propertyID, desiredValue);
     style->ref();
     KHTMLPart::TriState state = part->selectionHasStyle(style);
@@ -158,7 +158,7 @@ KHTMLPart::TriState stateStyle(KHTMLPart *part, int propertyID, const char *desi
 
 bool selectionStartHasStyle(KHTMLPart *part, int propertyID, const char *desiredValue)
 {
 
 bool selectionStartHasStyle(KHTMLPart *part, int propertyID, const char *desiredValue)
 {
-    CSSStyleDeclarationImpl *style = new CSSStyleDeclarationImpl(0);
+    CSSMutableStyleDeclarationImpl *style = new CSSMutableStyleDeclarationImpl;
     style->setProperty(propertyID, desiredValue);
     style->ref();
     bool hasStyle = part->selectionStartHasStyle(style);
     style->setProperty(propertyID, desiredValue);
     style->ref();
     bool hasStyle = part->selectionStartHasStyle(style);
index e55edd41b3bd4cfecc7915048262e58f15632c99..0c06599548961eb621f7622677433d4d661c1a72 100644 (file)
@@ -68,7 +68,7 @@ NodeImpl::Id HTMLBodyElementImpl::id() const
 
 void HTMLBodyElementImpl::createLinkDecl()
 {
 
 void HTMLBodyElementImpl::createLinkDecl()
 {
-    m_linkDecl = new CSSStyleDeclarationImpl(0);
+    m_linkDecl = new CSSMutableStyleDeclarationImpl;
     m_linkDecl->ref();
     m_linkDecl->setParent(getDocument()->elementSheet());
     m_linkDecl->setNode(this);
     m_linkDecl->ref();
     m_linkDecl->setParent(getDocument()->elementSheet());
     m_linkDecl->setNode(this);
index d06ee706e3b3e36eb44d7cdc9f3377aeda04d9e6..0f92937f7e2e430d7269be4488035e366fdc47ba 100644 (file)
@@ -67,7 +67,7 @@ public:
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
 protected:
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
 protected:
-    CSSStyleDeclarationImpl* m_linkDecl;
+    CSSMutableStyleDeclarationImpl* m_linkDecl;
 };
 
 // -------------------------------------------------------------------------
 };
 
 // -------------------------------------------------------------------------
index c75f5c20a55cc26472ffd0ca568653cb86372e73..1e7ccf996ed6a73ad0a92f86ddfeb8418d046ea6 100644 (file)
@@ -267,7 +267,7 @@ bool HTMLElementImpl::isInline() const
 
 void HTMLElementImpl::createInlineStyleDecl()
 {
 
 void HTMLElementImpl::createInlineStyleDecl()
 {
-    m_inlineStyleDecl = new CSSStyleDeclarationImpl(0);
+    m_inlineStyleDecl = new CSSMutableStyleDeclarationImpl;
     m_inlineStyleDecl->ref();
     m_inlineStyleDecl->setParent(getDocument()->elementSheet());
     m_inlineStyleDecl->setNode(this);
     m_inlineStyleDecl->ref();
     m_inlineStyleDecl->setParent(getDocument()->elementSheet());
     m_inlineStyleDecl->setNode(this);
@@ -386,7 +386,7 @@ void HTMLElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         // ### the inline sheet ay contain more than 1 property!
         // stylesheet info
         setHasStyle();
         // ### the inline sheet ay contain more than 1 property!
         // stylesheet info
         setHasStyle();
-        getInlineStyleDecl()->setProperty(attr->value());
+        getInlineStyleDecl()->parseProperty(attr->value());
         setChanged();
         break;
     case ATTR_TABINDEX:
         setChanged();
         break;
     case ATTR_TABINDEX:
@@ -526,14 +526,14 @@ void HTMLElementImpl::createAttributeMap() const
     namedAttrMap->ref();
 }
 
     namedAttrMap->ref();
 }
 
-CSSStyleDeclarationImpl* HTMLElementImpl::getInlineStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLElementImpl::getInlineStyleDecl()
 {
     if (!m_inlineStyleDecl)
         createInlineStyleDecl();
     return m_inlineStyleDecl;
 }
 
 {
     if (!m_inlineStyleDecl)
         createInlineStyleDecl();
     return m_inlineStyleDecl;
 }
 
-CSSStyleDeclarationImpl* HTMLElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLElementImpl::additionalAttributeStyleDecl()
 {
     return 0;
 }
 {
     return 0;
 }
@@ -766,7 +766,8 @@ DocumentFragmentImpl *HTMLElementImpl::createContextualFragment(const DOMString
     NodeImpl *nextNode;
     for (NodeImpl *node = fragment->firstChild(); node != NULL; node = nextNode) {
         nextNode = node->nextSibling();
     NodeImpl *nextNode;
     for (NodeImpl *node = fragment->firstChild(); node != NULL; node = nextNode) {
         nextNode = node->nextSibling();
-       if (node->id() == ID_HTML || node->id() == ID_BODY) {
+       node->ref();
+        if (node->id() == ID_HTML || node->id() == ID_BODY) {
            NodeImpl *firstChild = node->firstChild();
             if (firstChild != NULL) {
                 nextNode = firstChild;
            NodeImpl *firstChild = node->firstChild();
             if (firstChild != NULL) {
                 nextNode = firstChild;
@@ -780,11 +781,14 @@ DocumentFragmentImpl *HTMLElementImpl::createContextualFragment(const DOMString
                 child->deref();
            }
             fragment->removeChild(node, ignoredExceptionCode);
                 child->deref();
            }
             fragment->removeChild(node, ignoredExceptionCode);
-            // FIXME: Does node leak here?
        } else if (node->id() == ID_HEAD) {
            fragment->removeChild(node, ignoredExceptionCode);
        } else if (node->id() == ID_HEAD) {
            fragment->removeChild(node, ignoredExceptionCode);
-            // FIXME: Does node leak here?
        }
        }
+        // Important to do this deref after removeChild, because if the only thing
+        // keeping a node around is a parent that is non-0, removeChild will not
+        // delete the node. This works fine in JavaScript because there's always
+        // a ref of the node, but here in C++ we need to do it explicitly.
+        node->deref();
     }
 
     // Trick to get the fragment back to the floating state, with 0
     }
 
     // Trick to get the fragment back to the floating state, with 0
@@ -806,8 +810,6 @@ bool HTMLElementImpl::setInnerHTML( const DOMString &html )
     removeChildren();
     int ec = 0;
     appendChild( fragment, ec );
     removeChildren();
     int ec = 0;
     appendChild( fragment, ec );
-    fragment->ref();
-    fragment->deref();
     return !ec;
 }
 
     return !ec;
 }
 
@@ -820,8 +822,6 @@ bool HTMLElementImpl::setOuterHTML( const DOMString &html )
     
     int ec = 0;
     parentNode()->replaceChild(fragment, this, ec);
     
     int ec = 0;
     parentNode()->replaceChild(fragment, this, ec);
-    fragment->ref();
-    fragment->deref();
     return !ec;
 }
 
     return !ec;
 }
 
index 9607e149cd9e00b903265a6a160a4d495db13bed..cad95fecdd7da6e4cf7ea5f97539324713ed35de 100644 (file)
 namespace DOM {
 
 class DOMString;
 namespace DOM {
 
 class DOMString;
-class CSSStyleDeclarationImpl;
 class HTMLFormElementImpl;
 class DocumentFragmentImpl;
 
 enum MappedAttributeEntry { eNone, eUniversal, ePersistent, eReplaced, eBlock, eHR, eUnorderedList, eListItem,
     eTable, eCell, eCaption };
 
 class HTMLFormElementImpl;
 class DocumentFragmentImpl;
 
 enum MappedAttributeEntry { eNone, eUniversal, ePersistent, eReplaced, eBlock, eHR, eUnorderedList, eListItem,
     eTable, eCell, eCaption };
 
-class CSSMappedAttributeDeclarationImpl : public CSSStyleDeclarationImpl
+class CSSMappedAttributeDeclarationImpl : public CSSMutableStyleDeclarationImpl
 {
 public:
     CSSMappedAttributeDeclarationImpl(CSSRuleImpl *parentRule)
 {
 public:
     CSSMappedAttributeDeclarationImpl(CSSRuleImpl *parentRule)
-    : CSSStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
+    : CSSMutableStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
     {}
     
     virtual ~CSSMappedAttributeDeclarationImpl();
     {}
     
     virtual ~CSSMappedAttributeDeclarationImpl();
@@ -168,9 +167,9 @@ public:
 
     virtual void click();
     
 
     virtual void click();
     
-    CSSStyleDeclarationImpl* inlineStyleDecl() const { return m_inlineStyleDecl; }
-    virtual CSSStyleDeclarationImpl* additionalAttributeStyleDecl();
-    CSSStyleDeclarationImpl* getInlineStyleDecl();
+    CSSMutableStyleDeclarationImpl* inlineStyleDecl() const { return m_inlineStyleDecl; }
+    virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
+    CSSMutableStyleDeclarationImpl* getInlineStyleDecl();
     void createInlineStyleDecl();
      
     virtual AttributeImpl* createAttribute(NodeImpl::Id id, DOMStringImpl* value);
     void createInlineStyleDecl();
      
     virtual AttributeImpl* createAttribute(NodeImpl::Id id, DOMStringImpl* value);
@@ -190,7 +189,7 @@ protected:
     // for IMG, OBJECT and APPLET
     void addHTMLAlignment(HTMLAttributeImpl* htmlAttr);
 
     // for IMG, OBJECT and APPLET
     void addHTMLAlignment(HTMLAttributeImpl* htmlAttr);
 
-    CSSStyleDeclarationImpl* m_inlineStyleDecl;
+    CSSMutableStyleDeclarationImpl* m_inlineStyleDecl;
 };
 
 class HTMLGenericElementImpl : public HTMLElementImpl
 };
 
 class HTMLGenericElementImpl : public HTMLElementImpl
index af657693bd22dc368c8a558c81a8d507307639c0..e205366953fd5209f9bdf9c8a6857b23b82ff754 100644 (file)
@@ -544,7 +544,7 @@ void HTMLTableElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     }
 }
 
     }
 }
 
-CSSStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
 {
     if (m_noBorder)
         return 0;
 {
     if (m_noBorder)
         return 0;
@@ -572,7 +572,7 @@ CSSStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
     return decl;
 }
 
     return decl;
 }
 
-CSSStyleDeclarationImpl* HTMLTableElementImpl::getSharedCellDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::getSharedCellDecl()
 {
     HTMLAttributeImpl attr(ATTR_CELLBORDER, m_noBorder ? "none" : (m_solid ? "solid" : "inset"));
     CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(ePersistent, &attr);
 {
     HTMLAttributeImpl attr(ATTR_CELLBORDER, m_noBorder ? "none" : (m_solid ? "solid" : "inset"));
     CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(ePersistent, &attr);
@@ -972,7 +972,7 @@ void HTMLTableCellElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
 }
 
 // used by table cells to share style decls created by the enclosing table.
 }
 
 // used by table cells to share style decls created by the enclosing table.
-CSSStyleDeclarationImpl* HTMLTableCellElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableCellElementImpl::additionalAttributeStyleDecl()
 {
     HTMLElementImpl* p = static_cast<HTMLElementImpl*>(parentNode());
     while(p && p->id() != ID_TABLE)
 {
     HTMLElementImpl* p = static_cast<HTMLElementImpl*>(parentNode());
     while(p && p->id() != ID_TABLE)
index 19e1551dd02581ec5b29f17b7fa36fa4aca96dd5..221ee6a4168a9a681f9b34850ddc2975869fca2b 100644 (file)
@@ -102,8 +102,8 @@ public:
     virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
 
     // Used to obtain either a solid or outset border decl.
     virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
 
     // Used to obtain either a solid or outset border decl.
-    virtual CSSStyleDeclarationImpl* additionalAttributeStyleDecl();
-    CSSStyleDeclarationImpl* getSharedCellDecl();
+    virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
+    CSSMutableStyleDeclarationImpl* getSharedCellDecl();
 
     virtual void attach();
     
 
     virtual void attach();
     
@@ -212,7 +212,7 @@ public:
     virtual void attach();
 
     // used by table cells to share style decls created by the enclosing table.
     virtual void attach();
 
     // used by table cells to share style decls created by the enclosing table.
-    virtual CSSStyleDeclarationImpl* additionalAttributeStyleDecl();
+    virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
     
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
     
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
index f9046b0aa8b0c950e4e616da909f996aa8e185e2..9a1bea854261dad2f5c633e300648639fab546a4 100644 (file)
@@ -248,6 +248,8 @@ void KHTMLParser::parseToken(Token *t)
     if(!n)
         return;
 
     if(!n)
         return;
 
+    Node protectNode(n);
+
     // set attributes
     if(n->isElementNode())
     {
     // set attributes
     if(n->isElementNode())
     {
@@ -299,7 +301,6 @@ void KHTMLParser::parseToken(Token *t)
 #endif
             form = 0;
         }
 #endif
             form = 0;
         }
-        delete n;
     }
 }
 
     }
 }
 
@@ -311,6 +312,8 @@ static bool isTableRelatedTag(int id)
 
 bool KHTMLParser::insertNode(NodeImpl *n, bool flat)
 {
 
 bool KHTMLParser::insertNode(NodeImpl *n, bool flat)
 {
+    Node protectNode(n);
+
     int id = n->id();
 
     // let's be stupid and just try to insert it.
     int id = n->id();
 
     // let's be stupid and just try to insert it.
@@ -1655,7 +1658,6 @@ void KHTMLParser::createHead()
 #ifdef PARSER_DEBUG
         kdDebug( 6035 ) << "creation of head failed!!!!" << endl;
 #endif
 #ifdef PARSER_DEBUG
         kdDebug( 6035 ) << "creation of head failed!!!!" << endl;
 #endif
-        delete head;
         head = 0;
     }
 }
         head = 0;
     }
 }
index 13cfc825f0245519d85d440a0a010b9fbf39597f..5299b138762ad285f1f3a62f9b0d029875f34b7c 100644 (file)
@@ -5040,7 +5040,7 @@ CSSMutableStyleDeclarationImpl *KHTMLPart::typingStyle() const
     return d->m_typingStyle;
 }
 
     return d->m_typingStyle;
 }
 
-void KHTMLPart::setTypingStyle(CSSStyleDeclarationImpl *style)
+void KHTMLPart::setTypingStyle(CSSMutableStyleDeclarationImpl *style)
 {
     if (d->m_typingStyle == style)
         return;
 {
     if (d->m_typingStyle == style)
         return;
@@ -5330,18 +5330,21 @@ void KHTMLPart::applyStyle(CSSStyleDeclarationImpl *style)
             break;
         case Selection::CARET: {
             // Calculate the current typing style.
             break;
         case Selection::CARET: {
             // Calculate the current typing style.
+            CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
+            mutableStyle->ref();
             if (typingStyle()) {
             if (typingStyle()) {
-                typingStyle()->merge(style);
-                style = typingStyle();
+                typingStyle()->merge(mutableStyle);
+                mutableStyle->deref();
+                mutableStyle = typingStyle();
+                mutableStyle->ref();
             }
             }
-            style->ref();
             CSSComputedStyleDeclarationImpl computedStyle(selection().start().upstream(StayInBlock).node());
             CSSComputedStyleDeclarationImpl computedStyle(selection().start().upstream(StayInBlock).node());
-            computedStyle.diff(style);
+            computedStyle.diff(mutableStyle);
             
             // Handle block styles, substracting these from the typing style.
             
             // Handle block styles, substracting these from the typing style.
-            CSSStyleDeclarationImpl *blockStyle = style->copyBlockProperties();
+            CSSMutableStyleDeclarationImpl *blockStyle = mutableStyle->copyBlockProperties();
             blockStyle->ref();
             blockStyle->ref();
-            blockStyle->diff(style);
+            blockStyle->diff(mutableStyle);
             if (xmlDocImpl() && blockStyle->length() > 0) {
                 EditCommandPtr cmd(new ApplyStyleCommand(xmlDocImpl(), blockStyle));
                 cmd.apply();
             if (xmlDocImpl() && blockStyle->length() > 0) {
                 EditCommandPtr cmd(new ApplyStyleCommand(xmlDocImpl(), blockStyle));
                 cmd.apply();
@@ -5349,8 +5352,8 @@ void KHTMLPart::applyStyle(CSSStyleDeclarationImpl *style)
             blockStyle->deref();
             
             // Set the remaining style as the typing style.
             blockStyle->deref();
             
             // Set the remaining style as the typing style.
-            setTypingStyle(style);
-            style->deref();
+            setTypingStyle(mutableStyle);
+            mutableStyle->deref();
             break;
         }
         case Selection::RANGE:
             break;
         }
         case Selection::RANGE:
@@ -5364,8 +5367,9 @@ void KHTMLPart::applyStyle(CSSStyleDeclarationImpl *style)
 
 static void updateState(CSSMutableStyleDeclarationImpl *desiredStyle, CSSComputedStyleDeclarationImpl *computedStyle, bool &atStart, KHTMLPart::TriState &state)
 {
 
 static void updateState(CSSMutableStyleDeclarationImpl *desiredStyle, CSSComputedStyleDeclarationImpl *computedStyle, bool &atStart, KHTMLPart::TriState &state)
 {
-    for (QPtrListIterator<CSSProperty> it(*desiredStyle->values()); it.current(); ++it) {
-        int propertyID = it.current()->id();
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = desiredStyle->valuesIterator(); it != end; ++it) {
+        int propertyID = (*it).id();
         DOMString desiredProperty = desiredStyle->getPropertyValue(propertyID);
         DOMString computedProperty = computedStyle->getPropertyValue(propertyID);
         KHTMLPart::TriState propertyState = strcasecmp(desiredProperty, computedProperty) == 0
         DOMString desiredProperty = desiredStyle->getPropertyValue(propertyID);
         DOMString computedProperty = computedStyle->getPropertyValue(propertyID);
         KHTMLPart::TriState propertyState = strcasecmp(desiredProperty, computedProperty) == 0
@@ -5385,7 +5389,7 @@ KHTMLPart::TriState KHTMLPart::selectionHasStyle(CSSStyleDeclarationImpl *style)
     bool atStart = true;
     TriState state = falseTriState;
 
     bool atStart = true;
     TriState state = falseTriState;
 
-    CSSMutableStyleDeclarationImpl *mutableStyle = style;
+    CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
     CSSStyleDeclaration protectQueryStyle(mutableStyle);
 
     if (!d->m_selection.isRange()) {
     CSSStyleDeclaration protectQueryStyle(mutableStyle);
 
     if (!d->m_selection.isRange()) {
@@ -5426,15 +5430,16 @@ bool KHTMLPart::selectionStartHasStyle(CSSStyleDeclarationImpl *style) const
     if (!selectionStyle)
         return false;
 
     if (!selectionStyle)
         return false;
 
-    CSSMutableStyleDeclarationImpl *mutableStyle = style;
+    CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
 
     CSSStyleDeclaration protectSelectionStyle(selectionStyle);
     CSSStyleDeclaration protectQueryStyle(mutableStyle);
 
     bool match = true;
 
     CSSStyleDeclaration protectSelectionStyle(selectionStyle);
     CSSStyleDeclaration protectQueryStyle(mutableStyle);
 
     bool match = true;
-    for (QPtrListIterator<CSSProperty> it(*mutableStyle->values()); it.current(); ++it) {
-        int propertyID = it.current()->id();
-        DOMString desiredProperty = style->getPropertyValue(propertyID);
+    QValueListConstIterator<CSSProperty> end;
+    for (QValueListConstIterator<CSSProperty> it = mutableStyle->valuesIterator(); it != end; ++it) {
+        int propertyID = (*it).id();
+        DOMString desiredProperty = mutableStyle->getPropertyValue(propertyID);
         DOMString selectionProperty = selectionStyle->getPropertyValue(propertyID);
         if (strcasecmp(selectionProperty, desiredProperty) != 0) {
             match = false;
         DOMString selectionProperty = selectionStyle->getPropertyValue(propertyID);
         if (strcasecmp(selectionProperty, desiredProperty) != 0) {
             match = false;
@@ -5511,15 +5516,13 @@ CSSComputedStyleDeclarationImpl *KHTMLPart::selectionComputedStyle(NodeImpl *&no
     return new CSSComputedStyleDeclarationImpl(styleElement);
 }
 
     return new CSSComputedStyleDeclarationImpl(styleElement);
 }
 
-static CSSStyleDeclarationImpl *editingStyle()
+static CSSMutableStyleDeclarationImpl *editingStyle()
 {
 {
-    static CSSStyleDeclarationImpl *editingStyle = 0;
+    static CSSMutableStyleDeclarationImpl *editingStyle = 0;
     if (!editingStyle) {
     if (!editingStyle) {
-        QPtrList<CSSProperty> *propList = new QPtrList<CSSProperty>;
-        propList->setAutoDelete(true);
-        editingStyle = new CSSStyleDeclarationImpl(0, propList);
-        delete propList;
-        editingStyle->setCssText("word-wrap: break-word; -khtml-nbsp-mode: space; -khtml-line-break: after-white-space;");
+        editingStyle = new CSSMutableStyleDeclarationImpl;
+        int exceptionCode;
+        editingStyle->setCssText("word-wrap: break-word; -khtml-nbsp-mode: space; -khtml-line-break: after-white-space;", exceptionCode);
     }
     return editingStyle;
 }
     }
     return editingStyle;
 }
@@ -5561,8 +5564,8 @@ void KHTMLPart::applyEditingStyleToElement(ElementImpl *element) const
     if (!renderer || !renderer->isBlockFlow())
         return;
     
     if (!renderer || !renderer->isBlockFlow())
         return;
     
-    CSSStyleDeclarationImpl *currentStyle = static_cast<HTMLElementImpl *>(element)->getInlineStyleDecl();
-    CSSStyleDeclarationImpl *mergeStyle = editingStyle();
+    CSSMutableStyleDeclarationImpl *currentStyle = static_cast<HTMLElementImpl *>(element)->getInlineStyleDecl();
+    CSSMutableStyleDeclarationImpl *mergeStyle = editingStyle();
     if (mergeStyle) {
         currentStyle->merge(mergeStyle);
         element->setAttribute(ATTR_STYLE, currentStyle->cssText());
     if (mergeStyle) {
         currentStyle->merge(mergeStyle);
         element->setAttribute(ATTR_STYLE, currentStyle->cssText());
@@ -5578,11 +5581,14 @@ void KHTMLPart::removeEditingStyleFromElement(ElementImpl *element) const
     if (!renderer || !renderer->isBlockFlow())
         return;
     
     if (!renderer || !renderer->isBlockFlow())
         return;
     
-    CSSStyleDeclarationImpl *currentStyle = static_cast<HTMLElementImpl *>(element)->getInlineStyleDecl();
-    currentStyle->removeProperty(CSS_PROP_WORD_WRAP, false);
-    currentStyle->removeProperty(CSS_PROP__KHTML_NBSP_MODE, false);
-    currentStyle->removeProperty(CSS_PROP__KHTML_LINE_BREAK, false);
-    currentStyle->setChanged();
+    CSSMutableStyleDeclarationImpl *currentStyle = static_cast<HTMLElementImpl *>(element)->getInlineStyleDecl();
+    bool changed = false;
+    changed |= !currentStyle->removeProperty(CSS_PROP_WORD_WRAP, false).isNull();
+    changed |= !currentStyle->removeProperty(CSS_PROP__KHTML_NBSP_MODE, false).isNull();
+    changed |= !currentStyle->removeProperty(CSS_PROP__KHTML_LINE_BREAK, false).isNull();
+    if (changed)
+        currentStyle->setChanged();
+
     element->setAttribute(ATTR_STYLE, currentStyle->cssText());
 }
 
     element->setAttribute(ATTR_STYLE, currentStyle->cssText());
 }
 
index 11d38e55e3997b3d44b200169e8b1608476c4ffb..d0cce4d116fbaf2e9234037f19bf8a447f00aa7d 100644 (file)
@@ -42,8 +42,8 @@ class KJavaAppletContext;
 namespace DOM
 {
   class CSSComputedStyleDeclarationImpl;
 namespace DOM
 {
   class CSSComputedStyleDeclarationImpl;
+  class CSSMutableStyleDeclarationImpl;
   class CSSStyleDeclarationImpl;
   class CSSStyleDeclarationImpl;
-  typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
   class DOMString;
   class Document;
   class DocumentImpl;
   class DOMString;
   class Document;
   class DocumentImpl;
@@ -715,7 +715,7 @@ public:
   /**
    * Sets the typing style for the document.
    */
   /**
    * Sets the typing style for the document.
    */
-  void setTypingStyle(DOM::CSSStyleDeclarationImpl *);
+  void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 
   /**
    * Clears the typing style for the document.
 
   /**
    * Clears the typing style for the document.
index 77e40f3a78286ebfbdf8ce5254a94adad071ed76..954b27fd7f72dc2b74518fb12cc8e59331b3b17a 100644 (file)
@@ -520,9 +520,7 @@ EditingTextImpl *DocumentImpl::createEditingTextNode(const DOMString &text)
 
 CSSStyleDeclarationImpl *DocumentImpl::createCSSStyleDeclaration()
 {
 
 CSSStyleDeclarationImpl *DocumentImpl::createCSSStyleDeclaration()
 {
-    QPtrList<CSSProperty> *propList = new QPtrList<CSSProperty>;
-    propList->setAutoDelete(true);
-    return new CSSStyleDeclarationImpl(0, propList);
+    return new CSSMutableStyleDeclarationImpl;
 }
 
 NodeImpl *DocumentImpl::importNode(NodeImpl *importedNode, bool deep, int &exceptioncode)
 }
 
 NodeImpl *DocumentImpl::importNode(NodeImpl *importedNode, bool deep, int &exceptioncode)
index 4fdd90d8ab616d3ebe85597f35a6d2822a7f2ad5..17416bbbdbf172cf251e4a32d0317e83c064d22e 100644 (file)
@@ -160,14 +160,18 @@ NodeImpl *NodeImpl::lastChild() const
   return 0;
 }
 
   return 0;
 }
 
-NodeImpl *NodeImpl::insertBefore( NodeImpl *, NodeImpl *, int &exceptioncode )
+NodeImpl *NodeImpl::insertBefore( NodeImpl *newChild, NodeImpl *, int &exceptioncode )
 {
 {
+    newChild->ref();
+    newChild->deref();
     exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
     return 0;
 }
 
     exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
     return 0;
 }
 
-NodeImpl *NodeImpl::replaceChild( NodeImpl *, NodeImpl *, int &exceptioncode )
+NodeImpl *NodeImpl::replaceChild( NodeImpl *newChild, NodeImpl *, int &exceptioncode )
 {
 {
+  newChild->ref();
+  newChild->deref();
   exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
   return 0;
 }
   exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
   return 0;
 }
@@ -178,10 +182,12 @@ NodeImpl *NodeImpl::removeChild( NodeImpl *, int &exceptioncode )
   return 0;
 }
 
   return 0;
 }
 
-NodeImpl *NodeImpl::appendChild( NodeImpl *, int &exceptioncode )
+NodeImpl *NodeImpl::appendChild( NodeImpl *newChild, int &exceptioncode )
 {
 {
-  exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
-  return 0;
+    newChild->ref();
+    newChild->deref();
+    exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
+    return 0;
 }
 
 void NodeImpl::remove(int &exceptioncode)
 }
 
 void NodeImpl::remove(int &exceptioncode)
@@ -1607,6 +1613,8 @@ NodeImpl *NodeBaseImpl::insertBefore ( NodeImpl *newChild, NodeImpl *refChild, i
     if(!refChild)
         return appendChild(newChild, exceptioncode);
 
     if(!refChild)
         return appendChild(newChild, exceptioncode);
 
+    Node protectNewChild(newChild); // make sure the new child is ref'd and deref'd so we don't leak it
+
     // Make sure adding the new child is ok
     checkAddChild(newChild, exceptioncode);
     if (exceptioncode)
     // Make sure adding the new child is ok
     checkAddChild(newChild, exceptioncode);
     if (exceptioncode)
@@ -1623,7 +1631,7 @@ NodeImpl *NodeBaseImpl::insertBefore ( NodeImpl *newChild, NodeImpl *refChild, i
     // If newChild is a DocumentFragment with no children.... there's nothing to do.
     // Just return the document fragment
     if (isFragment && !newChild->firstChild())
     // If newChild is a DocumentFragment with no children.... there's nothing to do.
     // Just return the document fragment
     if (isFragment && !newChild->firstChild())
-        return newChild;
+        return (newChild->hasOneRef() && !newChild->parent()) ? 0 : newChild;
 
     // Now actually add the child(ren)
     NodeImpl *nextChild;
 
     // Now actually add the child(ren)
     NodeImpl *nextChild;
@@ -1674,6 +1682,8 @@ NodeImpl *NodeBaseImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, i
 {
     exceptioncode = 0;
 
 {
     exceptioncode = 0;
 
+    Node protectNewChild(newChild); // make sure the new child is ref'd and deref'd so we don't leak it
+
     if ( oldChild == newChild ) // nothing to do
        return oldChild;
     
     if ( oldChild == newChild ) // nothing to do
        return oldChild;
     
@@ -1692,7 +1702,6 @@ NodeImpl *NodeBaseImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, i
     NodeImpl *nextChild;
     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
 
     NodeImpl *nextChild;
     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
 
-
     // Remove the old child
     NodeImpl *prev = oldChild->previousSibling();
     NodeImpl *next = oldChild->nextSibling();
     // Remove the old child
     NodeImpl *prev = oldChild->previousSibling();
     NodeImpl *next = oldChild->nextSibling();
@@ -1832,6 +1841,8 @@ NodeImpl *NodeBaseImpl::appendChild ( NodeImpl *newChild, int &exceptioncode )
 {
     exceptioncode = 0;
 
 {
     exceptioncode = 0;
 
+    Node protectNewChild(newChild); // make sure the new child is ref'd and deref'd so we don't leak it
+
     // Make sure adding the new child is ok
     checkAddChild(newChild, exceptioncode);
     if (exceptioncode)
     // Make sure adding the new child is ok
     checkAddChild(newChild, exceptioncode);
     if (exceptioncode)
@@ -1951,6 +1962,8 @@ NodeImpl *NodeBaseImpl::addChild(NodeImpl *newChild)
 {
     // do not add applyChanges here! This function is only used during parsing
 
 {
     // do not add applyChanges here! This function is only used during parsing
 
+    Node protectNewChild(newChild); // make sure the new child is ref'd and deref'd so we don't leak it
+
     // short check for consistency with DTD
     if(!isXMLElementNode() && !newChild->isXMLElementNode() && !childAllowed(newChild))
     {
     // short check for consistency with DTD
     if(!isXMLElementNode() && !newChild->isXMLElementNode() && !childAllowed(newChild))
     {
index 58e3d4a5247731db9fb8eeac930019a9c4243bb5..c8c99b1133cc4879077d892a886200af1ba710f4 100644 (file)
@@ -787,7 +787,9 @@ static inline int getPropertyID(NSString *string)
 
 - (void)setCssText:(NSString *)cssText
 {
 
 - (void)setCssText:(NSString *)cssText
 {
-    [self _styleDeclarationImpl]->setCssText(cssText);
+    int exceptionCode;
+    [self _styleDeclarationImpl]->setCssText(cssText, exceptionCode);
+    raiseOnDOMError(exceptionCode);
 }
 
 - (NSString *)getPropertyValue:(NSString *)propertyName
 }
 
 - (NSString *)getPropertyValue:(NSString *)propertyName
@@ -811,7 +813,10 @@ static inline int getPropertyID(NSString *string)
     int propid = getPropertyID(propertyName);
     if (!propid) 
         return nil;
     int propid = getPropertyID(propertyName);
     if (!propid) 
         return nil;
-    return [self _styleDeclarationImpl]->removeProperty(propid);
+    int exceptionCode = 0;
+    DOMString result = [self _styleDeclarationImpl]->removeProperty(propid, exceptionCode);
+    raiseOnDOMError(exceptionCode);
+    return result;
 }
 
 - (NSString *)getPropertyPriority:(NSString *)propertyName
 }
 
 - (NSString *)getPropertyPriority:(NSString *)propertyName
@@ -831,7 +836,9 @@ static inline int getPropertyID(NSString *string)
     if (!propid) 
         return;
     bool important = strcasecmp(DOMString(priority), "important") == 0;
     if (!propid) 
         return;
     bool important = strcasecmp(DOMString(priority), "important") == 0;
-    [self _styleDeclarationImpl]->setProperty(propid, value, important);
+    int exceptionCode;
+    [self _styleDeclarationImpl]->setProperty(propid, value, important, exceptionCode);
+    raiseOnDOMError(exceptionCode);
 }
 
 - (unsigned long)length
 }
 
 - (unsigned long)length