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 5b5e920..99e54b9 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
index 4fbe20a..16543c1 100644 (file)
@@ -320,7 +320,6 @@ __ZNK22KWQPtrDictIteratorImpl5countEv
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
-__ZNK3DOM23CSSStyleDeclarationImpl6lengthEv
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
index 6939209..fbdeb48 100644 (file)
@@ -208,7 +208,6 @@ __ZNK22KWQPtrDictIteratorImpl5countEv
 __ZNK22KWQPtrDictIteratorImpl7currentEv
 __ZNK24KWQValueListIteratorImpl4nodeEv
 __ZNK3DOM11ElementImpl17formatForDebuggerEPcj
-__ZNK3DOM23CSSStyleDeclarationImpl6lengthEv
 __ZNK3DOM8NodeImpl17formatForDebuggerEPcj
 __ZNK3DOM8Position17formatForDebuggerEPcj
 __ZNK3DOM8TextImpl17formatForDebuggerEPcj
index 0df4d3a..8d079ee 100644 (file)
@@ -75,32 +75,6 @@ DOMString StyleBaseImpl::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()
index 97fe7bd..ead9241 100644 (file)
@@ -3,7 +3,7 @@
  *
  * 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
@@ -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.
- *
- * $Id$
  */
+
 #ifndef _CSS_BASE_H
 #define _CSS_BASE_H
 
@@ -216,9 +215,6 @@ namespace DOM {
 
        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();
index c43aa5e..935085c 100644 (file)
@@ -2,7 +2,7 @@
  * 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
  * 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 "dom_exception.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::RenderObject;
 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.
-static const int InheritableProperties[] = {
+static const int inheritableProperties[] = {
     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_ORPHANS,
     CSS_PROP_WHITE_SPACE,
+    CSS_PROP_WIDOWS,
     CSS_PROP_WORD_SPACING,
 };
 
+const unsigned numInheritableProperties = sizeof(inheritableProperties) / sizeof(inheritableProperties[0]);
+
 static CSSValueImpl* valueForLength(const Length &length)
 {
     switch (length.type) {
@@ -150,30 +260,37 @@ static CSSValueImpl* valueForShadow(const ShadowData *shadow)
     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:
-        l = m_renderer->style()->left();
+        l = style->left();
         break;
     case CSS_PROP_RIGHT:
-        l = m_renderer->style()->right();
+        l = style->right();
         break;
     case CSS_PROP_TOP:
-        l = m_renderer->style()->top();
+        l = style->top();
         break;
     case CSS_PROP_BOTTOM:
-        l = m_renderer->style()->bottom();
+        l = style->bottom();
         break;
     default:
         return 0;
     }
 
-    if (m_renderer->isPositioned())
+    if (renderer->isPositioned())
         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.
@@ -183,10 +300,8 @@ CSSValueImpl* CSSComputedStyleDeclarationImpl::getPositionOffsetValue(int proper
 }
 
 CSSComputedStyleDeclarationImpl::CSSComputedStyleDeclarationImpl(NodeImpl *n)
-    : CSSStyleDeclarationImpl(0)
+    : m_node(n)
 {
-    setNode(n);
-    m_renderer = node()->renderer();
 }
 
 CSSComputedStyleDeclarationImpl::~CSSComputedStyleDeclarationImpl()
@@ -199,9 +314,9 @@ DOMString CSSComputedStyleDeclarationImpl::cssText() const
     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".
@@ -216,28 +331,32 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
     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.
-    DocumentImpl* docimpl = node()->getDocument();
+    DocumentImpl* docimpl = node->getDocument();
     if (docimpl && updateLayout)
         docimpl->updateLayout();
 
-    if (!m_renderer)
+    RenderObject *renderer = node->renderer();
+    if (!renderer)
         return 0;
-    RenderStyle *style = m_renderer->style();
+    RenderStyle *style = renderer->style();
     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())
-            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:
@@ -263,13 +382,13 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         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 += 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:
@@ -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:
-        return getPositionOffsetValue(CSS_PROP_BOTTOM);
+        return getPositionOffsetValue(renderer, CSS_PROP_BOTTOM);
     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:
-        // 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:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
     case CSS_PROP__KHTML_BOX_FLEX_GROUP:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
     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:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
     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:
-        // 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:
-        // 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:
-        // 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;
@@ -369,11 +550,51 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // 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:
-        // 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:
@@ -447,9 +668,6 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         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;
@@ -481,9 +699,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
             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:
-        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);
@@ -501,14 +719,65 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         }
     }
     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:
-        // 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:
-        // 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:
@@ -521,22 +790,57 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // 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:
-        // 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:
-        // 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:
-        // 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:
@@ -546,13 +850,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
     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:
-        // FIXME: unimplemented
-        break;
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
     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;
+        if (style->outlineStyleIsAuto())
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        return valueForBorderStyle(style->outlineStyle());
     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;
+        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:
-        // 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:
-        // 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:
-        // 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:
-        return getPositionOffsetValue(CSS_PROP_RIGHT);
+        return getPositionOffsetValue(renderer, CSS_PROP_RIGHT);
     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:
-        return getPositionOffsetValue(CSS_PROP_TOP);
+        return getPositionOffsetValue(renderer, CSS_PROP_TOP);
     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:
@@ -720,10 +1063,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         ASSERT_NOT_REACHED();
         return 0;
     case CSS_PROP_WIDOWS:
