code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/html/HTMLTableElement.cpp

   1 /*
   2  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
   3  *           (C) 1997 Torben Weis (weis@kde.org)
   4  *           (C) 1998 Waldo Bastian (bastian@kde.org)
   5  *           (C) 1999 Lars Knoll (knoll@kde.org)
   6  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   7  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2010 Apple Inc. All rights reserved.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 #include "config.h"
  26 #include "HTMLTableElement.h"
  27
  28 #include "Attribute.h"
  29 #include "CSSPropertyNames.h"
  30 #include "CSSStyleSheet.h"
  31 #include "CSSValueKeywords.h"
  32 #include "ExceptionCode.h"
  33 #include "HTMLNames.h"
  34 #include "HTMLParserIdioms.h"
  35 #include "HTMLTableCaptionElement.h"
  36 #include "HTMLTableRowElement.h"
  37 #include "HTMLTableRowsCollection.h"
  38 #include "HTMLTableSectionElement.h"
  39 #include "RenderTable.h"
  40 #include "Text.h"
  41
  42 namespace WebCore {
  43
  44 using namespace HTMLNames;
  45
  46 HTMLTableElement::HTMLTableElement(const QualifiedName& tagName, Document* document)
  47     : HTMLElement(tagName, document)
  48     , m_borderAttr(false)
  49     , m_borderColorAttr(false)
  50     , m_frameAttr(false)
  51     , m_rulesAttr(UnsetRules)
  52     , m_padding(1)
  53 {
  54     ASSERT(hasTagName(tableTag));
  55 }
  56
  57 PassRefPtr<HTMLTableElement> HTMLTableElement::create(Document* document)
  58 {
  59     return adoptRef(new HTMLTableElement(tableTag, document));
  60 }
  61
  62 PassRefPtr<HTMLTableElement> HTMLTableElement::create(const QualifiedName& tagName, Document* document)
  63 {
  64     return adoptRef(new HTMLTableElement(tagName, document));
  65 }
  66
  67 HTMLTableCaptionElement* HTMLTableElement::caption() const
  68 {
  69     for (Node* child = firstChild(); child; child = child->nextSibling()) {
  70         if (child->hasTagName(captionTag))
  71             return static_cast<HTMLTableCaptionElement*>(child);
  72     }
  73     return 0;
  74 }
  75
  76 void HTMLTableElement::setCaption(PassRefPtr<HTMLTableCaptionElement> newCaption, ExceptionCode& ec)
  77 {
  78     deleteCaption();
  79     insertBefore(newCaption, firstChild(), ec);
  80 }
  81
  82 HTMLTableSectionElement* HTMLTableElement::tHead() const
  83 {
  84     for (Node* child = firstChild(); child; child = child->nextSibling()) {
  85         if (child->hasTagName(theadTag))
  86             return static_cast<HTMLTableSectionElement*>(child);
  87     }
  88     return 0;
  89 }
  90
  91 void HTMLTableElement::setTHead(PassRefPtr<HTMLTableSectionElement> newHead, ExceptionCode& ec)
  92 {
  93     deleteTHead();
  94
  95     Node* child;
  96     for (child = firstChild(); child; child = child->nextSibling())
  97         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
  98             break;
  99
 100     insertBefore(newHead, child, ec);
 101 }
 102
 103 HTMLTableSectionElement* HTMLTableElement::tFoot() const
 104 {
 105     for (Node* child = firstChild(); child; child = child->nextSibling()) {
 106         if (child->hasTagName(tfootTag))
 107             return static_cast<HTMLTableSectionElement*>(child);
 108     }
 109     return 0;
 110 }
 111
 112 void HTMLTableElement::setTFoot(PassRefPtr<HTMLTableSectionElement> newFoot, ExceptionCode& ec)
 113 {
 114     deleteTFoot();
 115
 116     Node* child;
 117     for (child = firstChild(); child; child = child->nextSibling())
 118         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
 119             break;
 120
 121     insertBefore(newFoot, child, ec);
 122 }
 123
 124 PassRefPtr<HTMLElement> HTMLTableElement::createTHead()
 125 {
 126     if (HTMLTableSectionElement* existingHead = tHead())
 127         return existingHead;
 128     RefPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
 129     ExceptionCode ec;
 130     setTHead(head, ec);
 131     return head.release();
 132 }
 133
 134 void HTMLTableElement::deleteTHead()
 135 {
 136     ExceptionCode ec;
 137     removeChild(tHead(), ec);
 138 }
 139
 140 PassRefPtr<HTMLElement> HTMLTableElement::createTFoot()
 141 {
 142     if (HTMLTableSectionElement* existingFoot = tFoot())
 143         return existingFoot;
 144     RefPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
 145     ExceptionCode ec;
 146     setTFoot(foot, ec);
 147     return foot.release();
 148 }
 149
 150 void HTMLTableElement::deleteTFoot()
 151 {
 152     ExceptionCode ec;
 153     removeChild(tFoot(), ec);
 154 }
 155
 156 PassRefPtr<HTMLElement> HTMLTableElement::createCaption()
 157 {
 158     if (HTMLTableCaptionElement* existingCaption = caption())
 159         return existingCaption;
 160     RefPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(captionTag, document());
 161     ExceptionCode ec;
 162     setCaption(caption, ec);
 163     return caption.release();
 164 }
 165
 166 void HTMLTableElement::deleteCaption()
 167 {
 168     ExceptionCode ec;
 169     removeChild(caption(), ec);
 170 }
 171
 172 HTMLTableSectionElement* HTMLTableElement::lastBody() const
 173 {
 174     for (Node* child = lastChild(); child; child = child->previousSibling()) {
 175         if (child->hasTagName(tbodyTag))
 176             return static_cast<HTMLTableSectionElement*>(child);
 177     }
 178     return 0;
 179 }
 180
 181 PassRefPtr<HTMLElement> HTMLTableElement::insertRow(int index, ExceptionCode& ec)
 182 {
 183     if (index < -1) {
 184         ec = INDEX_SIZE_ERR;
 185         return 0;
 186     }
 187
 188     HTMLTableRowElement* lastRow = 0;
 189     HTMLTableRowElement* row = 0;
 190     if (index == -1)
 191         lastRow = HTMLTableRowsCollection::lastRow(this);
 192     else {
 193         for (int i = 0; i <= index; ++i) {
 194             row = HTMLTableRowsCollection::rowAfter(this, lastRow);
 195             if (!row) {
 196                 if (i != index) {
 197                     ec = INDEX_SIZE_ERR;
 198                     return 0;
 199                 }
 200                 break;
 201             }
 202             lastRow = row;
 203         }
 204     }
 205
 206     ContainerNode* parent;
 207     if (lastRow)
 208         parent = row ? row->parentNode() : lastRow->parentNode();
 209     else {
 210         parent = lastBody();
 211         if (!parent) {
 212             RefPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
 213             RefPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
 214             newBody->appendChild(newRow, ec);
 215             appendChild(newBody.release(), ec);
 216             return newRow.release();
 217         }
 218     }
 219
 220     RefPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
 221     parent->insertBefore(newRow, row, ec);
 222     return newRow.release();
 223 }
 224
 225 void HTMLTableElement::deleteRow(int index, ExceptionCode& ec)
 226 {
 227     HTMLTableRowElement* row = 0;
 228     if (index == -1)
 229         row = HTMLTableRowsCollection::lastRow(this);
 230     else {
 231         for (int i = 0; i <= index; ++i) {
 232             row = HTMLTableRowsCollection::rowAfter(this, row);
 233             if (!row)
 234                 break;
 235         }
 236     }
 237     if (!row) {
 238         ec = INDEX_SIZE_ERR;
 239         return;
 240     }
 241     row->remove(ec);
 242 }
 243
 244 bool HTMLTableElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
 245 {
 246     if (attrName == backgroundAttr) {
 247         result = (MappedAttributeEntry)(eLastEntry + document()->docID());
 248         return false;
 249     }
 250
 251     if (attrName == widthAttr ||
 252         attrName == heightAttr ||
 253         attrName == bgcolorAttr ||
 254         attrName == cellspacingAttr ||
 255         attrName == vspaceAttr ||
 256         attrName == hspaceAttr ||
 257         attrName == valignAttr) {
 258         result = eUniversal;
 259         return false;
 260     }
 261
 262     if (attrName == bordercolorAttr || attrName == frameAttr || attrName == rulesAttr) {
 263         result = eUniversal;
 264         return true;
 265     }
 266
 267     if (attrName == borderAttr) {
 268         result = eTable;
 269         return true;
 270     }
 271
 272     if (attrName == alignAttr) {
 273         result = eTable;
 274         return false;
 275     }
 276
 277     return HTMLElement::mapToEntry(attrName, result);
 278 }
 279
 280 static inline bool isTableCellAncestor(Node* n)
 281 {
 282     return n->hasTagName(theadTag) || n->hasTagName(tbodyTag) ||
 283            n->hasTagName(tfootTag) || n->hasTagName(trTag) ||
 284            n->hasTagName(thTag);
 285 }
 286
 287 static bool setTableCellsChanged(Node* n)
 288 {
 289     ASSERT(n);
 290     bool cellChanged = false;
 291
 292     if (n->hasTagName(tdTag))
 293         cellChanged = true;
 294     else if (isTableCellAncestor(n)) {
 295         for (Node* child = n->firstChild(); child; child = child->nextSibling())
 296             cellChanged |= setTableCellsChanged(child);
 297     }
 298
 299     if (cellChanged)
 300        n->setNeedsStyleRecalc();
 301
 302     return cellChanged;
 303 }
 304
 305 void HTMLTableElement::parseMappedAttribute(Attribute* attr)
 306 {
 307     CellBorders bordersBefore = cellBorders();
 308     unsigned short oldPadding = m_padding;
 309
 310     if (attr->name() == widthAttr)
 311         addCSSLength(attr, CSSPropertyWidth, attr->value());
 312     else if (attr->name() == heightAttr)
 313         addCSSLength(attr, CSSPropertyHeight, attr->value());
 314     else if (attr->name() == borderAttr)  {
 315         m_borderAttr = true;
 316         if (attr->decl()) {
 317             RefPtr<CSSValue> val = attr->decl()->getPropertyCSSValue(CSSPropertyBorderLeftWidth);
 318             if (val && val->isPrimitiveValue()) {
 319                 CSSPrimitiveValue* primVal = static_cast<CSSPrimitiveValue*>(val.get());
 320                 m_borderAttr = primVal->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
 321             }
 322         } else if (!attr->isNull()) {
 323             int border = 0;
 324             if (attr->isEmpty())
 325                 border = 1;
 326             else
 327                 border = attr->value().toInt();
 328             m_borderAttr = border;
 329             addCSSLength(attr, CSSPropertyBorderWidth, String::number(border));
 330         }
 331     } else if (attr->name() == bgcolorAttr)
 332         addCSSColor(attr, CSSPropertyBackgroundColor, attr->value());
 333     else if (attr->name() == bordercolorAttr) {
 334         m_borderColorAttr = attr->decl();
 335         if (!attr->decl() && !attr->isEmpty()) {
 336             addCSSColor(attr, CSSPropertyBorderColor, attr->value());
 337             m_borderColorAttr = true;
 338         }
 339     } else if (attr->name() == backgroundAttr) {
 340         String url = stripLeadingAndTrailingHTMLSpaces(attr->value());
 341         if (!url.isEmpty())
 342             addCSSImageProperty(attr, CSSPropertyBackgroundImage, document()->completeURL(url).string());
 343     } else if (attr->name() == frameAttr) {
 344         // Cache the value of "frame" so that the table can examine it later.
 345         m_frameAttr = false;
 346
 347         // Whether or not to hide the top/right/bottom/left borders.
 348         const int cTop = 0;
 349         const int cRight = 1;
 350         const int cBottom = 2;
 351         const int cLeft = 3;
 352         bool borders[4] = { false, false, false, false };
 353
 354         // void, above, below, hsides, vsides, lhs, rhs, box, border
 355         if (equalIgnoringCase(attr->value(), "void"))
 356             m_frameAttr = true;
 357         else if (equalIgnoringCase(attr->value(), "above")) {
 358             m_frameAttr = true;
 359             borders[cTop] = true;
 360         } else if (equalIgnoringCase(attr->value(), "below")) {
 361             m_frameAttr = true;
 362             borders[cBottom] = true;
 363         } else if (equalIgnoringCase(attr->value(), "hsides")) {
 364             m_frameAttr = true;
 365             borders[cTop] = borders[cBottom] = true;
 366         } else if (equalIgnoringCase(attr->value(), "vsides")) {
 367             m_frameAttr = true;
 368             borders[cLeft] = borders[cRight] = true;
 369         } else if (equalIgnoringCase(attr->value(), "lhs")) {
 370             m_frameAttr = true;
 371             borders[cLeft] = true;
 372         } else if (equalIgnoringCase(attr->value(), "rhs")) {
 373             m_frameAttr = true;
 374             borders[cRight] = true;
 375         } else if (equalIgnoringCase(attr->value(), "box") ||
 376                    equalIgnoringCase(attr->value(), "border")) {
 377             m_frameAttr = true;
 378             borders[cTop] = borders[cBottom] = borders[cLeft] = borders[cRight] = true;
 379         }
 380
 381         // Now map in the border styles of solid and hidden respectively.
 382         if (m_frameAttr) {
 383             addCSSProperty(attr, CSSPropertyBorderTopWidth, CSSValueThin);
 384             addCSSProperty(attr, CSSPropertyBorderBottomWidth, CSSValueThin);
 385             addCSSProperty(attr, CSSPropertyBorderLeftWidth, CSSValueThin);
 386             addCSSProperty(attr, CSSPropertyBorderRightWidth, CSSValueThin);
 387             addCSSProperty(attr, CSSPropertyBorderTopStyle, borders[cTop] ? CSSValueSolid : CSSValueHidden);
 388             addCSSProperty(attr, CSSPropertyBorderBottomStyle, borders[cBottom] ? CSSValueSolid : CSSValueHidden);
 389             addCSSProperty(attr, CSSPropertyBorderLeftStyle, borders[cLeft] ? CSSValueSolid : CSSValueHidden);
 390             addCSSProperty(attr, CSSPropertyBorderRightStyle, borders[cRight] ? CSSValueSolid : CSSValueHidden);
 391         }
 392     } else if (attr->name() == rulesAttr) {
 393         m_rulesAttr = UnsetRules;
 394         if (equalIgnoringCase(attr->value(), "none"))
 395             m_rulesAttr = NoneRules;
 396         else if (equalIgnoringCase(attr->value(), "groups"))
 397             m_rulesAttr = GroupsRules;
 398         else if (equalIgnoringCase(attr->value(), "rows"))
 399             m_rulesAttr = RowsRules;
 400         if (equalIgnoringCase(attr->value(), "cols"))
 401             m_rulesAttr = ColsRules;
 402         if (equalIgnoringCase(attr->value(), "all"))
 403             m_rulesAttr = AllRules;
 404
 405         // The presence of a valid rules attribute causes border collapsing to be enabled.
 406         if (m_rulesAttr != UnsetRules)
 407             addCSSProperty(attr, CSSPropertyBorderCollapse, CSSValueCollapse);
 408     } else if (attr->name() == cellspacingAttr) {
 409         if (!attr->value().isEmpty())
 410             addCSSLength(attr, CSSPropertyBorderSpacing, attr->value());
 411     } else if (attr->name() == cellpaddingAttr) {
 412         if (!attr->value().isEmpty())
 413             m_padding = max(0, attr->value().toInt());
 414         else
 415             m_padding = 1;
 416     } else if (attr->name() == colsAttr) {
 417         // ###
 418     } else if (attr->name() == vspaceAttr) {
 419         addCSSLength(attr, CSSPropertyMarginTop, attr->value());
 420         addCSSLength(attr, CSSPropertyMarginBottom, attr->value());
 421     } else if (attr->name() == hspaceAttr) {
 422         addCSSLength(attr, CSSPropertyMarginLeft, attr->value());
 423         addCSSLength(attr, CSSPropertyMarginRight, attr->value());
 424     } else if (attr->name() == alignAttr) {
 425         if (!attr->value().isEmpty()) {
 426             if (equalIgnoringCase(attr->value(), "center")) {
 427                 addCSSProperty(attr, CSSPropertyWebkitMarginStart, CSSValueAuto);
 428                 addCSSProperty(attr, CSSPropertyWebkitMarginEnd, CSSValueAuto);
 429             } else
 430                 addCSSProperty(attr, CSSPropertyFloat, attr->value());
 431         }
 432     } else if (attr->name() == valignAttr) {
 433         if (!attr->value().isEmpty())
 434             addCSSProperty(attr, CSSPropertyVerticalAlign, attr->value());
 435     } else
 436         HTMLElement::parseMappedAttribute(attr);
 437
 438     if (bordersBefore != cellBorders() || oldPadding != m_padding) {
 439         if (oldPadding != m_padding)
 440             m_paddingDecl = 0;
 441         bool cellChanged = false;
 442         for (Node* child = firstChild(); child; child = child->nextSibling())
 443             cellChanged |= setTableCellsChanged(child);
 444         if (cellChanged)
 445             setNeedsStyleRecalc();
 446     }
 447 }
 448
 449 void HTMLTableElement::additionalAttributeStyleDecls(Vector<CSSMutableStyleDeclaration*>& results)
 450 {
 451     if ((!m_borderAttr && !m_borderColorAttr) || m_frameAttr)
 452         return;
 453
 454     AtomicString borderValue = m_borderColorAttr ? "solid" : "outset";
 455     CSSMappedAttributeDeclaration* decl = getMappedAttributeDecl(ePersistent, tableborderAttr, borderValue);
 456     if (!decl) {
 457         decl = CSSMappedAttributeDeclaration::create().releaseRef(); // This single ref pins us in the table until the document dies.
 458         decl->setParent(document()->elementSheet());
 459         decl->setNode(this);
 460         decl->setStrictParsing(false); // Mapped attributes are just always quirky.
 461
 462         int v = m_borderColorAttr ? CSSValueSolid : CSSValueOutset;
 463         decl->setProperty(CSSPropertyBorderTopStyle, v, false);
 464         decl->setProperty(CSSPropertyBorderBottomStyle, v, false);
 465         decl->setProperty(CSSPropertyBorderLeftStyle, v, false);
 466         decl->setProperty(CSSPropertyBorderRightStyle, v, false);
 467
 468         setMappedAttributeDecl(ePersistent, tableborderAttr, borderValue, decl);
 469         decl->setParent(0);
 470         decl->setNode(0);
 471         decl->setMappedState(ePersistent, tableborderAttr, borderValue);
 472     }
 473
 474
 475     results.append(decl);
 476 }
 477
 478 HTMLTableElement::CellBorders HTMLTableElement::cellBorders() const
 479 {
 480     switch (m_rulesAttr) {
 481         case NoneRules:
 482         case GroupsRules:
 483             return NoBorders;
 484         case AllRules:
 485             return SolidBorders;
 486         case ColsRules:
 487             return SolidBordersColsOnly;
 488         case RowsRules:
 489             return SolidBordersRowsOnly;
 490         case UnsetRules:
 491             if (!m_borderAttr)
 492                 return NoBorders;
 493             if (m_borderColorAttr)
 494                 return SolidBorders;
 495             return InsetBorders;
 496     }
 497     ASSERT_NOT_REACHED();
 498     return NoBorders;
 499 }
 500
 501 void HTMLTableElement::addSharedCellDecls(Vector<CSSMutableStyleDeclaration*>& results)
 502 {
 503     addSharedCellBordersDecl(results);
 504     addSharedCellPaddingDecl(results);
 505 }
 506
 507 void HTMLTableElement::addSharedCellBordersDecl(Vector<CSSMutableStyleDeclaration*>& results)
 508 {
 509     CellBorders borders = cellBorders();
 510
 511     static const AtomicString* cellBorderNames[] = { new AtomicString("none"), new AtomicString("solid"), new AtomicString("inset"), new AtomicString("solid-cols"), new AtomicString("solid-rows") };
 512     const AtomicString& cellborderValue = *cellBorderNames[borders];
 513     CSSMappedAttributeDeclaration* decl = getMappedAttributeDecl(ePersistent, cellborderAttr, cellborderValue);
 514     if (!decl) {
 515         decl = CSSMappedAttributeDeclaration::create().releaseRef(); // This single ref pins us in the table until the document dies.
 516         decl->setParent(document()->elementSheet());
 517         decl->setNode(this);
 518         decl->setStrictParsing(false); // Mapped attributes are just always quirky.
 519
 520         switch (borders) {
 521             case SolidBordersColsOnly:
 522                 decl->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin, false);
 523                 decl->setProperty(CSSPropertyBorderRightWidth, CSSValueThin, false);
 524                 decl->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid, false);
 525                 decl->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid, false);
 526                 decl->setProperty(CSSPropertyBorderColor, "inherit", false);
 527                 break;
 528             case SolidBordersRowsOnly:
 529                 decl->setProperty(CSSPropertyBorderTopWidth, CSSValueThin, false);
 530                 decl->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin, false);
 531                 decl->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid, false);
 532                 decl->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid, false);
 533                 decl->setProperty(CSSPropertyBorderColor, "inherit", false);
 534                 break;
 535             case SolidBorders:
 536                 decl->setProperty(CSSPropertyBorderWidth, "1px", false);
 537                 decl->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid, false);
 538                 decl->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid, false);
 539                 decl->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid, false);
 540                 decl->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid, false);
 541                 decl->setProperty(CSSPropertyBorderColor, "inherit", false);
 542                 break;
 543             case InsetBorders:
 544                 decl->setProperty(CSSPropertyBorderWidth, "1px", false);
 545                 decl->setProperty(CSSPropertyBorderTopStyle, CSSValueInset, false);
 546                 decl->setProperty(CSSPropertyBorderBottomStyle, CSSValueInset, false);
 547                 decl->setProperty(CSSPropertyBorderLeftStyle, CSSValueInset, false);
 548                 decl->setProperty(CSSPropertyBorderRightStyle, CSSValueInset, false);
 549                 decl->setProperty(CSSPropertyBorderColor, "inherit", false);
 550                 break;
 551             case NoBorders:
 552                 decl->setProperty(CSSPropertyBorderWidth, "0", false);
 553                 break;
 554         }
 555
 556         setMappedAttributeDecl(ePersistent, cellborderAttr, *cellBorderNames[borders], decl);
 557         decl->setParent(0);
 558         decl->setNode(0);
 559         decl->setMappedState(ePersistent, cellborderAttr, cellborderValue);
 560     }
 561
 562     results.append(decl);
 563 }
 564
 565 void HTMLTableElement::addSharedCellPaddingDecl(Vector<CSSMutableStyleDeclaration*>& results)
 566 {
 567     if (m_padding == 0)
 568         return;
 569
 570     if (!m_paddingDecl) {
 571         String paddingValue = String::number(m_padding);
 572         m_paddingDecl = getMappedAttributeDecl(eUniversal, cellpaddingAttr, paddingValue);
 573         if (!m_paddingDecl) {
 574             m_paddingDecl = CSSMappedAttributeDeclaration::create();
 575             m_paddingDecl->setParent(document()->elementSheet());
 576             m_paddingDecl->setNode(this);
 577             m_paddingDecl->setStrictParsing(false); // Mapped attributes are just always quirky.
 578
 579             m_paddingDecl->setProperty(CSSPropertyPaddingTop, paddingValue, false);
 580             m_paddingDecl->setProperty(CSSPropertyPaddingRight, paddingValue, false);
 581             m_paddingDecl->setProperty(CSSPropertyPaddingBottom, paddingValue, false);
 582             m_paddingDecl->setProperty(CSSPropertyPaddingLeft, paddingValue, false);
 583         }
 584         setMappedAttributeDecl(eUniversal, cellpaddingAttr, paddingValue, m_paddingDecl.get());
 585         m_paddingDecl->setParent(0);
 586         m_paddingDecl->setNode(0);
 587         m_paddingDecl->setMappedState(eUniversal, cellpaddingAttr, paddingValue);
 588     }
 589
 590     results.append(m_paddingDecl.get());
 591 }
 592
 593 void HTMLTableElement::addSharedGroupDecls(bool rows, Vector<CSSMutableStyleDeclaration*>& results)
 594 {
 595     if (m_rulesAttr != GroupsRules)
 596         return;
 597
 598     AtomicString rulesValue = rows ? "rowgroups" : "colgroups";
 599     CSSMappedAttributeDeclaration* decl = getMappedAttributeDecl(ePersistent, rulesAttr, rulesValue);
 600     if (!decl) {
 601         decl = CSSMappedAttributeDeclaration::create().releaseRef(); // This single ref pins us in the table until the document dies.
 602         decl->setParent(document()->elementSheet());
 603         decl->setNode(this);
 604         decl->setStrictParsing(false); // Mapped attributes are just always quirky.
 605
 606         if (rows) {
 607             decl->setProperty(CSSPropertyBorderTopWidth, CSSValueThin, false);
 608             decl->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin, false);
 609             decl->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid, false);
 610             decl->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid, false);
 611         } else {
 612             decl->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin, false);
 613             decl->setProperty(CSSPropertyBorderRightWidth, CSSValueThin, false);
 614             decl->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid, false);
 615             decl->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid, false);
 616         }
 617
 618         setMappedAttributeDecl(ePersistent, rulesAttr, rulesValue, decl);
 619         decl->setParent(0);
 620         decl->setNode(0);
 621         decl->setMappedState(ePersistent, rulesAttr, rulesValue);
 622     }
 623
 624     results.append(decl);
 625 }
 626
 627 CollectionCache* HTMLTableElement::collectionCache() const
 628 {
 629     if (!m_collectionCache)
 630         m_collectionCache = adoptPtr(new CollectionCache());
 631
 632     return m_collectionCache.get();
 633 }
 634
 635 void HTMLTableElement::attach()
 636 {
 637     ASSERT(!attached());
 638     HTMLElement::attach();
 639 }
 640
 641 bool HTMLTableElement::isURLAttribute(Attribute *attr) const
 642 {
 643     return attr->name() == backgroundAttr;
 644 }
 645
 646 PassRefPtr<HTMLCollection> HTMLTableElement::rows()
 647 {
 648     return HTMLTableRowsCollection::create(this);
 649 }
 650
 651 PassRefPtr<HTMLCollection> HTMLTableElement::tBodies()
 652 {
 653     return HTMLCollection::create(this, TableTBodies);
 654 }
 655
 656 String HTMLTableElement::rules() const
 657 {
 658     return getAttribute(rulesAttr);
 659 }
 660
 661 String HTMLTableElement::summary() const
 662 {
 663     return getAttribute(summaryAttr);
 664 }
 665
 666 void HTMLTableElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 667 {
 668     HTMLElement::addSubresourceAttributeURLs(urls);
 669
 670     addSubresourceURL(urls, document()->completeURL(getAttribute(backgroundAttr)));
 671 }
 672
 673 }