Refactor the DOM so that the concept of class/style/id is no longer unique to HTML...
authorhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 May 2005 05:49:35 +0000 (05:49 +0000)
committerhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 May 2005 05:49:35 +0000 (05:49 +0000)
for SVG and MathML elements to also support these capabilities.  In addition the concept of presentational
attributes has also been factored out.

        Reviewed by mjs

        * khtml/css/css_ruleimpl.cpp:
        (CSSStyleRuleImpl::setDeclaration):
        * khtml/css/cssstyleselector.cpp:
        (khtml::parseUASheet):
        (khtml::CSSStyleSelector::loadDefaultStyle):
        (khtml::CSSStyleSelector::initElementAndPseudoState):
        (khtml::CSSStyleSelector::canShareStyleWithElement):
        (khtml::CSSStyleSelector::locateSharedStyle):
        (khtml::CSSStyleSelector::styleForElement):
        (khtml::CSSStyleSelector::checkOneSelector):
        * khtml/css/cssstyleselector.h:
        * khtml/html/html_baseimpl.cpp:
        (HTMLBodyElementImpl::parseMappedAttribute):
        (HTMLFrameElementImpl::parseMappedAttribute):
        (HTMLFrameSetElementImpl::parseMappedAttribute):
        (HTMLIFrameElementImpl::parseMappedAttribute):
        * khtml/html/html_baseimpl.h:
        * khtml/html/html_blockimpl.cpp:
        (HTMLDivElementImpl::parseMappedAttribute):
        (HTMLHRElementImpl::parseMappedAttribute):
        (HTMLParagraphElementImpl::parseMappedAttribute):
        (HTMLMarqueeElementImpl::parseMappedAttribute):
        * khtml/html/html_blockimpl.h:
        * khtml/html/html_canvasimpl.cpp:
        (HTMLCanvasElementImpl::parseMappedAttribute):
        * khtml/html/html_canvasimpl.h:
        * khtml/html/html_elementimpl.cpp:
        (HTMLElementImpl::HTMLElementImpl):
        (HTMLElementImpl::~HTMLElementImpl):
        (HTMLElementImpl::mapToEntry):
        (HTMLElementImpl::parseMappedAttribute):
        (HTMLElementImpl::addHTMLAlignment):
        (HTMLElementImpl::setContentEditable):
        (HTMLElementImpl::toString):
        * khtml/html/html_elementimpl.h:
        * khtml/html/html_formimpl.cpp:
        (DOM::HTMLFormElementImpl::parseMappedAttribute):
        (DOM::HTMLGenericFormElementImpl::parseMappedAttribute):
        (DOM::HTMLButtonElementImpl::parseMappedAttribute):
        (DOM::HTMLInputElementImpl::setType):
        (DOM::HTMLInputElementImpl::parseMappedAttribute):
        (DOM::HTMLLabelElementImpl::parseMappedAttribute):
        (DOM::HTMLSelectElementImpl::parseMappedAttribute):
        (DOM::HTMLKeygenElementImpl::parseMappedAttribute):
        (DOM::HTMLOptGroupElementImpl::parseMappedAttribute):
        (DOM::HTMLOptionElementImpl::parseMappedAttribute):
        (DOM::HTMLTextAreaElementImpl::parseMappedAttribute):
        (DOM::HTMLIsIndexElementImpl::parseMappedAttribute):
        * khtml/html/html_formimpl.h:
        * khtml/html/html_headimpl.cpp:
        (HTMLBaseElementImpl::parseMappedAttribute):
        (HTMLLinkElementImpl::parseMappedAttribute):
        (HTMLMetaElementImpl::parseMappedAttribute):
        (HTMLStyleElementImpl::parseMappedAttribute):
        * khtml/html/html_headimpl.h:
        * khtml/html/html_imageimpl.cpp:
        (HTMLImageElementImpl::parseMappedAttribute):
        (HTMLMapElementImpl::parseMappedAttribute):
        (HTMLAreaElementImpl::parseMappedAttribute):
        * khtml/html/html_imageimpl.h:
        * khtml/html/html_inlineimpl.cpp:
        (DOM::HTMLAnchorElementImpl::parseMappedAttribute):
        (DOM::HTMLBRElementImpl::parseMappedAttribute):
        (DOM::HTMLFontElementImpl::parseMappedAttribute):
        * khtml/html/html_inlineimpl.h:
        * khtml/html/html_listimpl.cpp:
        (DOM::HTMLUListElementImpl::parseMappedAttribute):
        (DOM::HTMLOListElementImpl::parseMappedAttribute):
        (DOM::HTMLLIElementImpl::parseMappedAttribute):
        * khtml/html/html_listimpl.h:
        * khtml/html/html_objectimpl.cpp:
        (DOM::HTMLAppletElementImpl::parseMappedAttribute):
        (DOM::HTMLEmbedElementImpl::parseMappedAttribute):
        (DOM::HTMLObjectElementImpl::parseMappedAttribute):
        (DOM::HTMLParamElementImpl::parseMappedAttribute):
        * khtml/html/html_objectimpl.h:
        * khtml/html/html_tableimpl.cpp:
        (DOM::HTMLTableElementImpl::parseMappedAttribute):
        (DOM::HTMLTableElementImpl::additionalAttributeStyleDecl):
        (DOM::HTMLTableElementImpl::getSharedCellDecl):
        (DOM::HTMLTablePartElementImpl::parseMappedAttribute):
        (DOM::HTMLTableCellElementImpl::parseMappedAttribute):
        (DOM::HTMLTableColElementImpl::parseMappedAttribute):
        (DOM::HTMLTableCaptionElementImpl::parseMappedAttribute):
        * khtml/html/html_tableimpl.h:
        * khtml/html/htmltokenizer.h:
        (khtml::Token::addAttribute):
        * khtml/misc/htmlattrs.in:
        * khtml/misc/htmltags.in:
        * khtml/xml/dom_docimpl.cpp:
        (DocumentImpl::createAttribute):
        (DocumentImpl::createElementNS):
        (DocumentImpl::createHTMLElement):
        * khtml/xml/dom_elementimpl.cpp:
        (XMLElementImpl::cloneNode):
        (NamedAttrMapImpl::isMappedAttributeMap):
        (CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl):
        (StyledElementImpl::getMappedAttributeDecl):
        (StyledElementImpl::setMappedAttributeDecl):
        (StyledElementImpl::removeMappedAttributeDecl):
        (StyledElementImpl::invalidateStyleAttribute):
        (StyledElementImpl::updateStyleAttributeIfNeeded):
        (MappedAttributeImpl::~MappedAttributeImpl):
        (MappedAttributeImpl::clone):
        (m_mappedAttributeCount):
        (NamedMappedAttrMapImpl::clearAttributes):
        (NamedMappedAttrMapImpl::isMappedAttributeMap):
        (NamedMappedAttrMapImpl::declCount):
        (NamedMappedAttrMapImpl::mapsEquivalent):
        (NamedMappedAttrMapImpl::parseClassAttribute):
        (StyledElementImpl::StyledElementImpl):
        (StyledElementImpl::~StyledElementImpl):
        (StyledElementImpl::createAttribute):
        (StyledElementImpl::createInlineStyleDecl):
        (StyledElementImpl::destroyInlineStyleDecl):
        (StyledElementImpl::attributeChanged):
        (StyledElementImpl::mapToEntry):
        (StyledElementImpl::parseMappedAttribute):
        (StyledElementImpl::createAttributeMap):
        (StyledElementImpl::getInlineStyleDecl):
        (StyledElementImpl::style):
        (StyledElementImpl::additionalAttributeStyleDecl):
        (StyledElementImpl::getClassList):
        (isHexDigit):
        (toHex):
        (StyledElementImpl::addCSSProperty):
        (StyledElementImpl::addCSSStringProperty):
        (StyledElementImpl::addCSSImageProperty):
        (StyledElementImpl::addCSSLength):
        (StyledElementImpl::addCSSColor):
        (StyledElementImpl::createMappedDecl):
        * khtml/xml/dom_elementimpl.h:
        (DOM::):
        (DOM::CSSMappedAttributeDeclarationImpl::CSSMappedAttributeDeclarationImpl):
        (DOM::CSSMappedAttributeDeclarationImpl::setMappedState):
        (DOM::MappedAttributeImpl::MappedAttributeImpl):
        (DOM::MappedAttributeImpl::decl):
        (DOM::MappedAttributeImpl::setDecl):
        (DOM::NamedMappedAttrMapImpl::getClassList):
        (DOM::NamedMappedAttrMapImpl::hasMappedAttributes):
        (DOM::NamedMappedAttrMapImpl::declRemoved):
        (DOM::NamedMappedAttrMapImpl::declAdded):
        (DOM::NamedMappedAttrMapImpl::attributeItem):
        (DOM::StyledElementImpl::isStyledElement):
        (DOM::StyledElementImpl::hasMappedAttributes):
        (DOM::StyledElementImpl::mappedAttributes):
        (DOM::StyledElementImpl::isMappedAttribute):
        (DOM::StyledElementImpl::inlineStyleDecl):
        * khtml/xml/dom_nodeimpl.h:
        (DOM::NodeImpl::isStyledElement):

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

33 files changed:
WebCore/ChangeLog-2005-08-23
WebCore/khtml/css/css_ruleimpl.cpp
WebCore/khtml/css/cssstyleselector.cpp
WebCore/khtml/css/cssstyleselector.h
WebCore/khtml/html/html_baseimpl.cpp
WebCore/khtml/html/html_baseimpl.h
WebCore/khtml/html/html_blockimpl.cpp
WebCore/khtml/html/html_blockimpl.h
WebCore/khtml/html/html_canvasimpl.cpp
WebCore/khtml/html/html_canvasimpl.h
WebCore/khtml/html/html_elementimpl.cpp
WebCore/khtml/html/html_elementimpl.h
WebCore/khtml/html/html_formimpl.cpp
WebCore/khtml/html/html_formimpl.h
WebCore/khtml/html/html_headimpl.cpp
WebCore/khtml/html/html_headimpl.h
WebCore/khtml/html/html_imageimpl.cpp
WebCore/khtml/html/html_imageimpl.h
WebCore/khtml/html/html_inlineimpl.cpp
WebCore/khtml/html/html_inlineimpl.h
WebCore/khtml/html/html_listimpl.cpp
WebCore/khtml/html/html_listimpl.h
WebCore/khtml/html/html_objectimpl.cpp
WebCore/khtml/html/html_objectimpl.h
WebCore/khtml/html/html_tableimpl.cpp
WebCore/khtml/html/html_tableimpl.h
WebCore/khtml/html/htmltokenizer.h
WebCore/khtml/misc/htmlattrs.in
WebCore/khtml/misc/htmltags.in
WebCore/khtml/xml/dom_docimpl.cpp
WebCore/khtml/xml/dom_elementimpl.cpp
WebCore/khtml/xml/dom_elementimpl.h
WebCore/khtml/xml/dom_nodeimpl.h