-        // FIXME: unimplemented
-        break;
+        return new CSSPrimitiveValueImpl(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
     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:
@@ -754,8 +1096,9 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         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;
@@ -821,9 +1164,6 @@ CSSValueImpl *CSSComputedStyleDeclarationImpl::getPropertyCSSValue(int propertyI
         // 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();
@@ -872,57 +1212,46 @@ DOMString CSSComputedStyleDeclarationImpl::getPropertyValue(int propertyID) cons
 
 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;
 }
 
-DOMString CSSComputedStyleDeclarationImpl::removeProperty(int)
+DOMString CSSComputedStyleDeclarationImpl::removeProperty(int, int &exceptionCode)
 {
-    ASSERT_NOT_REACHED();
+    exceptionCode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
     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
index aa50f75..5a7a907 100644 (file)
@@ -2,7 +2,7 @@
  * 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
  * 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"
-#include "dom/dom_string.h"
 
 namespace khtml {
     class RenderObject;
+    class RenderStyle;
 }
 
 namespace DOM {
 
 class CSSProperty;
-class CSSStyleDeclarationImpl;
-class CSSValueImpl;
-class DOMString;
-class NodeImpl;
 
 enum EUpdateLayout { DoNotUpdateLayout = false, UpdateLayout = true };
 
@@ -46,32 +43,29 @@ public:
     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;
-    CSSValueImpl *getPropertyCSSValue(int propertyID, bool updateLayout) 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:
-    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
index bd0fee9..025326b 100644 (file)
@@ -38,11 +38,10 @@ namespace khtml {
 
 namespace DOM {
 
+class CSSMutableStyleDeclarationImpl;
 class CSSRule;
 class CSSStyleSheet;
 class CSSStyleSheetImpl;
-class CSSStyleDeclarationImpl;
-typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
 class MediaListImpl;
 
 class CSSRuleImpl : public StyleBaseImpl
index 5361a66..bdd324a 100644 (file)
@@ -2,7 +2,7 @@
  * 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
@@ -51,61 +51,57 @@ extern DOM::DOMString getPropertyName(unsigned short id);
 using khtml::FontDef;
 using khtml::CSSStyleSelector;
 
-using namespace DOM;
+namespace DOM {
 
 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;
 }
 
-CSSStyleDeclarationImpl::~CSSStyleDeclarationImpl()
+CSSMutableStyleDeclarationImpl::~CSSMutableStyleDeclarationImpl()
 {
-    delete m_lstValues;
     // 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 );
-    if ( value )
+    if (value)
         return CSSValue(value).cssText();
 
     // Shorthand and 4-values properties
@@ -201,7 +197,7 @@ DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
     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 ) {
@@ -218,7 +214,7 @@ DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
     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 ) {
@@ -234,38 +230,35 @@ DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int
     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;
 }
 
-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;
 
-    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;
 }
 
-void CSSStyleDeclarationImpl::setChanged()
+void CSSMutableStyleDeclarationImpl::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;
 }
 
-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;
-    else if (notifyChanged)
+#endif
+        exceptionCode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
+    } else if (notifyChanged)
         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();
+    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);
-    setParsedValue(propertyId, new CSSPrimitiveValueImpl(value, type), important, m_lstValues);
+    m_values.append(CSSProperty(propertyId, new CSSPrimitiveValueImpl(value, type), important));
     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);
-    setParsedValue(propertyId, new CSSImageValueImpl(URL, this), important, m_lstValues);
+    m_values.append(CSSProperty(propertyId, new CSSImageValueImpl(URL, this), important));
     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();
 }
 
-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;
@@ -369,12 +359,12 @@ void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &va
     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);
@@ -387,73 +377,58 @@ CSSRuleImpl *CSSStyleDeclarationImpl::parentRule() const
        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;
 }
 
-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);
+    // FIXME: Detect syntax errors and set exceptionCode.
     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;
-            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;
-    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->cssText() == property->value()->cssText()) {
-                properties.append(property->id());
+            if (value->cssText() == property.value()->cssText()) {
+                properties.append(property.id());
             }
             value->deref();
         }
@@ -476,40 +451,34 @@ static const int BlockProperties[] = {
     CSS_PROP_WIDOWS
 };
 
-CSSStyleDeclarationImpl *CSSStyleDeclarationImpl::copyBlockProperties() const
+CSSMutableStyleDeclarationImpl *CSSMutableStyleDeclarationImpl::copyBlockProperties() const
 {
     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]);
-        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;
@@ -533,7 +502,6 @@ DOM::DOMString CSSInitialValueImpl::cssText() const
 // ----------------------------------------------------------------------------------------
 
 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("; ");
 }
+
+}
index 4f0259f..7ea65cd 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.
- *
- * $Id$
  */
+
 #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 "misc/shared.h"
-
-#include <qintdict.h>
+#include <qvaluelist.h>
 
 namespace khtml {
     class RenderStyle;
@@ -40,81 +36,48 @@ namespace khtml {
 
 namespace DOM {
 
-class CSSRuleImpl;
-class CSSValueImpl;
-class NodeImpl;
+class CSSMutableStyleDeclarationImpl;
 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;
-    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:
-    // currently not needed - make sure its not used
-    CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl& o);
+    CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl &);
+    CSSStyleDeclarationImpl& operator=(const CSSStyleDeclarationImpl &);
 };
 
 class CSSValueImpl : public StyleBaseImpl
 {
 public:
-    CSSValueImpl();
-
-    virtual ~CSSValueImpl();
-
     virtual unsigned short cssValueType() const = 0;
-
     virtual DOMString cssText() const = 0;
 
     virtual bool isValue() { return true; }
@@ -124,9 +87,6 @@ public:
 class CSSInheritedValueImpl : public CSSValueImpl
 {
 public:
-    CSSInheritedValueImpl() : CSSValueImpl() {}
-    virtual ~CSSInheritedValueImpl() {}
-
     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( RectImpl *r);
-    CSSPrimitiveValueImpl( DashboardRegionImpl *r);
+    CSSPrimitiveValueImpl(RectImpl *r);
+    CSSPrimitiveValueImpl(DashboardRegionImpl *r);
     CSSPrimitiveValueImpl(QRgb color);
 
     virtual ~CSSPrimitiveValueImpl();
@@ -261,14 +221,11 @@ public:
     CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
       :CSSPrimitiveValueImpl(num, type) {}
 
-    virtual ~CSSQuirkPrimitiveValueImpl() {}
-
     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; }
@@ -281,7 +238,7 @@ public:
 class RectImpl : public khtml::Shared<RectImpl> {
 public:
     RectImpl();
-    ~RectImpl();
+    virtual ~RectImpl();
 
     CSSPrimitiveValueImpl *top() { return m_top; }
     CSSPrimitiveValueImpl *right() { return m_right; }
@@ -300,19 +257,21 @@ protected:
 };
 
 #if APPLE_CHANGES
+
 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();
-    };
+    }
 