index c5183a9970bed94732a03e7eb535d6b6a221af1e..5c3a10a87bbed36ab61229f759fe1fc8e6d0dc3b 100644 (file)
@@ -1,3 +1,162 @@
+2005-05-10  David Hyatt  <hyatt@apple.com>
+
+       Refactor the DOM so that the concept of class/style/id is no longer unique to HTML elements.  This paves the way
+       for SVG and MathML elements to also support these capabilities.  In addition the concept of presentational
+       attributes has also been factored out.
+       
+        Reviewed by mjs
+
+        * khtml/css/css_ruleimpl.cpp:
+        (CSSStyleRuleImpl::setDeclaration):
+        * khtml/css/cssstyleselector.cpp:
+        (khtml::parseUASheet):
+        (khtml::CSSStyleSelector::loadDefaultStyle):
+        (khtml::CSSStyleSelector::initElementAndPseudoState):
+        (khtml::CSSStyleSelector::canShareStyleWithElement):
+        (khtml::CSSStyleSelector::locateSharedStyle):
+        (khtml::CSSStyleSelector::styleForElement):
+        (khtml::CSSStyleSelector::checkOneSelector):
+        * khtml/css/cssstyleselector.h:
+        * khtml/html/html_baseimpl.cpp:
+        (HTMLBodyElementImpl::parseMappedAttribute):
+        (HTMLFrameElementImpl::parseMappedAttribute):
+        (HTMLFrameSetElementImpl::parseMappedAttribute):
+        (HTMLIFrameElementImpl::parseMappedAttribute):
+        * khtml/html/html_baseimpl.h:
+        * khtml/html/html_blockimpl.cpp:
+        (HTMLDivElementImpl::parseMappedAttribute):
+        (HTMLHRElementImpl::parseMappedAttribute):
+        (HTMLParagraphElementImpl::parseMappedAttribute):
+        (HTMLMarqueeElementImpl::parseMappedAttribute):
+        * khtml/html/html_blockimpl.h:
+        * khtml/html/html_canvasimpl.cpp:
+        (HTMLCanvasElementImpl::parseMappedAttribute):
+        * khtml/html/html_canvasimpl.h:
+        * khtml/html/html_elementimpl.cpp:
+        (HTMLElementImpl::HTMLElementImpl):
+        (HTMLElementImpl::~HTMLElementImpl):
+        (HTMLElementImpl::mapToEntry):
+        (HTMLElementImpl::parseMappedAttribute):
+        (HTMLElementImpl::addHTMLAlignment):
+        (HTMLElementImpl::setContentEditable):
+        (HTMLElementImpl::toString):
+        * khtml/html/html_elementimpl.h:
+        * khtml/html/html_formimpl.cpp:
+        (DOM::HTMLFormElementImpl::parseMappedAttribute):
+        (DOM::HTMLGenericFormElementImpl::parseMappedAttribute):
+        (DOM::HTMLButtonElementImpl::parseMappedAttribute):
+        (DOM::HTMLInputElementImpl::setType):
+        (DOM::HTMLInputElementImpl::parseMappedAttribute):
+        (DOM::HTMLLabelElementImpl::parseMappedAttribute):
+        (DOM::HTMLSelectElementImpl::parseMappedAttribute):
+        (DOM::HTMLKeygenElementImpl::parseMappedAttribute):
+        (DOM::HTMLOptGroupElementImpl::parseMappedAttribute):
+        (DOM::HTMLOptionElementImpl::parseMappedAttribute):
+        (DOM::HTMLTextAreaElementImpl::parseMappedAttribute):
+        (DOM::HTMLIsIndexElementImpl::parseMappedAttribute):
+        * khtml/html/html_formimpl.h:
+        * khtml/html/html_headimpl.cpp:
+        (HTMLBaseElementImpl::parseMappedAttribute):
+        (HTMLLinkElementImpl::parseMappedAttribute):
+        (HTMLMetaElementImpl::parseMappedAttribute):
+        (HTMLStyleElementImpl::parseMappedAttribute):
+        * khtml/html/html_headimpl.h:
+        * khtml/html/html_imageimpl.cpp:
+        (HTMLImageElementImpl::parseMappedAttribute):
+        (HTMLMapElementImpl::parseMappedAttribute):
+        (HTMLAreaElementImpl::parseMappedAttribute):
+        * khtml/html/html_imageimpl.h:
+        * khtml/html/html_inlineimpl.cpp:
+        (DOM::HTMLAnchorElementImpl::parseMappedAttribute):
+        (DOM::HTMLBRElementImpl::parseMappedAttribute):
+        (DOM::HTMLFontElementImpl::parseMappedAttribute):
+        * khtml/html/html_inlineimpl.h:
+        * khtml/html/html_listimpl.cpp:
+        (DOM::HTMLUListElementImpl::parseMappedAttribute):
+        (DOM::HTMLOListElementImpl::parseMappedAttribute):
+        (DOM::HTMLLIElementImpl::parseMappedAttribute):
+        * khtml/html/html_listimpl.h:
+        * khtml/html/html_objectimpl.cpp:
+        (DOM::HTMLAppletElementImpl::parseMappedAttribute):
+        (DOM::HTMLEmbedElementImpl::parseMappedAttribute):
+        (DOM::HTMLObjectElementImpl::parseMappedAttribute):
+        (DOM::HTMLParamElementImpl::parseMappedAttribute):
+        * khtml/html/html_objectimpl.h:
+        * khtml/html/html_tableimpl.cpp:
+        (DOM::HTMLTableElementImpl::parseMappedAttribute):
+        (DOM::HTMLTableElementImpl::additionalAttributeStyleDecl):
+        (DOM::HTMLTableElementImpl::getSharedCellDecl):
+        (DOM::HTMLTablePartElementImpl::parseMappedAttribute):
+        (DOM::HTMLTableCellElementImpl::parseMappedAttribute):
+        (DOM::HTMLTableColElementImpl::parseMappedAttribute):
+        (DOM::HTMLTableCaptionElementImpl::parseMappedAttribute):
+        * khtml/html/html_tableimpl.h:
+        * khtml/html/htmltokenizer.h:
+        (khtml::Token::addAttribute):
+        * khtml/misc/htmlattrs.in:
+        * khtml/misc/htmltags.in:
+        * khtml/xml/dom_docimpl.cpp:
+        (DocumentImpl::createAttribute):
+        (DocumentImpl::createElementNS):
+        (DocumentImpl::createHTMLElement):
+        * khtml/xml/dom_elementimpl.cpp:
+        (XMLElementImpl::cloneNode):
+        (NamedAttrMapImpl::isMappedAttributeMap):
+        (CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl):
+        (StyledElementImpl::getMappedAttributeDecl):
+        (StyledElementImpl::setMappedAttributeDecl):
+        (StyledElementImpl::removeMappedAttributeDecl):
+        (StyledElementImpl::invalidateStyleAttribute):
+        (StyledElementImpl::updateStyleAttributeIfNeeded):
+        (MappedAttributeImpl::~MappedAttributeImpl):
+        (MappedAttributeImpl::clone):
+        (m_mappedAttributeCount):
+        (NamedMappedAttrMapImpl::clearAttributes):
+        (NamedMappedAttrMapImpl::isMappedAttributeMap):
+        (NamedMappedAttrMapImpl::declCount):
+        (NamedMappedAttrMapImpl::mapsEquivalent):
+        (NamedMappedAttrMapImpl::parseClassAttribute):
+        (StyledElementImpl::StyledElementImpl):
+        (StyledElementImpl::~StyledElementImpl):
+        (StyledElementImpl::createAttribute):
+        (StyledElementImpl::createInlineStyleDecl):
+        (StyledElementImpl::destroyInlineStyleDecl):
+        (StyledElementImpl::attributeChanged):
+        (StyledElementImpl::mapToEntry):
+        (StyledElementImpl::parseMappedAttribute):
+        (StyledElementImpl::createAttributeMap):
+        (StyledElementImpl::getInlineStyleDecl):
+        (StyledElementImpl::style):
+        (StyledElementImpl::additionalAttributeStyleDecl):
+        (StyledElementImpl::getClassList):
+        (isHexDigit):
+        (toHex):
+        (StyledElementImpl::addCSSProperty):
+        (StyledElementImpl::addCSSStringProperty):
+        (StyledElementImpl::addCSSImageProperty):
+        (StyledElementImpl::addCSSLength):
+        (StyledElementImpl::addCSSColor):
+        (StyledElementImpl::createMappedDecl):
+        * khtml/xml/dom_elementimpl.h:
+        (DOM::):
+        (DOM::CSSMappedAttributeDeclarationImpl::CSSMappedAttributeDeclarationImpl):
+        (DOM::CSSMappedAttributeDeclarationImpl::setMappedState):
+        (DOM::MappedAttributeImpl::MappedAttributeImpl):
+        (DOM::MappedAttributeImpl::decl):
+        (DOM::MappedAttributeImpl::setDecl):
+        (DOM::NamedMappedAttrMapImpl::getClassList):
+        (DOM::NamedMappedAttrMapImpl::hasMappedAttributes):
+        (DOM::NamedMappedAttrMapImpl::declRemoved):
+        (DOM::NamedMappedAttrMapImpl::declAdded):
+        (DOM::NamedMappedAttrMapImpl::attributeItem):
+        (DOM::StyledElementImpl::isStyledElement):
+        (DOM::StyledElementImpl::hasMappedAttributes):
+        (DOM::StyledElementImpl::mappedAttributes):
+        (DOM::StyledElementImpl::isMappedAttribute):
+        (DOM::StyledElementImpl::inlineStyleDecl):
+        * khtml/xml/dom_nodeimpl.h:
+        (DOM::NodeImpl::isStyledElement):
+
 2005-05-10  Darin Adler  <darin@apple.com>
 
         Reviewed by Dave Hyatt.
index 3a5d295b9eab44bab7a1243c3689e4f90ff1ae61..84c95b105428223edd793e1ecbbf3021085997ae 100644 (file)
@@ -354,9 +354,11 @@ bool CSSStyleRuleImpl::parseString( const DOMString &/*string*/, bool )
 void CSSStyleRuleImpl::setDeclaration( CSSMutableStyleDeclarationImpl *style)
 {
     if ( m_style != style ) {
-        if(m_style) m_style->deref();
+        if (m_style)
+            m_style->deref();
         m_style = style;
-        if(m_style) m_style->ref();
+        if (m_style)
+            m_style->ref();
     }
 }
 
index 6861063eb9600f208a8b72a792c537d88f37033a..0b3331d95061500fe93ae14bef10004e1c715b5c 100644 (file)
@@ -269,57 +269,43 @@ CSSStyleSelector::~CSSStyleSelector()
     delete m_userSheet;
 }
 
+static CSSStyleSheetImpl* parseUASheet(const KHTMLSettings* s, const char* sheetName)
+{
+    QFile f(locate( "data", sheetName));
+    f.open(IO_ReadOnly);
+
+    QCString file(f.size() + 1);
+    int readbytes = f.readBlock(file.data(), f.size());
+    f.close();
+    if (readbytes >= 0)
+        file[readbytes] = '\0';
+
+    QString style = QString::fromLatin1(file.data());
+    if (s)
+        style += s->settingsToCSS();
+    DOMString str(style);
+
+    CSSStyleSheetImpl* sheet = new DOM::CSSStyleSheetImpl((DOM::CSSStyleSheetImpl*)0);
+    sheet->parseString(str);
+    return sheet;
+}
+
 void CSSStyleSelector::loadDefaultStyle(const KHTMLSettings *s)
 {
     if(defaultStyle) return;
+    defaultSheet = parseUASheet(s, "khtml/css/html4.css");
 
-    {
-        QFile f(locate( "data", "khtml/css/html4.css" ) );
-        f.open(IO_ReadOnly);
-
-        QCString file( f.size()+1 );
-        int readbytes = f.readBlock( file.data(), f.size() );
-        f.close();
-        if ( readbytes >= 0 )
-            file[readbytes] = '\0';
-
-        QString style = QString::fromLatin1( file.data() );
-        if(s)
-            style += s->settingsToCSS();
-        DOMString str(style);
-
-        defaultSheet = new DOM::CSSStyleSheetImpl((DOM::CSSStyleSheetImpl * ) 0);
-        defaultSheet->parseString( str );
-
-        // Collect only strict-mode rules.
-        defaultStyle = new CSSRuleSet();
-        defaultStyle->addRulesFromSheet( defaultSheet, "screen" );
-        
-        defaultPrintStyle = new CSSRuleSet();
-        defaultPrintStyle->addRulesFromSheet( defaultSheet, "print" );
-    }
-    {
-        QFile f(locate( "data", "khtml/css/quirks.css" ) );
-        f.open(IO_ReadOnly);
-
-        QCString file( f.size()+1 );
-        int readbytes = f.readBlock( file.data(), f.size() );
-        f.close();
-        if ( readbytes >= 0 )
-            file[readbytes] = '\0';
-
-        QString style = QString::fromLatin1( file.data() );
-        DOMString str(style);
+    // Collect only strict-mode rules.
+    defaultStyle = new CSSRuleSet();
+    defaultStyle->addRulesFromSheet(defaultSheet, "screen");
 
-        quirksSheet = new DOM::CSSStyleSheetImpl((DOM::CSSStyleSheetImpl * ) 0);
-        quirksSheet->parseString( str );
-
-        // Collect only quirks-mode rules.
-        defaultQuirksStyle = new CSSRuleSet();
-        defaultQuirksStyle->addRulesFromSheet( quirksSheet, "screen" );
-    }
+    defaultPrintStyle = new CSSRuleSet();
+    defaultPrintStyle->addRulesFromSheet(defaultSheet, "print");
 
-    //kdDebug() << "CSSStyleSelector: default style has " << defaultStyle->count() << " elements"<< endl;
+    // Collect only quirks-mode rules.
+    quirksSheet = parseUASheet(0, "khtml/css/quirks.css");
+    defaultQuirksStyle = new CSSRuleSet();
+    defaultQuirksStyle->addRulesFromSheet(quirksSheet, "screen");
 }
 
 void CSSStyleSelector::addMatchedRule(CSSRuleData* rule)
@@ -478,10 +464,10 @@ void CSSStyleSelector::sortMatchedRules(uint start, uint end)
 void CSSStyleSelector::initElementAndPseudoState(ElementImpl* e)
 {
     element = e;
-    if (element && element->isHTMLElement())
-        htmlElement = static_cast<HTMLElementImpl*>(element);
+    if (element && element->isStyledElement())
+        styledElement = static_cast<StyledElementImpl*>(element);
     else
-        htmlElement = 0;
+        styledElement = 0;
     ::encodedurl = &encodedurl;
     pseudoState = PseudoUnknown;
 }
@@ -620,12 +606,12 @@ NodeImpl* CSSStyleSelector::locateCousinList(ElementImpl* parent)
 
 bool CSSStyleSelector::canShareStyleWithElement(NodeImpl* n)
 {
-    if (n->isHTMLElement()) {
+    if (n->isStyledElement()) {
         bool mouseInside = element->renderer() ? element->renderer()->mouseInside() : false;
-        HTMLElementImpl* s = static_cast<HTMLElementImpl*>(n);
+        StyledElementImpl* s = static_cast<StyledElementImpl*>(n);
         if (s->renderer() && (s->id() == element->id()) && !s->hasID() &&
             (s->hasClass() == element->hasClass()) && !s->inlineStyleDecl() &&
-            (s->hasMappedAttributes() == htmlElement->hasMappedAttributes()) &&
+            (s->hasMappedAttributes() == styledElement->hasMappedAttributes()) &&
             (s->isLink() == element->isLink()) && 
             !s->renderer()->style()->affectedByAttributeSelectors() &&
             (s->renderer()->mouseInside() == mouseInside) &&
@@ -641,7 +627,7 @@ bool CSSStyleSelector::canShareStyleWithElement(NodeImpl* n)
             if (classesMatch) {
                 bool mappedAttrsMatch = true;
                 if (s->hasMappedAttributes())
-                    mappedAttrsMatch = s->htmlAttributes()->mapsEquivalent(htmlElement->htmlAttributes());
+                    mappedAttrsMatch = s->mappedAttributes()->mapsEquivalent(styledElement->mappedAttributes());
                 if (mappedAttrsMatch) {
                     bool linksMatch = true;
                     if (s->isLink()) {
@@ -665,8 +651,8 @@ bool CSSStyleSelector::canShareStyleWithElement(NodeImpl* n)
 
 RenderStyle* CSSStyleSelector::locateSharedStyle()
 {
-    if (htmlElement && !htmlElement->inlineStyleDecl() && !htmlElement->hasID() &&
-        !htmlElement->getDocument()->usesSiblingRules()) {
+    if (styledElement && !styledElement->inlineStyleDecl() && !styledElement->hasID() &&
+        !styledElement->getDocument()->usesSiblingRules()) {
         // Check previous siblings.
         int count = 0;
         DOM::NodeImpl* n;
@@ -741,13 +727,13 @@ RenderStyle* CSSStyleSelector::styleForElement(ElementImpl* e, RenderStyle* defa
     // 5. Now check author rules, beginning first with presentational attributes
     // mapped from HTML.
     int firstAuthorRule = -1, lastAuthorRule = -1;
-    if (htmlElement) {
+    if (styledElement) {
         // Ask if the HTML element has mapped attributes.
-        if (htmlElement->hasMappedAttributes()) {
+        if (styledElement->hasMappedAttributes()) {
             // Walk our attribute list and add in each decl.
-            const HTMLNamedAttrMapImpl* map = htmlElement->htmlAttributes();
+            const NamedMappedAttrMapImpl* map = styledElement->mappedAttributes();
             for (uint i = 0; i < map->length(); i++) {
-                HTMLAttributeImpl* attr = map->attributeItem(i);
+                MappedAttributeImpl* attr = map->attributeItem(i);
                 if (attr->decl()) {
                     if (firstAuthorRule == -1) firstAuthorRule = m_matchedDeclCount;
                     lastAuthorRule = m_matchedDeclCount;
@@ -759,7 +745,7 @@ RenderStyle* CSSStyleSelector::styleForElement(ElementImpl* e, RenderStyle* defa
         // Now we check additional mapped declarations.
         // Tables and table cells share an additional mapped rule that must be applied
         // after all attributes, since their mapped style depends on the values of multiple attributes.
-        CSSMutableStyleDeclarationImpl* attributeDecl = htmlElement->additionalAttributeStyleDecl();
+        CSSMutableStyleDeclarationImpl* attributeDecl = styledElement->additionalAttributeStyleDecl();
         if (attributeDecl) {
             if (firstAuthorRule == -1) firstAuthorRule = m_matchedDeclCount;
             lastAuthorRule = m_matchedDeclCount;
@@ -771,8 +757,8 @@ RenderStyle* CSSStyleSelector::styleForElement(ElementImpl* e, RenderStyle* defa
     matchRules(m_authorStyle, firstAuthorRule, lastAuthorRule);
     
     // 7. Now check our inline style attribute.
-    if (htmlElement) {
-        CSSMutableStyleDeclarationImpl* inlineDecl = htmlElement->inlineStyleDecl();
+    if (styledElement) {
+        CSSMutableStyleDeclarationImpl* inlineDecl = styledElement->inlineStyleDecl();
         if (inlineDecl) {
             if (firstAuthorRule == -1) firstAuthorRule = m_matchedDeclCount;
             lastAuthorRule = m_matchedDeclCount;
@@ -1122,7 +1108,7 @@ bool CSSStyleSelector::checkOneSelector(DOM::CSSSelector *sel, DOM::ElementImpl
         }
         else if (sel->match == CSSSelector::Id)
             return e->hasID() && e->getIDAttribute() == sel->value;
-        else if (style && (e != element || !htmlElement || !htmlElement->isMappedAttribute(sel->attr)))
+        else if (style && (e != element || !styledElement || !styledElement->isMappedAttribute(sel->attr)))
             style->setAffectedByAttributeSelectors();
 
         const AtomicString& value = e->getAttribute(sel->attr);
index b716bac6dc05f5f0f38a46045c90be7edf3fe0ad..adca421a4799b992eee7379d89266bdc99d91279 100644 (file)
@@ -40,7 +40,7 @@ namespace DOM {
     class DocumentImpl;
     class NodeImpl;
     class ElementImpl;
-    class HTMLElementImpl;
+    class StyledElementImpl;
     class StyleSheetImpl;
     class CSSStyleSheetImpl;
     class CSSSelector;
@@ -211,7 +211,7 @@ public:
        RenderStyle *style;
        RenderStyle *parentStyle;
        DOM::ElementImpl *element;
-        DOM::HTMLElementImpl *htmlElement;
+        DOM::StyledElementImpl *styledElement;
        DOM::NodeImpl *parentNode;
         RenderStyle::PseudoId pseudoStyle;
        KHTMLView *view;
index 488060c313f6d30370c0c924a7722c96db1cc450..6aaa5f1e9e60a6c9e7d60c42934bebf5a3fda1ae 100644 (file)
@@ -99,7 +99,7 @@ bool HTMLBodyElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& re
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLBodyElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLBodyElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -123,10 +123,10 @@ void HTMLBodyElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         addCSSLength(attr, CSS_PROP_MARGIN_TOP, attr->value());
         break;
     case ATTR_BGCOLOR:
-        addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
         break;
     case ATTR_TEXT:
-        addHTMLColor(attr, CSS_PROP_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_COLOR, attr->value());
         break;
     case ATTR_BGPROPERTIES:
         if ( strcasecmp( attr->value(), "fixed" ) == 0)
@@ -195,7 +195,7 @@ void HTMLBodyElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_NOSAVE:
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -404,7 +404,7 @@ void HTMLFrameElementImpl::openURL()
 }
 
 
-void HTMLFrameElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLFrameElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -413,7 +413,7 @@ void HTMLFrameElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     case ATTR_ID:
         // Important to call through to base for ATTR_ID so the hasID bit gets set.
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
         // fall through
     case ATTR_NAME:
         m_name = attr->value();
@@ -458,7 +458,7 @@ void HTMLFrameElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
                                 getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -691,7 +691,7 @@ NodeImpl::Id HTMLFrameSetElementImpl::id() const
     return ID_FRAMESET;
 }
 
-void HTMLFrameSetElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLFrameSetElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -732,7 +732,7 @@ void HTMLFrameSetElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
            getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -903,7 +903,7 @@ bool HTMLIFrameElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry&
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLIFrameElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr )
+void HTMLIFrameElementImpl::parseMappedAttribute(MappedAttributeImpl *attr )
 {
   switch (  attr->id() )
   {
@@ -917,7 +917,7 @@ void HTMLIFrameElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr )
       addHTMLAlignment( attr );
       break;
     default:
-      HTMLFrameElementImpl::parseHTMLAttribute( attr );
+      HTMLFrameElementImpl::parseMappedAttribute( attr );
   }
 }
 
index 87dce90c6a8df2713f8f13f4b10aa82bb434f015..6f11c840034bf64922026399276450ab202bf8f6 100644 (file)
@@ -58,7 +58,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     virtual void insertedIntoDocument();
 
@@ -97,7 +97,7 @@ public:
 
     virtual Id id() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
     virtual void attach();
     virtual void detach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
@@ -173,7 +173,7 @@ public:
 
     virtual Id id() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
     virtual void attach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
@@ -252,7 +252,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void attach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
index 8de780e562988f206f9785518d6822c7fe15c875..785195e760e9d5c224260d5d0726f056be6c9f95 100644 (file)
@@ -85,7 +85,7 @@ bool HTMLDivElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& res
     return HTMLElementImpl::mapToEntry(attr, result);
 }
         
-void HTMLDivElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLDivElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -103,7 +103,7 @@ void HTMLDivElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -149,7 +149,7 @@ bool HTMLHRElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& resu
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLHRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLHRElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch( attr->id() )
     {
@@ -185,16 +185,16 @@ void HTMLHRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         addCSSProperty(attr, CSS_PROP_BORDER_RIGHT_STYLE, CSS_VAL_SOLID);
         addCSSProperty(attr, CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_SOLID);
         addCSSProperty(attr, CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_SOLID);
-        addHTMLColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
-        addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
         break;
     case ATTR_NOSHADE:
         addCSSProperty(attr, CSS_PROP_BORDER_TOP_STYLE, CSS_VAL_SOLID);
         addCSSProperty(attr, CSS_PROP_BORDER_RIGHT_STYLE, CSS_VAL_SOLID);
         addCSSProperty(attr, CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_SOLID);
         addCSSProperty(attr, CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_SOLID);
-        addHTMLColor(attr, CSS_PROP_BORDER_COLOR, DOMString("grey"));
-        addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, DOMString("grey"));
+        addCSSColor(attr, CSS_PROP_BORDER_COLOR, DOMString("grey"));
+        addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, DOMString("grey"));
         break;
     case ATTR_SIZE: {
         DOMStringImpl* si = attr->value().implementation();
@@ -206,7 +206,7 @@ void HTMLHRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -288,7 +288,7 @@ bool HTMLParagraphElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntr
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLParagraphElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLParagraphElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -306,7 +306,7 @@ void HTMLParagraphElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             break;
         }
         default:
-            HTMLElementImpl::parseHTMLAttribute(attr);
+            HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -375,7 +375,7 @@ bool HTMLMarqueeElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry&
 }
             
             
-void HTMLMarqueeElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLMarqueeElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -389,7 +389,7 @@ void HTMLMarqueeElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             break;
         case ATTR_BGCOLOR:
             if (!attr->value().isEmpty())
-                addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
+                addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
             break;
         case ATTR_VSPACE:
             if (!attr->value().isEmpty()) {
@@ -431,7 +431,7 @@ void HTMLMarqueeElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             m_minimumDelay = !attr->isNull() ? 0 : defaultMinimumDelay;
             break;
         default:
-            HTMLElementImpl::parseHTMLAttribute(attr);
+            HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
index 9afac3e6ff005759645e9f1f0ff79d99fb632d42..ef9955386bb4c37d81af545a6d16a7dc3db14903 100644 (file)
@@ -59,7 +59,7 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *token);
+    virtual void parseMappedAttribute(MappedAttributeImpl *token);
 
     DOMString align() const;
     void setAlign(const DOMString &);
@@ -76,7 +76,7 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     DOMString align() const;
     void setAlign(const DOMString &);
@@ -116,7 +116,7 @@ public:
     HTMLParagraphElementImpl(DocumentPtr *doc);
 
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     
     virtual Id id() const;
 
@@ -145,7 +145,7 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *token);
+    virtual void parseMappedAttribute(MappedAttributeImpl *token);
 
     int minimumDelay() const { return m_minimumDelay; }
     
index 2f13a9847e55eca14f30d0f276b30590e64c7f54..a8699954c81799e5eb60669bc4f414e8c74f4448 100644 (file)
@@ -73,7 +73,7 @@ bool HTMLCanvasElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry&
     return HTMLImageElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLCanvasElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLCanvasElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -82,7 +82,7 @@ void HTMLCanvasElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             break;
         }
         default: {
-            HTMLImageElementImpl::parseHTMLAttribute(attr);
+            HTMLImageElementImpl::parseMappedAttribute(attr);
         }
     }
 }
index 9cd252b810ec46548f3beff0b783f88b7f43132d..c4e3e87ea1b3e9187a5420177442fe37b6844aec 100644 (file)
@@ -49,7 +49,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     virtual void attach();
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
index 010fcbce73fe8eb81d64f877ee1a074e0c4b6eb1..4f5887ccb683dd4675fc2eba3662da0509530988 100644 (file)
 using namespace DOM;
 using namespace khtml;
 
-CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl() {
-    if (m_entryType != ePersistent)
-        HTMLElementImpl::removeMappedAttributeDecl(m_entryType, m_attrName, m_attrValue);
-}
-
-QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >* HTMLElementImpl::m_mappedAttributeDecls = 0;
-
-CSSMappedAttributeDeclarationImpl* HTMLElementImpl::getMappedAttributeDecl(MappedAttributeEntry entryType, AttributeImpl* attr)
-{
-    if (!m_mappedAttributeDecls)
-        return 0;
-    
-    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
-    if (attrNameDict) {
-        QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = attrNameDict->find((void*)attr->id());
-        if (attrValueDict)
-            return attrValueDict->find(attr->value().implementation());
-    }
-    return 0;
-}
-
-void HTMLElementImpl::setMappedAttributeDecl(MappedAttributeEntry entryType, AttributeImpl* attr, CSSMappedAttributeDeclarationImpl* decl)
-{
-    if (!m_mappedAttributeDecls)
-        m_mappedAttributeDecls = new QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >;
-    
-    QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = 0;
-    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
-    if (!attrNameDict) {
-        attrNameDict = new QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >;
-        attrNameDict->setAutoDelete(true);
-        m_mappedAttributeDecls->insert((void*)entryType, attrNameDict);
-    }
-    else
-        attrValueDict = attrNameDict->find((void*)attr->id());
-    if (!attrValueDict) {
-        attrValueDict = new QPtrDict<CSSMappedAttributeDeclarationImpl>;
-        if (entryType == ePersistent)
-            attrValueDict->setAutoDelete(true);
-        attrNameDict->insert((void*)attr->id(), attrValueDict);
-    }
-    attrValueDict->replace(attr->value().implementation(), decl);
-}
-
-void HTMLElementImpl::removeMappedAttributeDecl(MappedAttributeEntry entryType, NodeImpl::Id attrName, const AtomicString& attrValue)
-{
-    if (!m_mappedAttributeDecls)
-        return;
-    
-    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
-    if (!attrNameDict)
-        return;
-    QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = attrNameDict->find((void*)attrName);
-    if (!attrValueDict)
-        return;
-    attrValueDict->remove(attrValue.implementation());
-}
-
-void HTMLElementImpl::invalidateStyleAttribute()
-{
-    m_isStyleAttributeValid = false;
-}
-
-void HTMLElementImpl::updateStyleAttributeIfNeeded() const
-{
-    if (!m_isStyleAttributeValid) {
-        m_isStyleAttributeValid = true;
-        m_synchronizingStyleAttribute = true;
-        if (m_inlineStyleDecl)
-            const_cast<HTMLElementImpl*>(this)->setAttribute(ATTR_STYLE, m_inlineStyleDecl->cssText());
-        m_synchronizingStyleAttribute = false;
-    }
-}
-
-HTMLAttributeImpl::~HTMLAttributeImpl()
-{
-    if (m_styleDecl)
-        m_styleDecl->deref();
-}
-
-AttributeImpl* HTMLAttributeImpl::clone(bool preserveDecl) const
-{
-    return new HTMLAttributeImpl(m_id, _value, preserveDecl ? m_styleDecl : 0);
-}
-
-HTMLNamedAttrMapImpl::HTMLNamedAttrMapImpl(ElementImpl *e)
-:NamedAttrMapImpl(e), m_mappedAttributeCount(0)
-{}
-
-void HTMLNamedAttrMapImpl::clearAttributes()
-{
-    m_classList.clear();
-    m_mappedAttributeCount = 0;
-    NamedAttrMapImpl::clearAttributes();
-}
-
-bool HTMLNamedAttrMapImpl::isHTMLAttributeMap() const
-{
-    return true;
-}
-
-int HTMLNamedAttrMapImpl::declCount() const
-{
-    int result = 0;
-    for (uint i = 0; i < length(); i++) {
-        HTMLAttributeImpl* attr = attributeItem(i);
-        if (attr->decl())
-            result++;
-    }
-    return result;
-}
-
-bool HTMLNamedAttrMapImpl::mapsEquivalent(const HTMLNamedAttrMapImpl* otherMap) const
-{
-    // The # of decls must match.
-    if (declCount() != otherMap->declCount())
-        return false;
-    
-    // The values for each decl must match.
-    for (uint i = 0; i < length(); i++) {
-        HTMLAttributeImpl* attr = attributeItem(i);
-        if (attr->decl()) {
-            AttributeImpl* otherAttr = otherMap->getAttributeItem(attr->id());
-            if (!otherAttr || (attr->value() != otherAttr->value()))
-                return false;
-        }
-    }
-    return true;
-}
-
-void HTMLNamedAttrMapImpl::parseClassAttribute(const DOMString& classStr)
-{
-    m_classList.clear();
-    if (!element->hasClass())
-        return;
-    
-    DOMString classAttr = element->getDocument()->inCompatMode() ? 
-        (classStr.implementation()->isLower() ? classStr : DOMString(classStr.implementation()->lower())) :
-        classStr;
-    
-    if (classAttr.find(' ') == -1 && classAttr.find('\n') == -1)
-        m_classList.setString(AtomicString(classAttr));
-    else {
-        QString val = classAttr.string();
-        val.replace('\n', ' ');
-        QStringList list = QStringList::split(' ', val);
-        
-        AtomicStringList* curr = 0;
-        for (QStringList::Iterator it = list.begin(); it != list.end(); ++it) {
-            const QString& singleClass = *it;
-            if (!singleClass.isEmpty()) {
-                if (curr) {
-                    curr->setNext(new AtomicStringList(AtomicString(singleClass)));
-                    curr = curr->next();
-                }
-                else {
-                    m_classList.setString(AtomicString(singleClass));
-                    curr = &m_classList;
-                }
-            }
-        }
-    }
-}
-
 // ------------------------------------------------------------------
 
 HTMLElementImpl::HTMLElementImpl(DocumentPtr *doc)
-    : ElementImpl(doc)
+    : StyledElementImpl(doc)
 {
-    m_inlineStyleDecl = 0;
-    m_isStyleAttributeValid = true;
-    m_synchronizingStyleAttribute = false;
 }
 
 HTMLElementImpl::~HTMLElementImpl()
 {
-    destroyInlineStyleDecl();
-}
-
-AttributeImpl* HTMLElementImpl::createAttribute(NodeImpl::Id id, DOMStringImpl* value)
-{
-    return new HTMLAttributeImpl(id, value);
 }
 
 bool HTMLElementImpl::isInline() const
@@ -282,25 +109,6 @@ bool HTMLElementImpl::isInline() const
     }
 }
 
-void HTMLElementImpl::createInlineStyleDecl()
-{
-    m_inlineStyleDecl = new CSSMutableStyleDeclarationImpl;
-    m_inlineStyleDecl->ref();
-    m_inlineStyleDecl->setParent(getDocument()->elementSheet());
-    m_inlineStyleDecl->setNode(this);
-    m_inlineStyleDecl->setStrictParsing(!getDocument()->inCompatMode());
-}
-
-void HTMLElementImpl::destroyInlineStyleDecl()
-{
-    if (m_inlineStyleDecl) {
-        m_inlineStyleDecl->setNode(0);
-        m_inlineStyleDecl->setParent(0);
-        m_inlineStyleDecl->deref();
-        m_inlineStyleDecl = 0;
-    }
-}
-
 NodeImpl *HTMLElementImpl::cloneNode(bool deep)
 {
     HTMLElementImpl *clone = static_cast<HTMLElementImpl *>(getDocument()->createHTMLElement(localNamePart(id())));
@@ -319,53 +127,6 @@ NodeImpl *HTMLElementImpl::cloneNode(bool deep)
     return clone;
 }
 
-void HTMLElementImpl::attributeChanged(AttributeImpl* attr, bool preserveDecls)
-{
-    HTMLAttributeImpl* htmlAttr = static_cast<HTMLAttributeImpl*>(attr);
-    if (htmlAttr->decl() && !preserveDecls) {
-        htmlAttr->setDecl(0);
-        setChanged();
-        if (namedAttrMap)
-            static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->declRemoved();
-    }
-
-    bool checkDecl = true;
-    MappedAttributeEntry entry;
-    bool needToParse = mapToEntry(attr->id(), entry);
-    if (preserveDecls) {
-        if (htmlAttr->decl()) {
-            setChanged();
-            if (namedAttrMap)
-                static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->declAdded();
-            checkDecl = false;
-        }
-    }
-    else if (!attr->isNull() && entry != eNone) {
-        CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(entry, attr);
-        if (decl) {
-            htmlAttr->setDecl(decl);
-            setChanged();
-            if (namedAttrMap)
-                static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->declAdded();
-            checkDecl = false;
-        } else
-            needToParse = true;
-    }
-
-    if (needToParse)
-        parseHTMLAttribute(htmlAttr);
-    
-    if (checkDecl && htmlAttr->decl()) {
-        // Add the decl to the table in the appropriate spot.
-        setMappedAttributeDecl(entry, attr, htmlAttr->decl());
-        htmlAttr->decl()->setMappedState(entry, attr->id(), attr->value());
-        htmlAttr->decl()->setParent(0);
-        htmlAttr->decl()->setNode(0);
-        if (namedAttrMap)
-            static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->declAdded();
-    }
-}
-
 bool HTMLElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const
 {
     switch (attr)
@@ -375,19 +136,18 @@ bool HTMLElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result
         case ATTR_DIR:
             result = eUniversal;
             return false;
-        case ATTR_STYLE:
-            result = eNone;
-            return !m_synchronizingStyleAttribute;
         default:
             break;
     }
-    
-    result = eNone;
-    return true;
+
+    return StyledElementImpl::mapToEntry(attr, result);
 }
     
-void HTMLElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
+    if (attr->id() == ATTR_ID || attr->id() == ATTR_CLASS || attr->id() == ATTR_STYLE)
+        return StyledElementImpl::parseMappedAttribute(attr);
+
     DOMString indexstring;
     switch (attr->id())
     {
@@ -397,38 +157,9 @@ void HTMLElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         else
             addCSSProperty(attr, CSS_PROP_TEXT_ALIGN, attr->value());
         break;
-// the core attributes...
-    case ATTR_ID:
-        // unique id
-        setHasID(!attr->isNull());
-        if (namedAttrMap) {
-            if (attr->isNull())
-                namedAttrMap->setID(nullAtom);
-            else if (getDocument()->inCompatMode() && !attr->value().implementation()->isLower())
-                namedAttrMap->setID(AtomicString(attr->value().domString().lower()));
-            else
-                namedAttrMap->setID(attr->value());
-        }
-        setChanged();
-        break;
-    case ATTR_CLASS:
-        // class
-        setHasClass(!attr->isNull());
-        if (namedAttrMap) static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->parseClassAttribute(attr->value());
-        setChanged();
-        break;
     case ATTR_CONTENTEDITABLE:
         setContentEditable(attr);
         break;
-    case ATTR_STYLE:
-        setHasStyle(!attr->isNull());
-        if (attr->isNull())
-            destroyInlineStyleDecl();
-        else
-            getInlineStyleDecl()->parseDeclaration(attr->value());
-        m_isStyleAttributeValid = true;
-        setChanged();
-        break;
     case ATTR_TABINDEX:
         indexstring=getAttribute(ATTR_TABINDEX);
         if (indexstring.length())
@@ -564,184 +295,6 @@ void HTMLElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     }
 }
 
-void HTMLElementImpl::createAttributeMap() const
-{
-    namedAttrMap = new HTMLNamedAttrMapImpl(const_cast<HTMLElementImpl*>(this));
-    namedAttrMap->ref();
-}
-
-CSSMutableStyleDeclarationImpl* HTMLElementImpl::getInlineStyleDecl()
-{
-    if (!m_inlineStyleDecl)
-        createInlineStyleDecl();
-    return m_inlineStyleDecl;
-}
-
-CSSMutableStyleDeclarationImpl* HTMLElementImpl::additionalAttributeStyleDecl()
-{
-    return 0;
-}
-
-const AtomicStringList* HTMLElementImpl::getClassList() const
-{
-    return namedAttrMap ? static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->getClassList() : 0;
-}
-
-static inline bool isHexDigit( const QChar &c ) {
-    return ( c >= '0' && c <= '9' ) ||
-          ( c >= 'a' && c <= 'f' ) ||
-          ( c >= 'A' && c <= 'F' );
-}
-
-static inline int toHex( const QChar &c ) {
-    return ( (c >= '0' && c <= '9')
-             ? (c.unicode() - '0')
-             : ( ( c >= 'a' && c <= 'f' )
-                 ? (c.unicode() - 'a' + 10)
-                 : ( ( c >= 'A' && c <= 'F' )
-                     ? (c.unicode() - 'A' + 10)
-                     : -1 ) ) );
-}
-
-void HTMLElementImpl::addCSSProperty(HTMLAttributeImpl* attr, int id, const DOMString &value)
-{
-    if (!attr->decl()) createMappedDecl(attr);
-    attr->decl()->setProperty(id, value, false);
-}
-
-void HTMLElementImpl::addCSSProperty(HTMLAttributeImpl* attr, int id, int value)
-{
-    if (!attr->decl()) createMappedDecl(attr);
-    attr->decl()->setProperty(id, value, false);
-}
-
-void HTMLElementImpl::addCSSStringProperty(HTMLAttributeImpl* attr, int id, const DOMString &value, CSSPrimitiveValue::UnitTypes type)
-{
-    if (!attr->decl()) createMappedDecl(attr);
-    attr->decl()->setStringProperty(id, value, type, false);
-}
-
-void HTMLElementImpl::addCSSImageProperty(HTMLAttributeImpl* attr, int id, const DOMString &URL)
-{
-    if (!attr->decl()) createMappedDecl(attr);
-    attr->decl()->setImageProperty(id, URL, false);
-}
-
-void HTMLElementImpl::addCSSLength(HTMLAttributeImpl* attr, int id, const DOMString &value)
-{
-    // FIXME: This function should not spin up the CSS parser, but should instead just figure out the correct
-    // length unit and make the appropriate parsed value.
-    if (!attr->decl()) createMappedDecl(attr);
-
-    // strip attribute garbage..
-    DOMStringImpl* v = value.implementation();
-    if ( v ) {
-        unsigned int l = 0;
-        
-        while ( l < v->l && v->s[l].unicode() <= ' ') l++;
-        
-        for ( ;l < v->l; l++ ) {
-            char cc = v->s[l].latin1();
-            if ( cc > '9' || ( cc < '0' && cc != '*' && cc != '%' && cc != '.') )
-                break;
-        }
-        if ( l != v->l ) {
-            attr->decl()->setLengthProperty(id, DOMString( v->s, l ), false);
-            return;
-        }
-    }
-    
-    attr->decl()->setLengthProperty(id, value, false);
-}
-
-/* color parsing that tries to match as close as possible IE 6. */
-void HTMLElementImpl::addHTMLColor(HTMLAttributeImpl* attr, int id, const DOMString &c)
-{
-    // this is the only case no color gets applied in IE.
-    if ( !c.length() )
-        return;
-
-    if (!attr->decl()) createMappedDecl(attr);
-    
-    if (attr->decl()->setProperty(id, c, false) )
-        return;
-    
-    QString color = c.string();
-    // not something that fits the specs.
-    
-    // we're emulating IEs color parser here. It maps transparent to black, otherwise it tries to build a rgb value
-    // out of everyhting you put in. The algorithm is experimentally determined, but seems to work for all test cases I have.
-    
-    // the length of the color value is rounded up to the next
-    // multiple of 3. each part of the rgb triple then gets one third
-    // of the length.
-    //
-    // Each triplet is parsed byte by byte, mapping
-    // each number to a hex value (0-9a-fA-F to their values
-    // everything else to 0).
-    //
-    // The highest non zero digit in all triplets is remembered, and
-    // used as a normalization point to normalize to values between 0
-    // and 255.
-    
-    if ( color.lower() != "transparent" ) {
-        if ( color[0] == '#' )
-            color.remove( 0,  1 );
-        int basicLength = (color.length() + 2) / 3;
-        if ( basicLength > 1 ) {
-            // IE ignores colors with three digits or less
-            //             qDebug("trying to fix up color '%s'. basicLength=%d, length=%d",
-            //                    color.latin1(), basicLength, color.length() );
-            int colors[3] = { 0, 0, 0 };
-            int component = 0;
-            int pos = 0;
-            int maxDigit = basicLength-1;
-            while ( component < 3 ) {
-                // search forward for digits in the string
-                int numDigits = 0;
-                while ( pos < (int)color.length() && numDigits < basicLength ) {
-                    int hex = toHex( color[pos] );
-                    colors[component] = (colors[component] << 4);
-                    if ( hex > 0 ) {
-                        colors[component] += hex;
-                        maxDigit = kMin( maxDigit, numDigits );
-                    }
-                    numDigits++;
-                    pos++;
-                }
-                while ( numDigits++ < basicLength )
-                    colors[component] <<= 4;
-                component++;
-            }
-            maxDigit = basicLength - maxDigit;
-            //             qDebug("color is %x %x %x, maxDigit=%d",  colors[0], colors[1], colors[2], maxDigit );
-            
-            // normalize to 00-ff. The highest filled digit counts, minimum is 2 digits
-            maxDigit -= 2;
-            colors[0] >>= 4*maxDigit;
-            colors[1] >>= 4*maxDigit;
-            colors[2] >>= 4*maxDigit;
-            //             qDebug("normalized color is %x %x %x",  colors[0], colors[1], colors[2] );
-            //         assert( colors[0] < 0x100 && colors[1] < 0x100 && colors[2] < 0x100 );
-            
-            color.sprintf("#%02x%02x%02x", colors[0], colors[1], colors[2] );
-            //             qDebug( "trying to add fixed color string '%s'", color.latin1() );
-            if ( attr->decl()->setProperty(id, DOMString(color), false) )
-                return;
-        }
-    }
-    attr->decl()->setProperty(id, CSS_VAL_BLACK, false);
-}
-
-void HTMLElementImpl::createMappedDecl(HTMLAttributeImpl* attr)
-{
-    CSSMappedAttributeDeclarationImpl* decl = new CSSMappedAttributeDeclarationImpl(0);
-    attr->setDecl(decl);
-    decl->setParent(getDocument()->elementSheet());
-    decl->setNode(this);
-    decl->setStrictParsing(false); // Mapped attributes are just always quirky.
-}
-
 DOMString HTMLElementImpl::innerHTML() const
 {
     return createMarkup(this, ChildrenOnly);
@@ -984,7 +537,7 @@ DOMString HTMLElementImpl::namespaceURI() const
         return XHTML_NAMESPACE;
 }
 
-void HTMLElementImpl::addHTMLAlignment(HTMLAttributeImpl* attr)
+void HTMLElementImpl::addHTMLAlignment(MappedAttributeImpl* attr)
 {
     //qDebug("alignment is %s", alignment.string().latin1() );
     // vertical alignment with respect to the current baseline of the text
@@ -1060,7 +613,7 @@ DOMString HTMLElementImpl::contentEditable() const
     return "inherit";
 }
 
-void HTMLElementImpl::setContentEditable(HTMLAttributeImpl* attr) 
+void HTMLElementImpl::setContentEditable(MappedAttributeImpl* attr) 
 {
     KHTMLPart *part = getDocument()->part();
     const AtomicString& enabled = attr->value();
@@ -1142,11 +695,6 @@ DOMString HTMLElementImpl::toString() const
     return ElementImpl::toString();
 }
 
-CSSStyleDeclarationImpl *HTMLElementImpl::style()
-{
-    return getInlineStyleDecl();
-}
-
 DOMString HTMLElementImpl::idDOM() const
 {
     return getAttribute(ATTR_ID);
index 67a0501e8f535e597f928c9fa9f508e47622de3f..45e54384c800ecee32361792155162767b543140 100644 (file)
@@ -25,8 +25,6 @@
 #define HTML_ELEMENTIMPL_H
 
 #include "xml/dom_elementimpl.h"
-#include "dom_atomicstringlist.h"
-#include "css/css_valueimpl.h"
 #include <qptrdict.h>
 
 namespace DOM {
@@ -34,86 +32,8 @@ namespace DOM {
 class DocumentFragmentImpl;
 class DOMString;
 class HTMLCollectionImpl;
-
-enum MappedAttributeEntry { eNone, eUniversal, ePersistent, eReplaced, eBlock, eHR, eUnorderedList, eListItem,
-    eTable, eCell, eCaption, eLastEntry };
-
-class CSSMappedAttributeDeclarationImpl : public CSSMutableStyleDeclarationImpl
-{
-public:
-    CSSMappedAttributeDeclarationImpl(CSSRuleImpl *parentRule)
-    : CSSMutableStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
-    {}
-    
-    virtual ~CSSMappedAttributeDeclarationImpl();
-
-    void setMappedState(MappedAttributeEntry type, NodeImpl::Id attr, const AtomicString& val)
-    {
-        m_entryType = type;
-        m_attrName = attr;
-        m_attrValue = val;
-    }
-
-private:
-    MappedAttributeEntry m_entryType;
-    NodeImpl::Id m_attrName;
-    AtomicString m_attrValue;
-};
-
-class HTMLAttributeImpl : public AttributeImpl
-{
-public:
-    HTMLAttributeImpl(NodeImpl::Id _id, const AtomicString& value, CSSMappedAttributeDeclarationImpl* decl = 0)
-    : AttributeImpl(_id, value), m_styleDecl(decl)
-    {
-        if (decl)
-            decl->ref();
-    }
-
-    ~HTMLAttributeImpl();
-
-    virtual AttributeImpl* clone(bool preserveDecl=true) const;
-
-    CSSMappedAttributeDeclarationImpl* decl() const { return m_styleDecl; }
-    void setDecl(CSSMappedAttributeDeclarationImpl* decl) 
-    { 
-        if (m_styleDecl) m_styleDecl->deref();
-        m_styleDecl = decl;
-        if (m_styleDecl) m_styleDecl->ref();
-    }
-
-private:
-    CSSMappedAttributeDeclarationImpl* m_styleDecl;
-};
-
-class HTMLNamedAttrMapImpl : public NamedAttrMapImpl
-{
-public:
-    HTMLNamedAttrMapImpl(ElementImpl *e);
-
-    virtual void clearAttributes();
-    
-    virtual bool isHTMLAttributeMap() const;
-    
-    virtual void parseClassAttribute(const DOMString& classAttr);
-    const AtomicStringList* getClassList() const { return &m_classList; }
     
-    virtual bool hasMappedAttributes() const { return m_mappedAttributeCount > 0; }
-    void declRemoved() { m_mappedAttributeCount--; }
-    void declAdded() { m_mappedAttributeCount++; }
-    
-    bool mapsEquivalent(const HTMLNamedAttrMapImpl* otherMap) const;
-    int declCount() const;
-
-    HTMLAttributeImpl* attributeItem(unsigned long index) const
-    { return attrs ? static_cast<HTMLAttributeImpl*>(attrs[index]) : 0; }
-    
-private:
-    AtomicStringList m_classList;
-    int m_mappedAttributeCount;
-};
-    
-class HTMLElementImpl : public ElementImpl
+class HTMLElementImpl : public StyledElementImpl
 {
 public:
     HTMLElementImpl(DocumentPtr *doc);
@@ -125,28 +45,12 @@ public:
     virtual bool isInline() const;
      
     virtual Id id() const = 0;
+    
+    virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
+    virtual void parseMappedAttribute(MappedAttributeImpl* attr);
 
-    virtual void attributeChanged(AttributeImpl* attr, bool preserveDecls = false);
-    virtual void parseHTMLAttribute(HTMLAttributeImpl* attr);
-    virtual void createAttributeMap() const;
-
-    virtual NodeImpl *cloneNode(bool deep);
-
-    virtual const AtomicStringList* getClassList() const;
-
-    bool hasMappedAttributes() const { return namedAttrMap ? static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap)->hasMappedAttributes() : false; }
-    const HTMLNamedAttrMapImpl* htmlAttributes() const { return static_cast<HTMLNamedAttrMapImpl*>(namedAttrMap); }
-    virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    bool isMappedAttribute(NodeImpl::Id attr) const { MappedAttributeEntry res = eNone; mapToEntry(attr, res); return res != eNone; }
+    virtual NodeImpl* cloneNode(bool deep);
 
-    void addCSSLength(HTMLAttributeImpl* attr, int id, const DOMString &value);
-    void addCSSProperty(HTMLAttributeImpl* attr, int id, const DOMString &value);
-    void addCSSProperty(HTMLAttributeImpl* attr, int id, int value);
-    void addCSSStringProperty(HTMLAttributeImpl* attr, int id, const DOMString &value, DOM::CSSPrimitiveValue::UnitTypes = DOM::CSSPrimitiveValue::CSS_STRING);
-    void addCSSImageProperty(HTMLAttributeImpl* attr, int id, const DOMString &URL);
-    void addHTMLColor(HTMLAttributeImpl* attr, int id, const DOMString &c);
-    void createMappedDecl(HTMLAttributeImpl* attr);
-    
     SharedPtr<HTMLCollectionImpl> children();
     
     DOMString idDOM() const; // rename to id after eliminating NodeImpl::id some day
@@ -175,42 +79,20 @@ public:
     virtual bool isFocusable() const;
     virtual bool isContentEditable() const;
     virtual DOMString contentEditable() const;
-    virtual void setContentEditable(HTMLAttributeImpl* attr);
+    virtual void setContentEditable(MappedAttributeImpl* attr);
     virtual void setContentEditable(const DOMString &enabled);
 
     virtual void click(bool sendMouseEvents);
     virtual void accessKeyAction(bool sendToAnyElement);
-    
-    CSSMutableStyleDeclarationImpl* inlineStyleDecl() const { return m_inlineStyleDecl; }
-    virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
-    CSSMutableStyleDeclarationImpl* getInlineStyleDecl();
-    void createInlineStyleDecl();
-    void destroyInlineStyleDecl();
-
-    virtual AttributeImpl* createAttribute(NodeImpl::Id id, DOMStringImpl* value);
 
     virtual bool isGenericFormElement() const { return false; }
 
     virtual DOMString toString() const;
 
-    static CSSMappedAttributeDeclarationImpl* getMappedAttributeDecl(MappedAttributeEntry type, AttributeImpl* attr);
-    static void setMappedAttributeDecl(MappedAttributeEntry type, AttributeImpl* attr, CSSMappedAttributeDeclarationImpl* decl);
-    static void removeMappedAttributeDecl(MappedAttributeEntry type, NodeImpl::Id attrName, const AtomicString& attrValue);
-    static QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >* m_mappedAttributeDecls;
-
-    void invalidateStyleAttribute();
-    virtual void updateStyleAttributeIfNeeded() const;
-
-    virtual CSSStyleDeclarationImpl *style();
-
 protected:
 
     // for IMG, OBJECT and APPLET
-    void addHTMLAlignment(HTMLAttributeImpl* htmlAttr);
-
-    CSSMutableStyleDeclarationImpl* m_inlineStyleDecl;
-    mutable bool m_isStyleAttributeValid : 1;
-    mutable bool m_synchronizingStyleAttribute : 1;
+    void addHTMLAlignment(MappedAttributeImpl* htmlAttr);
 };
 
 class HTMLGenericElementImpl : public HTMLElementImpl
index 5052d32b1490438b28aac53c346da0d40835be68..f16d297de46268d3d9c1f6a20a891db3fa6cbb3f 100644 (file)
@@ -626,7 +626,7 @@ void HTMLFormElementImpl::reset(  )
     m_inreset = false;
 }
 
-void HTMLFormElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLFormElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -701,7 +701,7 @@ void HTMLFormElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
        }
        // fall through
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -855,7 +855,7 @@ HTMLGenericFormElementImpl::~HTMLGenericFormElementImpl()
         m_form->removeFormElement(this);
 }
 
-void HTMLGenericFormElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLGenericFormElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -875,7 +875,7 @@ void HTMLGenericFormElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -1192,7 +1192,7 @@ void HTMLButtonElementImpl::focus()
     getDocument()->setFocusNode(this);
 }
 
-void HTMLButtonElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLButtonElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -1219,7 +1219,7 @@ void HTMLButtonElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -1414,7 +1414,7 @@ void HTMLInputElementImpl::setType(const DOMString& t)
     if (m_type != newType) {
         if (newType == FILE && m_haveType) {
             // Set the attribute back to the old value.
-            // Useful in case we were called from inside parseHTMLAttribute.
+            // Useful in case we were called from inside parseMappedAttribute.
             setAttribute(ATTR_TYPE, type());
         } else {
             bool wasAttached = m_attached;
@@ -1620,7 +1620,7 @@ bool HTMLInputElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLInputElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLInputElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -1724,7 +1724,7 @@ void HTMLInputElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         setChanged();
         break;
     default:
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -2338,7 +2338,7 @@ NodeImpl::Id HTMLLabelElementImpl::id() const
     return ID_LABEL;
 }
 
-void HTMLLabelElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLLabelElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -2351,7 +2351,7 @@ void HTMLLabelElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -2706,7 +2706,7 @@ NodeImpl* HTMLSelectElementImpl::addChild(NodeImpl* newChild)
     return HTMLGenericFormElementImpl::addChild(newChild);
 }
 
-void HTMLSelectElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLSelectElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -2735,7 +2735,7 @@ void HTMLSelectElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -2963,7 +2963,7 @@ DOMString HTMLKeygenElementImpl::type() const
     return "keygen";
 }
 
-void HTMLKeygenElementImpl::parseHTMLAttribute(HTMLAttributeImpl* attr)
+void HTMLKeygenElementImpl::parseMappedAttribute(MappedAttributeImpl* attr)
 {
     switch(attr->id())
     {
@@ -2975,7 +2975,7 @@ void HTMLKeygenElementImpl::parseHTMLAttribute(HTMLAttributeImpl* attr)
         break;
     default:
         // skip HTMLSelectElementImpl parsing!
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -3074,9 +3074,9 @@ NodeImpl* HTMLOptGroupElementImpl::addChild(NodeImpl* newChild)
     return HTMLGenericFormElementImpl::addChild(newChild);
 }
 
-void HTMLOptGroupElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLOptGroupElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
-    HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+    HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     recalcSelectOptions();
 }
 
@@ -3181,7 +3181,7 @@ void HTMLOptionElementImpl::setIndex(long, int &exception)
     // ###
 }
 
-void HTMLOptionElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLOptionElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -3192,7 +3192,7 @@ void HTMLOptionElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         m_value = attr->value();
         break;
     default:
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -3306,7 +3306,7 @@ void HTMLTextAreaElementImpl::childrenChanged()
     setValue(defaultValue());
 }
     
-void HTMLTextAreaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTextAreaElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -3354,7 +3354,7 @@ void HTMLTextAreaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
            getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -3502,16 +3502,16 @@ NodeImpl::Id HTMLIsIndexElementImpl::id() const
     return ID_ISINDEX;
 }
 
-void HTMLIsIndexElementImpl::parseHTMLAttribute(HTMLAttributeImpl* attr)
+void HTMLIsIndexElementImpl::parseMappedAttribute(MappedAttributeImpl* attr)
 {
     switch(attr->id())
     {
     case ATTR_PROMPT:
        setValue(attr->value());
     default:
-        // don't call HTMLInputElement::parseHTMLAttribute here, as it would
+        // don't call HTMLInputElement::parseMappedAttribute here, as it would
         // accept attributes this element does not support
-        HTMLGenericFormElementImpl::parseHTMLAttribute(attr);
+        HTMLGenericFormElementImpl::parseMappedAttribute(attr);
     }
 }
 
index 817cf75b738b0dd787a6e6a9920396378f51b520..7ff7ecfb0bd1dd79e3df6501bde09518bc9d21fa 100644 (file)
@@ -84,7 +84,7 @@ public:
 
     bool autoComplete() const { return m_autocomplete; }
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     void radioClicked( HTMLGenericFormElementImpl *caller );
 
@@ -167,7 +167,7 @@ public:
 
     virtual DOMString type() const = 0;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void attach();
     virtual void insertedIntoDocument();
     virtual void removedFromDocument();
@@ -246,7 +246,7 @@ public:
     virtual Id id() const;
     DOMString type() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void defaultEventHandler(EventImpl *evt);
     virtual bool appendFormData(FormDataList&, bool);
 
@@ -363,7 +363,7 @@ public:
     virtual void accessKeyAction(bool sendToAnyElement);
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void attach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
@@ -455,7 +455,7 @@ public:
     
     virtual Id id() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void accessKeyAction(bool sendToAnyElement);
 
@@ -549,7 +549,7 @@ public:
 
     virtual void childrenChanged();
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
     virtual bool appendFormData(FormDataList&, bool);
@@ -602,7 +602,7 @@ public:
     // ### this is just a rough guess
     virtual bool isEnumeratable() const { return false; }
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual bool appendFormData(FormDataList&, bool);
 protected:
     AtomicString m_challenge;
@@ -627,7 +627,7 @@ public:
     virtual NodeImpl *removeChild ( NodeImpl *oldChild, int &exceptioncode );
     virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode );
     virtual NodeImpl *addChild( NodeImpl* newChild );
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     void recalcSelectOptions();
 
     DOMString label() const;
@@ -655,7 +655,8 @@ public:
 
     long index() const;
     void setIndex(long, int &exception);
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
+
     DOMString value() const;
     void setValue(const DOMString &);
 
@@ -713,7 +714,7 @@ public:
     void select (  );
 
     virtual void childrenChanged();
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
     virtual void detach();
     virtual bool appendFormData(FormDataList&, bool);
@@ -759,7 +760,8 @@ public:
     HTMLIsIndexElementImpl(DocumentPtr *doc, HTMLFormElementImpl *f = 0);
 
     virtual Id id() const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     DOMString prompt() const;
     void setPrompt(const DOMString &);
index bfbfea66c228448d24ee959cf93d8f37106de3ec..10af8955ccc9adbd24cce29026254dda0833ac6f 100644 (file)
@@ -59,7 +59,7 @@ NodeImpl::Id HTMLBaseElementImpl::id() const
     return ID_BASE;
 }
 
-void HTMLBaseElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLBaseElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -72,7 +72,7 @@ void HTMLBaseElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
        process();
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -177,7 +177,7 @@ void HTMLLinkElementImpl::setDisabledState(bool _disabled)
     }
 }
 