-    void setNext (DashboardRegionImpl *next) {
-        if (m_next) m_next->deref();
+    void setNext (DashboardRegionImpl *next)
+    {
         if (next) next->ref();
+        if (m_next) m_next->deref();
         m_next = next;
-    };
+    }
     
 public:
     DashboardRegionImpl *m_next;
@@ -321,13 +280,14 @@ public:
     unsigned int m_isCircle:1;
     unsigned int m_isRectangle:1;
 };
+
 #endif
 
 class CSSImageValueImpl : public CSSPrimitiveValueImpl, public khtml::CachedObjectClient
 {
 public:
-    CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style);
     CSSImageValueImpl();
+    CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style);
     virtual ~CSSImageValueImpl();
 
     khtml::CachedImage *image(khtml::DocLoader* loader);
@@ -417,11 +377,13 @@ 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)
     {
@@ -430,21 +392,27 @@ public:
         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) {
-       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; }
-    
     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;
+
 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:
-    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
index 9d2c362..76c96cc 100644 (file)
@@ -223,10 +223,7 @@ bool CSSParser::parseValue( CSSMutableStyleDeclarationImpl *declaration, int _id
     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;
     }
 
@@ -305,10 +302,7 @@ bool CSSParser::parseDeclaration( CSSMutableStyleDeclarationImpl *declaration, c
     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;
     }
 
@@ -333,13 +327,9 @@ void CSSParser::addProperty( int propId, CSSValueImpl *value, bool important )
 
 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;
-    return new CSSMutableStyleDeclarationImpl(rule, propList);
+    return result;
 }
 
 void CSSParser::clearProperties()