-void HTMLLinkElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLLinkElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -201,7 +201,7 @@ void HTMLLinkElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         setDisabledState(!attr->isNull());
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -436,7 +436,7 @@ NodeImpl::Id HTMLMetaElementImpl::id() const
     return ID_META;
 }
 
-void HTMLMetaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLMetaElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -451,7 +451,7 @@ void HTMLMetaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_NAME:
       break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -686,7 +686,7 @@ NodeImpl::Id HTMLStyleElementImpl::id() const
 }
 
 // other stuff...
-void HTMLStyleElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLStyleElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -697,7 +697,7 @@ void HTMLStyleElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         m_media = attr->value().string().lower();
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
index 044dcfefa2e98edb1201550e90b81c927e902b3b..9a687210d4550eb217e004f1246a89e7bab9785c 100644 (file)
@@ -53,7 +53,7 @@ public:
     DOMString target() const { return m_target; }
 
     virtual Id id() const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void insertedIntoDocument();
     virtual void removedFromDocument();
 
@@ -109,7 +109,7 @@ public:
     StyleSheetImpl* sheet() const { return m_sheet; }
 
     // overload from HTMLElementImpl
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     void process();
 
@@ -156,7 +156,7 @@ public:
     ~HTMLMetaElementImpl();
 
     virtual Id id() const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void insertedIntoDocument();
 
     void process();
@@ -234,7 +234,7 @@ public:
     StyleSheetImpl *sheet() const { return m_sheet; }
 
     // overload from HTMLElementImpl
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void insertedIntoDocument();
     virtual void removedFromDocument();
     virtual void childrenChanged();
index de8ed088f6662b4f05dd646a9f8dda89295d0268..bfc70134bd8170ea7ede2b5e6fbcd301cc0ecc56 100644 (file)
@@ -171,7 +171,7 @@ bool HTMLImageElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLImageElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLImageElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -266,7 +266,7 @@ void HTMLImageElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
        }
        // fall through
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -582,13 +582,13 @@ HTMLMapElementImpl::mapMouseEvent(int x_, int y_, int width_, int height_,
     return false;
 }
 
-void HTMLMapElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLMapElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
     case ATTR_ID:
         // Must call base class so that hasID bit gets set.
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
         if (getDocument()->htmlMode() != DocumentImpl::XHtml) break;
         // fall through
     case ATTR_NAME:
@@ -599,7 +599,7 @@ void HTMLMapElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         getDocument()->addImageMap(this);
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -639,7 +639,7 @@ NodeImpl::Id HTMLAreaElementImpl::id() const
     return ID_AREA;
 }
 
-void HTMLAreaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLAreaElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -665,7 +665,7 @@ void HTMLAreaElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_ACCESSKEY:
         break;
     default:
-        HTMLAnchorElementImpl::parseHTMLAttribute(attr);
+        HTMLAnchorElementImpl::parseMappedAttribute(attr);
     }
 }
 
index cd2b77bd851b3da8cb0b69f4917b75d8945c9abb..6292e703b5b79a96caeb0bc986dab38a0d96a9f0 100644 (file)
@@ -80,7 +80,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     virtual void attach();
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
@@ -163,7 +163,7 @@ public:
 
     virtual Id id() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     bool isDefault() const { return m_shape == Default; }
 
@@ -219,7 +219,7 @@ public:
 
     virtual DOMString getName() const { return m_name; }
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     bool mapMouseEvent(int x_, int y_, int width_, int height_,
                        khtml::RenderObject::NodeInfo& info);
index aa61eb663302e67e0d411d41fbec414aaaebd4d2..dbd767c22bc1ecca3ae01218ad40ed759d3deeb7 100644 (file)
@@ -214,7 +214,7 @@ void HTMLAnchorElementImpl::defaultEventHandler(EventImpl *evt)
 }
 
 
-void HTMLAnchorElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLAnchorElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -229,7 +229,7 @@ void HTMLAnchorElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_REL:
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -405,7 +405,7 @@ bool HTMLBRElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& resu
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLBRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLBRElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id())
     {
@@ -423,7 +423,7 @@ void HTMLBRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -520,7 +520,7 @@ bool HTMLFontElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& re
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLFontElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLFontElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -548,13 +548,13 @@ void HTMLFontElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     case ATTR_COLOR:
-        addHTMLColor(attr, CSS_PROP_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_COLOR, attr->value());
         break;
     case ATTR_FACE:
         addCSSProperty(attr, CSS_PROP_FONT_FAMILY, attr->value());
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
index b25542ae1ede2bfec2ca043abdfeab24ac25238a..15a2e3ccd78cc3ad224410e6ca660ccbe72d20fd 100644 (file)
@@ -40,7 +40,7 @@ public:
     virtual bool isKeyboardFocusable() const;
     virtual bool isFocusable() const;
     virtual Id id() const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     virtual void defaultEventHandler(EventImpl *evt);
     virtual void accessKeyAction(bool fullAction);
     virtual bool isURLAttribute(AttributeImpl *attr) const;
@@ -101,7 +101,7 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
     
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
 
@@ -120,7 +120,7 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     DOMString color() const;
     void setColor(const DOMString &);
index 4481b0da0f456d12f4cb6b1c0f91e45c05bd15e1..7e94b6c21ca989b66f6d2d4d30f42ddad40293c5 100644 (file)
@@ -50,7 +50,7 @@ bool HTMLUListElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLUListElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLUListElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -58,7 +58,7 @@ void HTMLUListElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         addCSSProperty(attr, CSS_PROP_LIST_STYLE_TYPE, attr->value());
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -136,7 +136,7 @@ bool HTMLOListElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLOListElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLOListElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -155,7 +155,7 @@ void HTMLOListElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_START:
             _start = !attr->isNull() ? attr->value().toInt() : 1;
     default:
-        HTMLUListElementImpl::parseHTMLAttribute(attr);
+        HTMLUListElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -204,7 +204,7 @@ bool HTMLLIElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& resu
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLLIElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLLIElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -235,7 +235,7 @@ void HTMLLIElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             addCSSProperty(attr, CSS_PROP_LIST_STYLE_TYPE, attr->value());
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
index d6b81396955e8c94302ff0814f24296251f73090..eb7bea81e262b686b6f22e86367e9d2e435d7f9a 100644 (file)
@@ -40,8 +40,8 @@ public:
 
     virtual Id id() const;
 
-    virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     virtual long start() const { return 1; }
 
@@ -88,8 +88,8 @@ public:
 
     virtual Id id() const;
     
-    virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *);
+    virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
+    virtual void parseMappedAttribute(MappedAttributeImpl *);
 
     bool compact() const;
     void setCompact(bool);
@@ -116,7 +116,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void attach();
 
index 79dad23dbfc7f05cd83bf4dc3d36a24f3de0627b..343fce4dc89cff6eecf0e5496a1bba8069f02897 100644 (file)
@@ -90,7 +90,7 @@ bool HTMLAppletElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry&
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLAppletElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLAppletElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch (attr->id()) {
     case ATTR_ALT:
@@ -111,7 +111,7 @@ void HTMLAppletElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
        addHTMLAlignment(attr);
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -402,7 +402,7 @@ bool HTMLEmbedElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLEmbedElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLEmbedElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
   QString val = attr->value().string();
   
@@ -459,7 +459,7 @@ void HTMLEmbedElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         }
         break;
      default:
-        HTMLElementImpl::parseHTMLAttribute( attr );
+        HTMLElementImpl::parseMappedAttribute( attr );
   }
 }
 
@@ -557,7 +557,7 @@ bool HTMLObjectElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry&
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLObjectElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLObjectElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
   QString val = attr->value().string();
   int pos;
@@ -605,7 +605,7 @@ void HTMLObjectElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
            getDocument()->createHTMLEventListener(attr->value().string(), this));
         break;
     default:
-      HTMLElementImpl::parseHTMLAttribute( attr );
+      HTMLElementImpl::parseMappedAttribute( attr );
   }
 }
 
@@ -928,13 +928,13 @@ NodeImpl::Id HTMLParamElementImpl::id() const
     return ID_PARAM;
 }
 
-void HTMLParamElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLParamElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch( attr->id() )
     {
     case ATTR_ID:
         // Must call base class so that hasID bit gets set.
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
         if (getDocument()->htmlMode() != DocumentImpl::XHtml) break;
         // fall through
     case ATTR_NAME:
index 756a99bfddc0819a7c76a85932cb97d413769b32..7b8d24e1ae8b78979308730c7d8eba39b1e84072 100644 (file)
@@ -48,7 +48,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *token);
+    virtual void parseMappedAttribute(MappedAttributeImpl *token);
     
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
@@ -118,7 +118,7 @@ public:
     virtual Id id() const;
 
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void attach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
@@ -154,7 +154,7 @@ public:
     HTMLFormElementImpl *form() const;
 
     virtual bool mapToEntry(Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *token);
+    virtual void parseMappedAttribute(MappedAttributeImpl *token);
 
     virtual void attach();
     virtual bool rendererIsNeeded(khtml::RenderStyle *);
@@ -252,7 +252,7 @@ public:
 
     virtual Id id() const;
 
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *token);
+    virtual void parseMappedAttribute(MappedAttributeImpl *token);
 
     virtual bool isURLAttribute(AttributeImpl *attr) const;
 
index 89b43df9c00c8b99be4bff317fbf339f87f3a858..99bed4f6f9fb9dae0053ab6b447d08634db42fe7 100644 (file)
@@ -393,7 +393,7 @@ bool HTMLTableElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& r
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLTableElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTableElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -443,12 +443,12 @@ void HTMLTableElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
         break;
     }
     case ATTR_BGCOLOR:
-        addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
+        addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value());
         break;
     case ATTR_BORDERCOLOR:
         m_solid = attr->decl();
         if (!attr->decl() && !attr->isEmpty()) {
-            addHTMLColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
+            addCSSColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
             addCSSProperty(attr, CSS_PROP_BORDER_TOP_STYLE, CSS_VAL_SOLID);
             addCSSProperty(attr, CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_SOLID);
             addCSSProperty(attr, CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_SOLID);
@@ -543,7 +543,7 @@ void HTMLTableElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_NOSAVE:
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -551,7 +551,7 @@ CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDe
 {
     if (m_noBorder)
         return 0;
-    HTMLAttributeImpl attr(ATTR_TABLEBORDER, m_solid ? "solid" : "outset");
+    MappedAttributeImpl attr(ATTR_TABLEBORDER, m_solid ? "solid" : "outset");
     CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(ePersistent, &attr);
     if (!decl) {
         decl = new CSSMappedAttributeDeclarationImpl(0);
@@ -577,7 +577,7 @@ CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::additionalAttributeStyleDe
 
 CSSMutableStyleDeclarationImpl* HTMLTableElementImpl::getSharedCellDecl()
 {
-    HTMLAttributeImpl attr(ATTR_CELLBORDER, m_noBorder ? "none" : (m_solid ? "solid" : "inset"));
+    MappedAttributeImpl attr(ATTR_CELLBORDER, m_noBorder ? "none" : (m_solid ? "solid" : "inset"));
     CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(ePersistent, &attr);
     if (!decl) {
         decl = new CSSMappedAttributeDeclarationImpl(0);
@@ -743,12 +743,12 @@ bool HTMLTablePartElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntr
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLTablePartElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTablePartElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
     case ATTR_BGCOLOR:
-        addHTMLColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value() );
+        addCSSColor(attr, CSS_PROP_BACKGROUND_COLOR, attr->value() );
         break;
     case ATTR_BACKGROUND:
     {
@@ -760,7 +760,7 @@ void HTMLTablePartElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_BORDERCOLOR:
     {
         if (!attr->value().isEmpty()) {
-            addHTMLColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
+            addCSSColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
             addCSSProperty(attr, CSS_PROP_BORDER_TOP_STYLE, CSS_VAL_SOLID);
             addCSSProperty(attr, CSS_PROP_BORDER_BOTTOM_STYLE, CSS_VAL_SOLID);
             addCSSProperty(attr, CSS_PROP_BORDER_LEFT_STYLE, CSS_VAL_SOLID);
@@ -796,7 +796,7 @@ void HTMLTablePartElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_NOSAVE:
        break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -1135,7 +1135,7 @@ bool HTMLTableCellElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntr
     return HTMLTablePartElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLTableCellElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTableCellElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -1172,7 +1172,7 @@ void HTMLTableCellElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
     case ATTR_NOSAVE:
        break;
     default:
-        HTMLTablePartElementImpl::parseHTMLAttribute(attr);
+        HTMLTablePartElementImpl::parseMappedAttribute(attr);
     }
 }
 
@@ -1361,7 +1361,7 @@ bool HTMLTableColElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry
     return HTMLTablePartElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLTableColElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTableColElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -1375,7 +1375,7 @@ void HTMLTableColElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             addCSSLength(attr, CSS_PROP_WIDTH, attr->value());
         break;
     default:
-        HTMLTablePartElementImpl::parseHTMLAttribute(attr);
+        HTMLTablePartElementImpl::parseMappedAttribute(attr);
     }
 
 }
@@ -1451,7 +1451,7 @@ bool HTMLTableCaptionElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeE
     return HTMLElementImpl::mapToEntry(attr, result);
 }
 
-void HTMLTableCaptionElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
+void HTMLTableCaptionElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
 {
     switch(attr->id())
     {
@@ -1460,7 +1460,7 @@ void HTMLTableCaptionElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
             addCSSProperty(attr, CSS_PROP_CAPTION_SIDE, attr->value());
         break;
     default:
-        HTMLElementImpl::parseHTMLAttribute(attr);
+        HTMLElementImpl::parseMappedAttribute(attr);
     }
 }
 
index cd0fbfc09301a2734ae89f783e976b1c95bd355f..f52fe7e91a62a907fd6271a14bd1fe81a1ee1313 100644 (file)
@@ -118,7 +118,7 @@ public:
     virtual NodeImpl *addChild(NodeImpl *child);
     
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     // Used to obtain either a solid or outset border decl.
     virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
@@ -152,7 +152,7 @@ public:
         { }
 
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 };
 
 // -------------------------------------------------------------------------
@@ -255,7 +255,7 @@ public:
     virtual Id id() const { return _id; }
     
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     virtual void attach();
 
@@ -329,7 +329,7 @@ public:
 
     // overrides
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     long span() const { return _span; }
 
@@ -370,10 +370,10 @@ public:
     virtual Id id() const;
     
     virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
-    virtual void parseHTMLAttribute(HTMLAttributeImpl *attr);
+    virtual void parseMappedAttribute(MappedAttributeImpl *attr);
 
     DOMString align() const;
-    void setAlign( const DOMString & );
+    void setAlign(const DOMString&);
 };
 
 } //namespace
index d88822338ec1efb3aca2a32e9eb67eb79ec3c223..ac41a98dd4fc56d509dd382c4f468f15c626e8f8 100644 (file)
@@ -84,14 +84,14 @@ public:
     {
         DOM::AttributeImpl* a = 0;
         if(buffer->unicode())
-            a = new DOM::HTMLAttributeImpl(buffer->unicode(), v);
+            a = new DOM::MappedAttributeImpl(buffer->unicode(), v);
         else if ( !attrName.isEmpty() && attrName != "/" )
-            a = new DOM::HTMLAttributeImpl(doc->attrId(0, DOM::DOMString(attrName).implementation(), false),
-                                           v);
+            a = new DOM::MappedAttributeImpl(doc->attrId(0, DOM::DOMString(attrName).implementation(), false),
+                                             v);
 
         if (a) {
             if(!attrs) {
-                attrs = new DOM::HTMLNamedAttrMapImpl(0);
+                attrs = new DOM::NamedMappedAttrMapImpl(0);
                 attrs->ref();
             }
             attrs->insertAttribute(a);
@@ -110,7 +110,7 @@ public:
         }
         flat = false;
     }
-    DOM::HTMLNamedAttrMapImpl* attrs;
+    DOM::NamedMappedAttrMapImpl* attrs;
     DOM::DOMStringImpl* text;
     ushort id;
     bool flat;