index c3e3fcb..d041f32 100644 (file)
@@ -37,7 +37,7 @@ namespace DOM {
     class CSSValueImpl;
     class CSSValueListImpl;
     class CSSPrimitiveValueImpl;
-    typedef class CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
+    class CSSMutableStyleDeclarationImpl;
     class CSSProperty;
     class CSSRuleListImpl;
 
index f79ca78..a9917d0 100644 (file)
@@ -191,7 +191,7 @@ findProp (register const char *str, register unsigned int len)
 {
   enum
     {
-      TOTAL_KEYWORDS = 159,
+      TOTAL_KEYWORDS = 157,
       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[] =
     {
-#line 135 "cssproperties.gperf"
+#line 134 "cssproperties.gperf"
       {"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},
-#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},
-#line 152 "cssproperties.gperf"
+#line 151 "cssproperties.gperf"
       {"border-top", CSS_PROP_BORDER_TOP},
-#line 150 "cssproperties.gperf"
+#line 149 "cssproperties.gperf"
       {"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},
-#line 66 "cssproperties.gperf"
+#line 65 "cssproperties.gperf"
       {"-apple-line-clamp", CSS_PROP__APPLE_LINE_CLAMP},
-#line 159 "cssproperties.gperf"
+#line 158 "cssproperties.gperf"
       {"margin", CSS_PROP_MARGIN},
-#line 161 "cssproperties.gperf"
+#line 160 "cssproperties.gperf"
       {"padding", CSS_PROP_PADDING},
-#line 107 "cssproperties.gperf"
+#line 106 "cssproperties.gperf"
       {"position", CSS_PROP_POSITION},
-#line 103 "cssproperties.gperf"
+#line 102 "cssproperties.gperf"
       {"page", CSS_PROP_PAGE},
-#line 71 "cssproperties.gperf"
+#line 70 "cssproperties.gperf"
       {"margin-top", CSS_PROP_MARGIN_TOP},
-#line 98 "cssproperties.gperf"
+#line 97 "cssproperties.gperf"
       {"padding-top", CSS_PROP_PADDING_TOP},
-#line 73 "cssproperties.gperf"
+#line 72 "cssproperties.gperf"
       {"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},
-#line 109 "cssproperties.gperf"
+#line 108 "cssproperties.gperf"
       {"right", CSS_PROP_RIGHT},
-#line 92 "cssproperties.gperf"
+#line 91 "cssproperties.gperf"
       {"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},
-#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},
-#line 63 "cssproperties.gperf"
+#line 62 "cssproperties.gperf"
       {"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},
-#line 167 "cssproperties.gperf"
+#line 166 "cssproperties.gperf"
       {"scrollbar-track-color", CSS_PROP_SCROLLBAR_TRACK_COLOR},
-#line 65 "cssproperties.gperf"
+#line 64 "cssproperties.gperf"
       {"letter-spacing", CSS_PROP_LETTER_SPACING},
-#line 67 "cssproperties.gperf"
+#line 66 "cssproperties.gperf"
       {"line-height", CSS_PROP_LINE_HEIGHT},
-#line 72 "cssproperties.gperf"
+#line 71 "cssproperties.gperf"
       {"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},
-#line 160 "cssproperties.gperf"
+#line 159 "cssproperties.gperf"
       {"outline", CSS_PROP_OUTLINE},
-#line 140 "cssproperties.gperf"
+#line 139 "cssproperties.gperf"
       {"vertical-align", CSS_PROP_VERTICAL_ALIGN},
-#line 90 "cssproperties.gperf"
+#line 89 "cssproperties.gperf"
       {"-khtml-nbsp-mode", CSS_PROP__KHTML_NBSP_MODE},
-#line 136 "cssproperties.gperf"
+#line 135 "cssproperties.gperf"
       {"unicode-bidi", CSS_PROP_UNICODE_BIDI},
-#line 93 "cssproperties.gperf"
+#line 92 "cssproperties.gperf"
       {"outline-color", CSS_PROP_OUTLINE_COLOR},
-#line 75 "cssproperties.gperf"
+#line 74 "cssproperties.gperf"
       {"-khtml-line-break", CSS_PROP__KHTML_LINE_BREAK},
-#line 165 "cssproperties.gperf"
+#line 164 "cssproperties.gperf"
       {"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},
-#line 106 "cssproperties.gperf"
+#line 105 "cssproperties.gperf"
       {"page-break-inside", CSS_PROP_PAGE_BREAK_INSIDE},
-#line 79 "cssproperties.gperf"
+#line 78 "cssproperties.gperf"
       {"-khtml-margin-start", CSS_PROP__KHTML_MARGIN_START},
-#line 102 "cssproperties.gperf"
+#line 101 "cssproperties.gperf"
       {"-khtml-padding-start", CSS_PROP__KHTML_PADDING_START},
-#line 76 "cssproperties.gperf"
+#line 75 "cssproperties.gperf"
       {"-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},
-#line 78 "cssproperties.gperf"
+#line 77 "cssproperties.gperf"
       {"-khtml-margin-bottom-collapse", CSS_PROP__KHTML_MARGIN_BOTTOM_COLLAPSE},
-#line 148 "cssproperties.gperf"
+#line 147 "cssproperties.gperf"
       {"background", CSS_PROP_BACKGROUND},
-#line 114 "cssproperties.gperf"
-      {"text-indent", CSS_PROP_TEXT_INDENT},
 #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},
-#line 147 "cssproperties.gperf"
+#line 146 "cssproperties.gperf"
       {"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},
-#line 64 "cssproperties.gperf"
+#line 63 "cssproperties.gperf"
       {"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},
-#line 112 "cssproperties.gperf"
+#line 111 "cssproperties.gperf"
       {"text-align", CSS_PROP_TEXT_ALIGN},
-#line 108 "cssproperties.gperf"
+#line 107 "cssproperties.gperf"
       {"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},
@@ -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},
-#line 74 "cssproperties.gperf"
+#line 73 "cssproperties.gperf"
       {"margin-left", CSS_PROP_MARGIN_LEFT},
-#line 101 "cssproperties.gperf"
+#line 100 "cssproperties.gperf"
       {"padding-left", CSS_PROP_PADDING_LEFT},
-#line 121 "cssproperties.gperf"
+#line 120 "cssproperties.gperf"
       {"text-overline", CSS_PROP_TEXT_OVERLINE},
-#line 80 "cssproperties.gperf"
+#line 79 "cssproperties.gperf"
       {"-khtml-marquee", CSS_PROP__KHTML_MARQUEE},
-#line 86 "cssproperties.gperf"
+#line 85 "cssproperties.gperf"
       {"max-height", CSS_PROP_MAX_HEIGHT},
-#line 137 "cssproperties.gperf"
+#line 136 "cssproperties.gperf"
       {"-khtml-user-drag", CSS_PROP__KHTML_USER_DRAG},
-#line 122 "cssproperties.gperf"
+#line 121 "cssproperties.gperf"
       {"text-overline-color", CSS_PROP_TEXT_OVERLINE_COLOR},
-#line 162 "cssproperties.gperf"
+#line 161 "cssproperties.gperf"
       {"scrollbar-face-color", CSS_PROP_SCROLLBAR_FACE_COLOR},
-#line 61 "cssproperties.gperf"
+#line 60 "cssproperties.gperf"
       {"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},
@@ -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},
-#line 59 "cssproperties.gperf"
+#line 58 "cssproperties.gperf"
       {"font-stretch", CSS_PROP_FONT_STRETCH},
-#line 139 "cssproperties.gperf"
+#line 138 "cssproperties.gperf"
       {"-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},
-#line 82 "cssproperties.gperf"
+#line 81 "cssproperties.gperf"
       {"-khtml-marquee-increment", CSS_PROP__KHTML_MARQUEE_INCREMENT},
-#line 83 "cssproperties.gperf"
+#line 82 "cssproperties.gperf"
       {"-khtml-marquee-repetition", CSS_PROP__KHTML_MARQUEE_REPETITION},
-#line 128 "cssproperties.gperf"
+#line 127 "cssproperties.gperf"
       {"text-underline", CSS_PROP_TEXT_UNDERLINE},
-#line 129 "cssproperties.gperf"
+#line 128 "cssproperties.gperf"
       {"text-underline-color", CSS_PROP_TEXT_UNDERLINE_COLOR},
-#line 104 "cssproperties.gperf"
+#line 103 "cssproperties.gperf"
       {"page-break-after", CSS_PROP_PAGE_BREAK_AFTER},
-#line 91 "cssproperties.gperf"
+#line 90 "cssproperties.gperf"
       {"opacity", CSS_PROP_OPACITY},
-#line 130 "cssproperties.gperf"
+#line 129 "cssproperties.gperf"
       {"text-underline-mode", CSS_PROP_TEXT_UNDERLINE_MODE},
-#line 84 "cssproperties.gperf"
+#line 83 "cssproperties.gperf"
       {"-khtml-marquee-speed", CSS_PROP__KHTML_MARQUEE_SPEED},
-#line 105 "cssproperties.gperf"
+#line 104 "cssproperties.gperf"
       {"page-break-before", CSS_PROP_PAGE_BREAK_BEFORE},
-#line 144 "cssproperties.gperf"
+#line 143 "cssproperties.gperf"
       {"width", CSS_PROP_WIDTH},
-#line 89 "cssproperties.gperf"
+#line 88 "cssproperties.gperf"
       {"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},
@@ -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},
-#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},
-#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},
-#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},
-#line 142 "cssproperties.gperf"
+#line 141 "cssproperties.gperf"
       {"white-space", CSS_PROP_WHITE_SPACE},
-#line 146 "cssproperties.gperf"
+#line 145 "cssproperties.gperf"
       {"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},
-#line 117 "cssproperties.gperf"
+#line 116 "cssproperties.gperf"
       {"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},
-#line 141 "cssproperties.gperf"
+#line 140 "cssproperties.gperf"
       {"visibility", CSS_PROP_VISIBILITY},
-#line 133 "cssproperties.gperf"
+#line 132 "cssproperties.gperf"
       {"-apple-text-size-adjust", CSS_PROP__APPLE_TEXT_SIZE_ADJUST},
-#line 127 "cssproperties.gperf"
+#line 126 "cssproperties.gperf"
       {"text-transform", CSS_PROP_TEXT_TRANSFORM},
-#line 163 "cssproperties.gperf"
+#line 162 "cssproperties.gperf"
       {"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},
-#line 96 "cssproperties.gperf"
+#line 95 "cssproperties.gperf"
       {"outline-width", CSS_PROP_OUTLINE_WIDTH},
-#line 69 "cssproperties.gperf"
-      {"list-style-position", CSS_PROP_LIST_STYLE_POSITION},
 #line 68 "cssproperties.gperf"
+      {"list-style-position", CSS_PROP_LIST_STYLE_POSITION},
+#line 67 "cssproperties.gperf"
       {"list-style-image", CSS_PROP_LIST_STYLE_IMAGE},
-#line 166 "cssproperties.gperf"
+#line 165 "cssproperties.gperf"
       {"scrollbar-darkshadow-color", CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR},
-#line 95 "cssproperties.gperf"
+#line 94 "cssproperties.gperf"
       {"outline-style", CSS_PROP_OUTLINE_STYLE},
-#line 87 "cssproperties.gperf"
+#line 86 "cssproperties.gperf"
       {"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},
-#line 60 "cssproperties.gperf"
+#line 59 "cssproperties.gperf"
       {"font-style", CSS_PROP_FONT_STYLE},
-#line 94 "cssproperties.gperf"
+#line 93 "cssproperties.gperf"
       {"outline-offset", CSS_PROP_OUTLINE_OFFSET},
-#line 97 "cssproperties.gperf"
+#line 96 "cssproperties.gperf"
       {"overflow", CSS_PROP_OVERFLOW},
-#line 62 "cssproperties.gperf"
+#line 61 "cssproperties.gperf"
       {"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 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},
-#line 145 "cssproperties.gperf"
+#line 144 "cssproperties.gperf"
       {"word-wrap", CSS_PROP_WORD_WRAP},
-#line 124 "cssproperties.gperf"
+#line 123 "cssproperties.gperf"
       {"text-overline-style", CSS_PROP_TEXT_OVERLINE_STYLE},
-#line 85 "cssproperties.gperf"
+#line 84 "cssproperties.gperf"
       {"-khtml-marquee-style", CSS_PROP__KHTML_MARQUEE_STYLE},
-#line 132 "cssproperties.gperf"
+#line 131 "cssproperties.gperf"
       {"text-underline-width", CSS_PROP_TEXT_UNDERLINE_WIDTH},
-#line 143 "cssproperties.gperf"
+#line 142 "cssproperties.gperf"
       {"widows", CSS_PROP_WIDOWS},
-#line 131 "cssproperties.gperf"
+#line 130 "cssproperties.gperf"
       {"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},
-#line 70 "cssproperties.gperf"
+#line 69 "cssproperties.gperf"
       {"list-style-type", CSS_PROP_LIST_STYLE_TYPE},
-#line 138 "cssproperties.gperf"
+#line 137 "cssproperties.gperf"
       {"-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},
-#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}
@@ -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,  -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, 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, 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, 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)
@@ -595,7 +591,7 @@ findProp (register const char *str, register unsigned int len)
     }
   return 0;
 }
-#line 170 "cssproperties.gperf"
+#line 168 "cssproperties.gperf"
 
 static const char * const propertyList[] = {
 "",
@@ -646,7 +642,6 @@ static const char * const propertyList[] = {
 "float", 
 "font-family", 
 "font-size", 
-"font-size-adjust", 
 "font-stretch", 
 "font-style", 
 "font-variant", 
@@ -757,7 +752,6 @@ static const char * const propertyList[] = {
 "scrollbar-darkshadow-color", 
 "scrollbar-track-color", 
 "scrollbar-arrow-color", 
-"-khtml-flow-mode", 
     0
 };
 DOMString getPropertyName(unsigned short id)
index d17fd25..ece9700 100644 (file)
 #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_TOTAL 160
+#define CSS_PROP_TOTAL 158
 #endif
 
index 9449961..9cc154d 100644 (file)
@@ -59,7 +59,6 @@ empty-cells
 float
 font-family
 font-size
-font-size-adjust
 font-stretch
 font-style
 font-variant
@@ -170,4 +169,3 @@ scrollbar-3dlight-color
 scrollbar-darkshadow-color
 scrollbar-track-color
 scrollbar-arrow-color
--khtml-flow-mode
index 173f7ad..796bbac 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];
-        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
-                        case CSS_PROP__APPLE_TEXT_SIZE_ADJUST:
+                    case CSS_PROP__APPLE_TEXT_SIZE_ADJUST:
 #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 14cff7e..6ccc871 100644 (file)
@@ -62,7 +62,7 @@ CSSStyleDeclaration::~CSSStyleDeclaration()
 DOMString CSSStyleDeclaration::cssText() const
 {
     if(!impl) return DOMString();
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText();
+    return impl->cssText();
 }
 
 static void throwException(int exceptioncode)
@@ -77,15 +77,16 @@ void CSSStyleDeclaration::setCssText( const DOMString &value )
 {
     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();
-    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 )
@@ -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;
-    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();
-    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 )
@@ -122,25 +126,27 @@ void CSSStyleDeclaration::setProperty( const DOMString &propName, const DOMStrin
     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;
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->length();
+    return impl->length();
 }
 
 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;
-    return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule();
+    return impl->parentRule();
 }
 
 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
@@ -193,10 +199,9 @@ DOMString CSSValue::cssText() const
     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
index 6784da9..9e4d34f 100644 (file)
@@ -410,16 +410,6 @@ QRect Node::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;
index f42b88c..34dffed 100644 (file)
@@ -855,12 +855,12 @@ public:
      *   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
      */
-    NodeImpl *handle() const;
+    NodeImpl *handle() const { return impl; }
 
     /**
      * @internal returns the index of a node
index 1b253b7..52ca14f 100644 (file)
@@ -1,7 +1,7 @@
 // -*- 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
@@ -19,6 +19,7 @@
  */
 
 #include "xmlhttprequest.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();
   }
 
-  changeState(Completed);
   job = 0;
+
+  changeState(Completed);
   
   if (decoder) {
     decoder->deref();
@@ -668,4 +670,4 @@ Value XMLHttpRequestProtoFunc::tryCall(ExecState *exec, Object &thisObj, const L
   return Undefined();
 }
 
-}; // end namespace
+} // end namespace
index 8a9d21e..db603c2 100644 (file)
@@ -55,6 +55,7 @@
 
 using DOM::AttrImpl;
 using DOM::CSSComputedStyleDeclarationImpl;
+using DOM::CSSMutableStyleDeclarationImpl;
 using DOM::CSSPrimitiveValue;
 using DOM::CSSPrimitiveValueImpl;
 using DOM::CSSProperty;
@@ -292,13 +293,13 @@ void EditCommandPtr::setEndingSelection(const Selection &s) const
     get()->setEndingSelection(s);
 }
 
-CSSStyleDeclarationImpl *EditCommandPtr::typingStyle() const
+CSSMutableStyleDeclarationImpl *EditCommandPtr::typingStyle() const
 {
     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);
@@ -339,10 +340,16 @@ StyleChange::StyleChange(CSSStyleDeclarationImpl *style, const Position &positio
 
 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.
@@ -356,6 +363,8 @@ void StyleChange::init(CSSStyleDeclarationImpl *style, const Position &position)
         styleText += property->cssText().string();
     }
 
+    mutableStyle->deref();
+
     m_cssStyle = styleText.stripWhiteSpace();
 }
 
@@ -513,12 +522,12 @@ void EditCommand::setEndingSelection(const Selection &s)
         cmd->m_endingSelection = s;
 }
 
-void EditCommand::assignTypingStyle(CSSStyleDeclarationImpl *style)
+void EditCommand::assignTypingStyle(CSSMutableStyleDeclarationImpl *style)
 {
     if (m_typingStyle == style)
         return;
         
-    CSSStyleDeclarationImpl *old = m_typingStyle;
+    CSSMutableStyleDeclarationImpl *old = m_typingStyle;
     m_typingStyle = style;
     if (m_typingStyle)
         m_typingStyle->ref();
@@ -526,7 +535,7 @@ void EditCommand::assignTypingStyle(CSSStyleDeclarationImpl *style)
         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
@@ -978,7 +987,7 @@ void AppendNodeCommand::doUnapply()
 // ApplyStyleCommand
 
 ApplyStyleCommand::ApplyStyleCommand(DocumentImpl *document, CSSStyleDeclarationImpl *style)
-    : CompositeEditCommand(document), m_style(style)
+    : CompositeEditCommand(document), m_style(style->makeMutable())
 {   
     ASSERT(m_style);
     m_style->ref();
@@ -992,12 +1001,12 @@ ApplyStyleCommand::~ApplyStyleCommand()
 
 void ApplyStyleCommand::doApply()
 {
-    CSSStyleDeclarationImpl *blockStyle = m_style->copyBlockProperties();
+    CSSMutableStyleDeclarationImpl *blockStyle = m_style->copyBlockProperties();
     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);
@@ -1009,7 +1018,7 @@ void ApplyStyleCommand::doApply()
     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
@@ -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());
@@ -1107,11 +1116,11 @@ void ApplyStyleCommand::applyInlineStyle(CSSStyleDeclarationImpl *style)
 //------------------------------------------------------------------------------------------
 // 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;
@@ -1136,21 +1145,22 @@ void ApplyStyleCommand::removeHTMLStyleNode(HTMLElementImpl *elem)
     removeNodePreservingChildren(elem);
 }
 
-void ApplyStyleCommand::removeCSSStyle(CSSStyleDeclarationImpl *style, HTMLElementImpl *elem)
+void ApplyStyleCommand::removeCSSStyle(CSSMutableStyleDeclarationImpl *style, HTMLElementImpl *elem)
 {
     ASSERT(style);
     ASSERT(elem);
 
-    CSSStyleDeclarationImpl *decl = elem->inlineStyleDecl();
+    CSSMutableStyleDeclarationImpl *decl = elem->inlineStyleDecl();
     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();
-            removeCSSProperty(decl, property->id());
+            removeCSSProperty(decl, propertyID);
             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.
-        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())
@@ -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());
@@ -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());
@@ -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();
-        CSSStyleDeclarationImpl *decl = block->inlineStyleDecl();
+        CSSMutableStyleDeclarationImpl *decl = block->inlineStyleDecl();
         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.
@@ -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
-    CSSStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
+    CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
     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
-        CSSStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
+        CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
         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
-        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.
@@ -2822,7 +2832,7 @@ void MoveSelectionCommand::doApply()
 // 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();
index f2904e5..9ddda31 100644 (file)
@@ -33,6 +33,7 @@
 #include "shared.h"
 
 namespace DOM {
+    class CSSMutableStyleDeclarationImpl;
     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;
 
-    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;
@@ -147,14 +148,14 @@ public:
     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:
-    void assignTypingStyle(DOM::CSSStyleDeclarationImpl *);
+    void assignTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 
     virtual bool preservesTypingStyle() const;
 
@@ -162,7 +163,7 @@ private:
     ECommandState m_state;
     khtml::Selection m_startingSelection;
     khtml::Selection m_endingSelection;
-    DOM::CSSStyleDeclarationImpl *m_typingStyle;
+    DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
     EditCommand *m_parent;
 };
 
@@ -247,28 +248,28 @@ public:
        
     virtual void doApply();
 
-    DOM::CSSStyleDeclarationImpl *style() const { return m_style; }
+    DOM::CSSMutableStyleDeclarationImpl *style() const { return m_style; }
 
 private:
     // style-removal helpers
-    bool isHTMLStyleNode(DOM::CSSStyleDeclarationImpl *, DOM::HTMLElementImpl *);
+    bool isHTMLStyleNode(DOM::CSSMutableStyleDeclarationImpl *, 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
-    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);
     
-    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::CSSStyleDeclarationImpl *m_typingStyle;
+    DOM::CSSMutableStyleDeclarationImpl *m_typingStyle;
 };
 
 //------------------------------------------------------------------------------------------
@@ -522,11 +523,11 @@ public:
     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:
-    DOM::CSSStyleDeclarationImpl *m_decl;
+    DOM::CSSMutableStyleDeclarationImpl *m_decl;
     int m_property;
     DOM::DOMString m_oldValue;
     bool m_important;
index 07fde05..eb03cdf 100644 (file)
@@ -133,7 +133,7 @@ namespace {
 
 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);
@@ -148,7 +148,7 @@ bool execStyleChange(KHTMLPart *part, int propertyID, const char *propertyValue)
 
 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);
@@ -158,7 +158,7 @@ KHTMLPart::TriState stateStyle(KHTMLPart *part, int propertyID, const char *desi
 
 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);
index e55edd4..0c06599 100644 (file)
@@ -68,7 +68,7 @@ NodeImpl::Id HTMLBodyElementImpl::id() const
 
 void HTMLBodyElementImpl::createLinkDecl()
 {
-    m_linkDecl = new CSSStyleDeclarationImpl(0);
+    m_linkDecl = new CSSMutableStyleDeclarationImpl;
     m_linkDecl->ref();
     m_linkDecl->setParent(getDocument()->elementSheet());
     m_linkDecl->setNode(this);
index d06ee70..0f92937 100644 (file)
@@ -67,7 +67,7 @@ public:
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
 protected:
-    CSSStyleDeclarationImpl* m_linkDecl;
+    CSSMutableStyleDeclarationImpl* m_linkDecl;
 };
 
 // -------------------------------------------------------------------------
index c75f5c2..1e7ccf9 100644 (file)
@@ -267,7 +267,7 @@ bool HTMLElementImpl::isInline() const
 
 void HTMLElementImpl::createInlineStyleDecl()
 {
-    m_inlineStyleDecl = new CSSStyleDeclarationImpl(0);
+    m_inlineStyleDecl = new CSSMutableStyleDeclarationImpl;
     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();
-        getInlineStyleDecl()->setProperty(attr->value());
+        getInlineStyleDecl()->parseProperty(attr->value());
         setChanged();
         break;
     case ATTR_TABINDEX:
@@ -526,14 +526,14 @@ void HTMLElementImpl::createAttributeMap() const
     namedAttrMap->ref();
 }
 
-CSSStyleDeclarationImpl* HTMLElementImpl::getInlineStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLElementImpl::getInlineStyleDecl()
 {
     if (!m_inlineStyleDecl)
         createInlineStyleDecl();
     return m_inlineStyleDecl;
 }
 
-CSSStyleDeclarationImpl* HTMLElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLElementImpl::additionalAttributeStyleDecl()
 {
     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();
-       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;
@@ -780,11 +781,14 @@ DocumentFragmentImpl *HTMLElementImpl::createContextualFragment(const DOMString
                 child->deref();
            }
             fragment->removeChild(node, ignoredExceptionCode);
-            // FIXME: Does node leak here?
        } 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
@@ -806,8 +810,6 @@ bool HTMLElementImpl::setInnerHTML( const DOMString &html )
     removeChildren();
     int ec = 0;
     appendChild( fragment, ec );
-    fragment->ref();
-    fragment->deref();
     return !ec;
 }
 
@@ -820,8 +822,6 @@ bool HTMLElementImpl::setOuterHTML( const DOMString &html )
     
     int ec = 0;
     parentNode()->replaceChild(fragment, this, ec);
-    fragment->ref();
-    fragment->deref();
     return !ec;
 }
 
index 9607e14..cad95fe 100644 (file)
 namespace DOM {
 
 class DOMString;
-class CSSStyleDeclarationImpl;
 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)
-    : CSSStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
+    : CSSMutableStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
     {}
     
     virtual ~CSSMappedAttributeDeclarationImpl();
@@ -168,9 +167,9 @@ public:
 
     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);
@@ -190,7 +189,7 @@ protected:
     // for IMG, OBJECT and APPLET
     void addHTMLAlignment(HTMLAttributeImpl* htmlAttr);
 
-    CSSStyleDeclarationImpl* m_inlineStyleDecl;
+    CSSMutableStyleDeclarationImpl* m_inlineStyleDecl;
 };
 
 class HTMLGenericElementImpl : public HTMLElementImpl
index af65769..e205366 100644 (file)
@@ -544,7 +544,7 @@ void HTMLTableElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     }
 }
 
-CSSStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
 {
     if (m_noBorder)
         return 0;
@@ -572,7 +572,7 @@ CSSStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDecl()
     return decl;
 }
 
-CSSStyleDeclarationImpl* HTMLTableElementImpl::getSharedCellDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::getSharedCellDecl()
 {
     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.
-CSSStyleDeclarationImpl* HTMLTableCellElementImpl::additionalAttributeStyleDecl()
+CSSMutableStyleDeclarationImpl* HTMLTableCellElementImpl::additionalAttributeStyleDecl()
 {
     HTMLElementImpl* p = static_cast<HTMLElementImpl*>(parentNode());
     while(p && p->id() != ID_TABLE)
index 19e1551..221ee6a 100644 (file)
@@ -102,8 +102,8 @@ public:
     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();
     
@@ -212,7 +212,7 @@ public:
     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;
 
index f9046b0..9a1bea8 100644 (file)
@@ -248,6 +248,8 @@ void KHTMLParser::parseToken(Token *t)
     if(!n)
         return;
 
+    Node protectNode(n);
+
     // set attributes
     if(n->isElementNode())
     {
@@ -299,7 +301,6 @@ void KHTMLParser::parseToken(Token *t)
 #endif
             form = 0;
         }
-        delete n;
     }
 }
 
@@ -311,6 +312,8 @@ static bool isTableRelatedTag(int id)
 
 bool KHTMLParser::insertNode(NodeImpl *n, bool flat)
 {
+    Node protectNode(n);
+
     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
-        delete head;
         head = 0;
     }
 }
index 13cfc82..5299b13 100644 (file)
@@ -5040,7 +5040,7 @@ CSSMutableStyleDeclarationImpl *KHTMLPart::typingStyle() const
     return d->m_typingStyle;
 }
 
-void KHTMLPart::setTypingStyle(CSSStyleDeclarationImpl *style)
+void KHTMLPart::setTypingStyle(CSSMutableStyleDeclarationImpl *style)
 {
     if (d->m_typingStyle == style)
         return;
@@ -5330,18 +5330,21 @@ void KHTMLPart::applyStyle(CSSStyleDeclarationImpl *style)
             break;
         case Selection::CARET: {
             // Calculate the current typing style.
+            CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
+            mutableStyle->ref();
             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());
-            computedStyle.diff(style);
+            computedStyle.diff(mutableStyle);
             
             // Handle block styles, substracting these from the typing style.
-            CSSStyleDeclarationImpl *blockStyle = style->copyBlockProperties();
+            CSSMutableStyleDeclarationImpl *blockStyle = mutableStyle->copyBlockProperties();
             blockStyle->ref();
-            blockStyle->diff(style);
+            blockStyle->diff(mutableStyle);
             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.
-            setTypingStyle(style);
-            style->deref();
+            setTypingStyle(mutableStyle);
+            mutableStyle->deref();
             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)
 {
-    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
@@ -5385,7 +5389,7 @@ KHTMLPart::TriState KHTMLPart::selectionHasStyle(CSSStyleDeclarationImpl *style)
     bool atStart = true;
     TriState state = falseTriState;
 
-    CSSMutableStyleDeclarationImpl *mutableStyle = style;
+    CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
     CSSStyleDeclaration protectQueryStyle(mutableStyle);
 
     if (!d->m_selection.isRange()) {
@@ -5426,15 +5430,16 @@ bool KHTMLPart::selectionStartHasStyle(CSSStyleDeclarationImpl *style) const
     if (!selectionStyle)
         return false;
 
-    CSSMutableStyleDeclarationImpl *mutableStyle = style;
+    CSSMutableStyleDeclarationImpl *mutableStyle = style->makeMutable();
 
     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;
@@ -5511,15 +5516,13 @@ CSSComputedStyleDeclarationImpl *KHTMLPart::selectionComputedStyle(NodeImpl *&no
     return new CSSComputedStyleDeclarationImpl(styleElement);
 }
 
-static CSSStyleDeclarationImpl *editingStyle()
+static CSSMutableStyleDeclarationImpl *editingStyle()
 {
-    static CSSStyleDeclarationImpl *editingStyle = 0;
+    static CSSMutableStyleDeclarationImpl *editingStyle = 0;
     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;
 }
@@ -5561,8 +5564,8 @@ void KHTMLPart::applyEditingStyleToElement(ElementImpl *element) const
     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());
@@ -5578,11 +5581,14 @@ void KHTMLPart::removeEditingStyleFromElement(ElementImpl *element) const
     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());
 }
 