index 8fdb1cd24547aeb5d7e7a8b01720ed89b814dca6..d0341e1746413e1430ddfafe264100fd2a4d5665 100644 (file)
@@ -180,3 +180,4 @@ vspace
 width
 wrap
 z-index
+collapsed
index ebc659d815fe2e71b12a3743651eb0144ee5071e..b88f8ca14ad78e0722e854445e6707254100efc4 100644 (file)
@@ -100,3 +100,7 @@ ul
 var
 wbr
 xmp
+application
+menubar
+menuitem
+menuseparator
index 9275f7be60f1706f88c6916a7ee7f1d126b2c572..1556ec06ef5d156d465c5d29ffcaf5e6a6be864b 100644 (file)
@@ -521,7 +521,7 @@ AttrImpl *DocumentImpl::createAttribute( NodeImpl::Id id )
 {
     // Assume this is an HTML attribute, since createAttribute isn't namespace-aware.  There's no harm to XML
     // documents if we're wrong.
-    return new AttrImpl(0, docPtr(), new HTMLAttributeImpl(id, DOMString("").implementation()));
+    return new AttrImpl(0, docPtr(), new MappedAttributeImpl(id, DOMString("").implementation()));
 }
 
 EntityReferenceImpl *DocumentImpl::createEntityReference ( const DOMString &name )
@@ -624,7 +624,7 @@ ElementImpl *DocumentImpl::createElementNS( const DOMString &_namespaceURI, cons
     int colonPos = qName.find(':',0);
 
     if (_namespaceURI == XHTML_NAMESPACE) {
-        // User requested an element in the XHTML namespace - this means we create a HTML element
+        // User requested an element in the XHTML namespace - this means we create a specific element
         // (elements not in this namespace are treated as normal XML elements)
         e = createHTMLElement(qName.mid(colonPos+1), exceptioncode);
         if (exceptioncode)
@@ -637,6 +637,7 @@ ElementImpl *DocumentImpl::createElementNS( const DOMString &_namespaceURI, cons
             }
         }
     }
+
     if (!e)
         e = new XMLElementImpl( document, _qualifiedName.implementation(), _namespaceURI.implementation() );
 
@@ -920,6 +921,9 @@ ElementImpl *DocumentImpl::createHTMLElement(unsigned short tagID)
     case ID_Q:
         return new HTMLQuoteElementImpl(docPtr());
 
+    case ID_MARQUEE:
+        return new HTMLMarqueeElementImpl(docPtr());
+   
 // elements with no special representation in the DOM
 
 // block:
@@ -959,14 +963,6 @@ ElementImpl *DocumentImpl::createHTMLElement(unsigned short tagID)
     case ID_BDO:
     default:
         return new HTMLGenericElementImpl(docPtr(), tagID);
-
-    case ID_MARQUEE:
-        return new HTMLMarqueeElementImpl(docPtr());
-        
-// text
-    case ID_TEXT:
-        kdDebug( 6020 ) << "Use document->createTextNode()" << endl;
-        return 0;
     }
 
     return 0;
index 15001495433b5609202c9625b1100a6ab9cafae5..0a72955a7302def86018ebb9e0807ace2f628647 100644 (file)
@@ -39,6 +39,8 @@
 #include "rendering/render_canvas.h"
 #include "misc/htmlhashes.h"
 #include "css/css_valueimpl.h"
+#include "css/cssproperties.h"
+#include "css/cssvalues.h"
 #include "css/css_stylesheetimpl.h"
 #include "css/cssstyleselector.h"
 #include "xml/dom_xmlimpl.h"
@@ -807,7 +809,7 @@ DOMString XMLElementImpl::namespaceURI() const
 
 NodeImpl *XMLElementImpl::cloneNode ( bool deep )
 {
-    // ### we loose namespace here FIXME
+    // ### we lose namespace here FIXME
     // should pass id around
     XMLElementImpl *clone = new XMLElementImpl(docPtr(), getDocument()->tagName(m_id).implementation());
     clone->m_id = m_id;
@@ -836,7 +838,7 @@ NamedAttrMapImpl::~NamedAttrMapImpl()
     NamedAttrMapImpl::clearAttributes(); // virtual method, so qualify just to be explicit
 }
 
-bool NamedAttrMapImpl::isHTMLAttributeMap() const
+bool NamedAttrMapImpl::isMappedAttributeMap() const
 {
     return false;
 }
@@ -1102,3 +1104,479 @@ void NamedAttrMapImpl::removeAttribute(NodeImpl::Id id)
     attr->deref();
 }
 
+// ------------------------------- Styled Element and Mapped Attribute Implementation
+
+CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl() {
+    if (m_entryType != ePersistent)
+        StyledElementImpl::removeMappedAttributeDecl(m_entryType, m_attrName, m_attrValue);
+}
+
+QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >* StyledElementImpl::m_mappedAttributeDecls = 0;
+
+CSSMappedAttributeDeclarationImpl* StyledElementImpl::getMappedAttributeDecl(MappedAttributeEntry entryType, AttributeImpl* attr)
+{
+    if (!m_mappedAttributeDecls)
+        return 0;
+    
+    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
+    if (attrNameDict) {
+        QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = attrNameDict->find((void*)attr->id());
+        if (attrValueDict)
+            return attrValueDict->find(attr->value().implementation());
+    }
+    return 0;
+}
+
+void StyledElementImpl::setMappedAttributeDecl(MappedAttributeEntry entryType, AttributeImpl* attr, CSSMappedAttributeDeclarationImpl* decl)
+{
+    if (!m_mappedAttributeDecls)
+        m_mappedAttributeDecls = new QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >;
+    
+    QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = 0;
+    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
+    if (!attrNameDict) {
+        attrNameDict = new QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >;
+        attrNameDict->setAutoDelete(true);
+        m_mappedAttributeDecls->insert((void*)entryType, attrNameDict);
+    }
+    else
+        attrValueDict = attrNameDict->find((void*)attr->id());
+    if (!attrValueDict) {
+        attrValueDict = new QPtrDict<CSSMappedAttributeDeclarationImpl>;
+        if (entryType == ePersistent)
+            attrValueDict->setAutoDelete(true);
+        attrNameDict->insert((void*)attr->id(), attrValueDict);
+    }
+    attrValueDict->replace(attr->value().implementation(), decl);
+}
+
+void StyledElementImpl::removeMappedAttributeDecl(MappedAttributeEntry entryType, NodeImpl::Id attrName, const AtomicString& attrValue)
+{
+    if (!m_mappedAttributeDecls)
+        return;
+    
+    QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> >* attrNameDict = m_mappedAttributeDecls->find((void*)entryType);
+    if (!attrNameDict)
+        return;
+    QPtrDict<CSSMappedAttributeDeclarationImpl>* attrValueDict = attrNameDict->find((void*)attrName);
+    if (!attrValueDict)
+        return;
+    attrValueDict->remove(attrValue.implementation());
+}
+
+void StyledElementImpl::invalidateStyleAttribute()
+{
+    m_isStyleAttributeValid = false;
+}
+
+void StyledElementImpl::updateStyleAttributeIfNeeded() const
+{
+    if (!m_isStyleAttributeValid) {
+        m_isStyleAttributeValid = true;
+        m_synchronizingStyleAttribute = true;
+        if (m_inlineStyleDecl)
+            const_cast<StyledElementImpl*>(this)->setAttribute(ATTR_STYLE, m_inlineStyleDecl->cssText());
+        m_synchronizingStyleAttribute = false;
+    }
+}
+
+MappedAttributeImpl::~MappedAttributeImpl()
+{
+    if (m_styleDecl)
+        m_styleDecl->deref();
+}
+
+AttributeImpl* MappedAttributeImpl::clone(bool preserveDecl) const
+{
+    return new MappedAttributeImpl(m_id, _value, preserveDecl ? m_styleDecl : 0);
+}
+
+NamedMappedAttrMapImpl::NamedMappedAttrMapImpl(ElementImpl *e)
+:NamedAttrMapImpl(e), m_mappedAttributeCount(0)
+{}
+
+void NamedMappedAttrMapImpl::clearAttributes()
+{
+    m_classList.clear();
+    m_mappedAttributeCount = 0;
+    NamedAttrMapImpl::clearAttributes();
+}
+
+bool NamedMappedAttrMapImpl::isMappedAttributeMap() const
+{
+    return true;
+}
+
+int NamedMappedAttrMapImpl::declCount() const
+{
+    int result = 0;
+    for (uint i = 0; i < length(); i++) {
+        MappedAttributeImpl* attr = attributeItem(i);
+        if (attr->decl())
+            result++;
+    }
+    return result;
+}
+
+bool NamedMappedAttrMapImpl::mapsEquivalent(const NamedMappedAttrMapImpl* otherMap) const
+{
+    // The # of decls must match.
+    if (declCount() != otherMap->declCount())
+        return false;
+    
+    // The values for each decl must match.
+    for (uint i = 0; i < length(); i++) {
+        MappedAttributeImpl* attr = attributeItem(i);
+        if (attr->decl()) {
+            AttributeImpl* otherAttr = otherMap->getAttributeItem(attr->id());
+            if (!otherAttr || (attr->value() != otherAttr->value()))
+                return false;
+        }
+    }
+    return true;
+}
+
+void NamedMappedAttrMapImpl::parseClassAttribute(const DOMString& classStr)
+{
+    m_classList.clear();
+    if (!element->hasClass())
+        return;
+    
+    DOMString classAttr = element->getDocument()->inCompatMode() ? 
+        (classStr.implementation()->isLower() ? classStr : DOMString(classStr.implementation()->lower())) :
+        classStr;
+    
+    if (classAttr.find(' ') == -1 && classAttr.find('\n') == -1)
+        m_classList.setString(AtomicString(classAttr));
+    else {
+        QString val = classAttr.string();
+        val.replace('\n', ' ');
+        QStringList list = QStringList::split(' ', val);
+        
+        AtomicStringList* curr = 0;
+        for (QStringList::Iterator it = list.begin(); it != list.end(); ++it) {
+            const QString& singleClass = *it;
+            if (!singleClass.isEmpty()) {
+                if (curr) {
+                    curr->setNext(new AtomicStringList(AtomicString(singleClass)));
+                    curr = curr->next();
+                }
+                else {
+                    m_classList.setString(AtomicString(singleClass));
+                    curr = &m_classList;
+                }
+            }
+        }
+    }
+}
+
+StyledElementImpl::StyledElementImpl(DocumentPtr *doc)
+    : ElementImpl(doc)
+{
+    m_inlineStyleDecl = 0;
+    m_isStyleAttributeValid = true;
+    m_synchronizingStyleAttribute = false;
+}
+
+StyledElementImpl::~StyledElementImpl()
+{
+    destroyInlineStyleDecl();
+}
+
+AttributeImpl* StyledElementImpl::createAttribute(NodeImpl::Id id, DOMStringImpl* value)
+{
+    return new MappedAttributeImpl(id, value);
+}
+
+void StyledElementImpl::createInlineStyleDecl()
+{
+    m_inlineStyleDecl = new CSSMutableStyleDeclarationImpl;
+    m_inlineStyleDecl->ref();
+    m_inlineStyleDecl->setParent(getDocument()->elementSheet());
+    m_inlineStyleDecl->setNode(this);
+    m_inlineStyleDecl->setStrictParsing(!getDocument()->inCompatMode());
+}
+
+void StyledElementImpl::destroyInlineStyleDecl()
+{
+    if (m_inlineStyleDecl) {
+        m_inlineStyleDecl->setNode(0);
+        m_inlineStyleDecl->setParent(0);
+        m_inlineStyleDecl->deref();
+        m_inlineStyleDecl = 0;
+    }
+}
+
+void StyledElementImpl::attributeChanged(AttributeImpl* attr, bool preserveDecls)
+{
+    MappedAttributeImpl* mappedAttr = static_cast<MappedAttributeImpl*>(attr);
+    if (mappedAttr->decl() && !preserveDecls) {
+        mappedAttr->setDecl(0);
+        setChanged();
+        if (namedAttrMap)
+            static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->declRemoved();
+    }
+
+    bool checkDecl = true;
+    MappedAttributeEntry entry;
+    bool needToParse = mapToEntry(attr->id(), entry);
+    if (preserveDecls) {
+        if (mappedAttr->decl()) {
+            setChanged();
+            if (namedAttrMap)
+                static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->declAdded();
+            checkDecl = false;
+        }
+    }
+    else if (!attr->isNull() && entry != eNone) {
+        CSSMappedAttributeDeclarationImpl* decl = getMappedAttributeDecl(entry, attr);
+        if (decl) {
+            mappedAttr->setDecl(decl);
+            setChanged();
+            if (namedAttrMap)
+                static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->declAdded();
+            checkDecl = false;
+        } else
+            needToParse = true;
+    }
+
+    if (needToParse)
+        parseMappedAttribute(mappedAttr);
+    
+    if (checkDecl && mappedAttr->decl()) {
+        // Add the decl to the table in the appropriate spot.
+        setMappedAttributeDecl(entry, attr, mappedAttr->decl());
+        mappedAttr->decl()->setMappedState(entry, attr->id(), attr->value());
+        mappedAttr->decl()->setParent(0);
+        mappedAttr->decl()->setNode(0);
+        if (namedAttrMap)
+            static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->declAdded();
+    }
+}
+
+bool StyledElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const
+{
+    result = eNone;
+    if (attr == ATTR_STYLE)
+        return !m_synchronizingStyleAttribute;
+    return true;
+}
+
+void StyledElementImpl::parseMappedAttribute(MappedAttributeImpl *attr)
+{
+    switch (attr->id()) {
+    case ATTR_ID:
+        // unique id
+        setHasID(!attr->isNull());
+        if (namedAttrMap) {
+            if (attr->isNull())
+                namedAttrMap->setID(nullAtom);
+            else if (getDocument()->inCompatMode() && !attr->value().implementation()->isLower())
+                namedAttrMap->setID(AtomicString(attr->value().domString().lower()));
+            else
+                namedAttrMap->setID(attr->value());
+        }
+        setChanged();
+        break;
+    case ATTR_CLASS:
+        // class
+        setHasClass(!attr->isNull());
+        if (namedAttrMap) static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->parseClassAttribute(attr->value());
+        setChanged();
+        break;
+    case ATTR_STYLE:
+        setHasStyle(!attr->isNull());
+        if (attr->isNull())
+            destroyInlineStyleDecl();
+        else
+            getInlineStyleDecl()->parseDeclaration(attr->value());
+        m_isStyleAttributeValid = true;
+        setChanged();
+        break;
+    default:
+        break;
+    }
+}
+
+void StyledElementImpl::createAttributeMap() const
+{
+    namedAttrMap = new NamedMappedAttrMapImpl(const_cast<StyledElementImpl*>(this));
+    namedAttrMap->ref();
+}
+
+CSSMutableStyleDeclarationImpl* StyledElementImpl::getInlineStyleDecl()
+{
+    if (!m_inlineStyleDecl)
+        createInlineStyleDecl();
+    return m_inlineStyleDecl;
+}
+
+CSSStyleDeclarationImpl* StyledElementImpl::style()
+{
+    return getInlineStyleDecl();
+}
+
+CSSMutableStyleDeclarationImpl* StyledElementImpl::additionalAttributeStyleDecl()
+{
+    return 0;
+}
+
+const AtomicStringList* StyledElementImpl::getClassList() const
+{
+    return namedAttrMap ? static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->getClassList() : 0;
+}
+
+static inline bool isHexDigit( const QChar &c ) {
+    return ( c >= '0' && c <= '9' ) ||
+          ( c >= 'a' && c <= 'f' ) ||
+          ( c >= 'A' && c <= 'F' );
+}
+
+static inline int toHex( const QChar &c ) {
+    return ( (c >= '0' && c <= '9')
+             ? (c.unicode() - '0')
+             : ( ( c >= 'a' && c <= 'f' )
+                 ? (c.unicode() - 'a' + 10)
+                 : ( ( c >= 'A' && c <= 'F' )
+                     ? (c.unicode() - 'A' + 10)
+                     : -1 ) ) );
+}
+
+void StyledElementImpl::addCSSProperty(MappedAttributeImpl* attr, int id, const DOMString &value)
+{
+    if (!attr->decl()) createMappedDecl(attr);
+    attr->decl()->setProperty(id, value, false);
+}
+
+void StyledElementImpl::addCSSProperty(MappedAttributeImpl* attr, int id, int value)
+{
+    if (!attr->decl()) createMappedDecl(attr);
+    attr->decl()->setProperty(id, value, false);
+}
+
+void StyledElementImpl::addCSSStringProperty(MappedAttributeImpl* attr, int id, const DOMString &value, CSSPrimitiveValue::UnitTypes type)
+{
+    if (!attr->decl()) createMappedDecl(attr);
+    attr->decl()->setStringProperty(id, value, type, false);
+}
+
+void StyledElementImpl::addCSSImageProperty(MappedAttributeImpl* attr, int id, const DOMString &URL)
+{
+    if (!attr->decl()) createMappedDecl(attr);
+    attr->decl()->setImageProperty(id, URL, false);
+}
+
+void StyledElementImpl::addCSSLength(MappedAttributeImpl* attr, int id, const DOMString &value)
+{
+    // FIXME: This function should not spin up the CSS parser, but should instead just figure out the correct
+    // length unit and make the appropriate parsed value.
+    if (!attr->decl()) createMappedDecl(attr);
+
+    // strip attribute garbage..
+    DOMStringImpl* v = value.implementation();
+    if ( v ) {
+        unsigned int l = 0;
+        
+        while ( l < v->l && v->s[l].unicode() <= ' ') l++;
+        
+        for ( ;l < v->l; l++ ) {
+            char cc = v->s[l].latin1();
+            if ( cc > '9' || ( cc < '0' && cc != '*' && cc != '%' && cc != '.') )
+                break;
+        }
+        if ( l != v->l ) {
+            attr->decl()->setLengthProperty(id, DOMString( v->s, l ), false);
+            return;
+        }
+    }
+    
+    attr->decl()->setLengthProperty(id, value, false);
+}
+
+/* color parsing that tries to match as close as possible IE 6. */
+void StyledElementImpl::addCSSColor(MappedAttributeImpl* attr, int id, const DOMString &c)
+{
+    // this is the only case no color gets applied in IE.
+    if ( !c.length() )
+        return;
+
+    if (!attr->decl()) createMappedDecl(attr);
+    
+    if (attr->decl()->setProperty(id, c, false) )
+        return;
+    
+    QString color = c.string();
+    // not something that fits the specs.
+    
+    // we're emulating IEs color parser here. It maps transparent to black, otherwise it tries to build a rgb value
+    // out of everyhting you put in. The algorithm is experimentally determined, but seems to work for all test cases I have.
+    
+    // the length of the color value is rounded up to the next
+    // multiple of 3. each part of the rgb triple then gets one third
+    // of the length.
+    //
+    // Each triplet is parsed byte by byte, mapping
+    // each number to a hex value (0-9a-fA-F to their values
+    // everything else to 0).
+    //
+    // The highest non zero digit in all triplets is remembered, and
+    // used as a normalization point to normalize to values between 0
+    // and 255.
+    
+    if ( color.lower() != "transparent" ) {
+        if ( color[0] == '#' )
+            color.remove( 0,  1 );
+        int basicLength = (color.length() + 2) / 3;
+        if ( basicLength > 1 ) {
+            // IE ignores colors with three digits or less
+            //             qDebug("trying to fix up color '%s'. basicLength=%d, length=%d",
+            //                    color.latin1(), basicLength, color.length() );
+            int colors[3] = { 0, 0, 0 };
+            int component = 0;
+            int pos = 0;
+            int maxDigit = basicLength-1;
+            while ( component < 3 ) {
+                // search forward for digits in the string
+                int numDigits = 0;
+                while ( pos < (int)color.length() && numDigits < basicLength ) {
+                    int hex = toHex( color[pos] );
+                    colors[component] = (colors[component] << 4);
+                    if ( hex > 0 ) {
+                        colors[component] += hex;
+                        maxDigit = kMin( maxDigit, numDigits );
+                    }
+                    numDigits++;
+                    pos++;
+                }
+                while ( numDigits++ < basicLength )
+                    colors[component] <<= 4;
+                component++;
+            }
+            maxDigit = basicLength - maxDigit;
+            //             qDebug("color is %x %x %x, maxDigit=%d",  colors[0], colors[1], colors[2], maxDigit );
+            
+            // normalize to 00-ff. The highest filled digit counts, minimum is 2 digits
+            maxDigit -= 2;
+            colors[0] >>= 4*maxDigit;
+            colors[1] >>= 4*maxDigit;
+            colors[2] >>= 4*maxDigit;
+            //             qDebug("normalized color is %x %x %x",  colors[0], colors[1], colors[2] );
+            //         assert( colors[0] < 0x100 && colors[1] < 0x100 && colors[2] < 0x100 );
+            
+            color.sprintf("#%02x%02x%02x", colors[0], colors[1], colors[2] );
+            //             qDebug( "trying to add fixed color string '%s'", color.latin1() );
+            if ( attr->decl()->setProperty(id, DOMString(color), false) )
+                return;
+        }
+    }
+    attr->decl()->setProperty(id, CSS_VAL_BLACK, false);
+}
+
+void StyledElementImpl::createMappedDecl(MappedAttributeImpl* attr)
+{
+    CSSMappedAttributeDeclarationImpl* decl = new CSSMappedAttributeDeclarationImpl(0);
+    attr->setDecl(decl);
+    decl->setParent(getDocument()->elementSheet());
+    decl->setNode(this);
+    decl->setStrictParsing(false); // Mapped attributes are just always quirky.
+}
index 142587db1e49fd8bd9e6392803b5a84b441ac576..c7e4e10c4eedee1d9ff53d10a69ae06d374b355d 100644 (file)
@@ -30,6 +30,7 @@
 #include "dom/dom_element.h"
 #include "xml/dom_stringimpl.h"
 #include "misc/shared.h"
+#include "css/css_valueimpl.h"
 
 #if APPLE_CHANGES
 #ifdef __OBJC__
@@ -37,6 +38,8 @@
 #endif
 #endif
 
+#include "dom_atomicstringlist.h"
+
 namespace khtml {
     class CSSStyleSelector;
 }
@@ -289,6 +292,7 @@ public:
 
     // DOM methods & attributes for NamedNodeMap
     virtual AttrImpl *getNamedItem ( NodeImpl::Id id ) const;
+
     virtual SharedPtr<NodeImpl> removeNamedItem ( NodeImpl::Id id, int &exceptioncode );
     virtual SharedPtr<NodeImpl> setNamedItem ( NodeImpl* arg, int &exceptioncode );
 
@@ -310,7 +314,7 @@ public:
             newAttribute->deref();
     }
 
-    virtual bool isHTMLAttributeMap() const;
+    virtual bool isMappedAttributeMap() const;
 
     const AtomicString& id() const { return m_id; }
     void setID(const AtomicString& _id) { m_id = _id; }
@@ -330,6 +334,131 @@ protected:
     AtomicString m_id;
 };
 
+enum MappedAttributeEntry { eNone, eUniversal, ePersistent, eReplaced, eBlock, eHR, eUnorderedList, eListItem,
+    eTable, eCell, eCaption, eLastEntry };
+
+class CSSMappedAttributeDeclarationImpl : public CSSMutableStyleDeclarationImpl
+{
+public:
+    CSSMappedAttributeDeclarationImpl(CSSRuleImpl *parentRule)
+    : CSSMutableStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(0)
+    {}
+    
+    virtual ~CSSMappedAttributeDeclarationImpl();
+
+    void setMappedState(MappedAttributeEntry type, NodeImpl::Id attr, const AtomicString& val)
+    {
+        m_entryType = type;
+        m_attrName = attr;
+        m_attrValue = val;
+    }
+
+private:
+    MappedAttributeEntry m_entryType;
+    NodeImpl::Id m_attrName;
+    AtomicString m_attrValue;
+};
+
+class MappedAttributeImpl : public AttributeImpl
+{
+public:
+    MappedAttributeImpl(NodeImpl::Id _id, const AtomicString& value, CSSMappedAttributeDeclarationImpl* decl = 0)
+    : AttributeImpl(_id, value), m_styleDecl(decl)
+    {
+        if (decl)
+            decl->ref();
+    }
+
+    ~MappedAttributeImpl();
+
+    virtual AttributeImpl* clone(bool preserveDecl=true) const;
+
+    CSSMappedAttributeDeclarationImpl* decl() const { return m_styleDecl; }
+    void setDecl(CSSMappedAttributeDeclarationImpl* decl) 
+    { 
+        if (m_styleDecl) m_styleDecl->deref();
+        m_styleDecl = decl;
+        if (m_styleDecl) m_styleDecl->ref();
+    }
+
+private:
+    CSSMappedAttributeDeclarationImpl* m_styleDecl;
+};
+
+class NamedMappedAttrMapImpl : public NamedAttrMapImpl
+{
+public:
+    NamedMappedAttrMapImpl(ElementImpl *e);
+
+    virtual void clearAttributes();
+    
+    virtual bool isMappedAttributeMap() const;
+    
+    virtual void parseClassAttribute(const DOMString& classAttr);
+    const AtomicStringList* getClassList() const { return &m_classList; }
+    
+    virtual bool hasMappedAttributes() const { return m_mappedAttributeCount > 0; }
+    void declRemoved() { m_mappedAttributeCount--; }
+    void declAdded() { m_mappedAttributeCount++; }
+    
+    bool mapsEquivalent(const NamedMappedAttrMapImpl* otherMap) const;
+    int declCount() const;
+
+    MappedAttributeImpl* attributeItem(unsigned long index) const
+    { return attrs ? static_cast<MappedAttributeImpl*>(attrs[index]) : 0; }
+    
+private:
+    AtomicStringList m_classList;
+    int m_mappedAttributeCount;
+};
+
+class StyledElementImpl : public ElementImpl
+{
+public:
+    StyledElementImpl(DocumentPtr *doc);
+    virtual ~StyledElementImpl();
+
+    virtual bool isStyledElement() const { return true; }
+
+    bool hasMappedAttributes() const { return namedAttrMap ? static_cast<NamedMappedAttrMapImpl*>(namedAttrMap)->hasMappedAttributes() : false; }
+    const NamedMappedAttrMapImpl* mappedAttributes() const { return static_cast<NamedMappedAttrMapImpl*>(namedAttrMap); }
+    bool isMappedAttribute(NodeImpl::Id attr) const { MappedAttributeEntry res = eNone; mapToEntry(attr, res); return res != eNone; }
+
+    void addCSSLength(MappedAttributeImpl* attr, int id, const DOMString &value);
+    void addCSSProperty(MappedAttributeImpl* attr, int id, const DOMString &value);
+    void addCSSProperty(MappedAttributeImpl* attr, int id, int value);
+    void addCSSStringProperty(MappedAttributeImpl* attr, int id, const DOMString &value, DOM::CSSPrimitiveValue::UnitTypes = DOM::CSSPrimitiveValue::CSS_STRING);
+    void addCSSImageProperty(MappedAttributeImpl* attr, int id, const DOMString &URL);
+    void addCSSColor(MappedAttributeImpl* attr, int id, const DOMString &c);
+    void createMappedDecl(MappedAttributeImpl* attr);
+    
+    static CSSMappedAttributeDeclarationImpl* getMappedAttributeDecl(MappedAttributeEntry type, AttributeImpl* attr);
+    static void setMappedAttributeDecl(MappedAttributeEntry type, AttributeImpl* attr, CSSMappedAttributeDeclarationImpl* decl);
+    static void removeMappedAttributeDecl(MappedAttributeEntry type, NodeImpl::Id attrName, const AtomicString& attrValue);
+    static QPtrDict<QPtrDict<QPtrDict<CSSMappedAttributeDeclarationImpl> > >* m_mappedAttributeDecls;
+    
+    CSSMutableStyleDeclarationImpl* inlineStyleDecl() const { return m_inlineStyleDecl; }
+    virtual CSSMutableStyleDeclarationImpl* additionalAttributeStyleDecl();
+    CSSMutableStyleDeclarationImpl* getInlineStyleDecl();
+    CSSStyleDeclarationImpl* style();
+    void createInlineStyleDecl();
+    void destroyInlineStyleDecl();
+    void invalidateStyleAttribute();
+    virtual void updateStyleAttributeIfNeeded() const;
+    
+    virtual const AtomicStringList* getClassList() const;
+    virtual void attributeChanged(AttributeImpl* attr, bool preserveDecls = false);
+    virtual void parseMappedAttribute(MappedAttributeImpl* attr);
+    virtual bool mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const;
+    virtual void createAttributeMap() const;
+    virtual AttributeImpl* createAttribute(NodeImpl::Id id, DOMStringImpl* value);
+
+protected:
+    CSSMutableStyleDeclarationImpl* m_inlineStyleDecl;
+    mutable bool m_isStyleAttributeValid : 1;
+    mutable bool m_synchronizingStyleAttribute : 1;
+};
+
 }; //namespace
 
 #if APPLE_CHANGES
index f99ceba25fd552ba16f57acfe6ebc9167d35377d..caacca6551ef4a4b4b105423f06c10fa6d0d9788 100644 (file)
@@ -134,6 +134,7 @@ public:
     // Other methods (not part of DOM)
     virtual bool isElementNode() const { return false; }
     virtual bool isHTMLElement() const { return false; }
+    virtual bool isStyledElement() const { return false; }
     virtual bool isAttributeNode() const { return false; }
     virtual bool isTextNode() const { return false; }
     virtual bool isDocumentNode() const { return false; }