index 11d38e5..d0cce4d 100644 (file)
@@ -42,8 +42,8 @@ class KJavaAppletContext;
 namespace DOM
 {
   class CSSComputedStyleDeclarationImpl;
+  class CSSMutableStyleDeclarationImpl;
   class CSSStyleDeclarationImpl;
-  typedef CSSStyleDeclarationImpl CSSMutableStyleDeclarationImpl;
   class DOMString;
   class Document;
   class DocumentImpl;
@@ -715,7 +715,7 @@ public:
   /**
    * Sets the typing style for the document.
    */
-  void setTypingStyle(DOM::CSSStyleDeclarationImpl *);
+  void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 
   /**
    * Clears the typing style for the document.
index 77e40f3..954b27f 100644 (file)
@@ -520,9 +520,7 @@ EditingTextImpl *DocumentImpl::createEditingTextNode(const DOMString &text)
 
 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)
index 4fdd90d..17416bb 100644 (file)
@@ -160,14 +160,18 @@ NodeImpl *NodeImpl::lastChild() const
   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;
 }
 
-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;
 }
@@ -178,10 +182,12 @@ NodeImpl *NodeImpl::removeChild( NodeImpl *, int &exceptioncode )
   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)
@@ -1607,6 +1613,8 @@ NodeImpl *NodeBaseImpl::insertBefore ( NodeImpl *newChild, NodeImpl *refChild, i
     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)
@@ -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())
-        return newChild;
+        return (newChild->hasOneRef() && !newChild->parent()) ? 0 : newChild;
 
     // Now actually add the child(ren)
     NodeImpl *nextChild;
@@ -1674,6 +1682,8 @@ NodeImpl *NodeBaseImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, i
 {
     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;
     
@@ -1692,7 +1702,6 @@ NodeImpl *NodeBaseImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, i
     NodeImpl *nextChild;
     NodeImpl *child = isFragment ? newChild->firstChild() : newChild;
 
-
     // 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;
 
+    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)
@@ -1951,6 +1962,8 @@ NodeImpl *NodeBaseImpl::addChild(NodeImpl *newChild)
 {
     // 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))
     {
index 58e3d4a..c8c99b1 100644 (file)
@@ -787,7 +787,9 @@ static inline int getPropertyID(NSString *string)
 
 - (void)setCssText:(NSString *)cssText
 {
-    [self _styleDeclarationImpl]->setCssText(cssText);
+    int exceptionCode;
+    [self _styleDeclarationImpl]->setCssText(cssText, exceptionCode);
+    raiseOnDOMError(exceptionCode);
 }
 
 - (NSString *)getPropertyValue:(NSString *)propertyName
@@ -811,7 +813,10 @@ static inline int getPropertyID(NSString *string)
     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
@@ -831,7 +836,9 @@ static inline int getPropertyID(NSString *string)
     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