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
HTMLTableElement(const QualifiedName & tagName,Document * document)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
create(Document * document)57 PassRefPtr<HTMLTableElement> HTMLTableElement::create(Document* document)
58 {
59 return adoptRef(new HTMLTableElement(tableTag, document));
60 }
61
create(const QualifiedName & tagName,Document * document)62 PassRefPtr<HTMLTableElement> HTMLTableElement::create(const QualifiedName& tagName, Document* document)
63 {
64 return adoptRef(new HTMLTableElement(tagName, document));
65 }
66
caption() const67 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
setCaption(PassRefPtr<HTMLTableCaptionElement> newCaption,ExceptionCode & ec)76 void HTMLTableElement::setCaption(PassRefPtr<HTMLTableCaptionElement> newCaption, ExceptionCode& ec)
77 {
78 deleteCaption();
79 insertBefore(newCaption, firstChild(), ec);
80 }
81
tHead() const82 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
setTHead(PassRefPtr<HTMLTableSectionElement> newHead,ExceptionCode & ec)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
tFoot() const103 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
setTFoot(PassRefPtr<HTMLTableSectionElement> newFoot,ExceptionCode & ec)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
createTHead()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
deleteTHead()134 void HTMLTableElement::deleteTHead()
135 {
136 ExceptionCode ec;
137 removeChild(tHead(), ec);
138 }
139
createTFoot()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
deleteTFoot()150 void HTMLTableElement::deleteTFoot()
151 {
152 ExceptionCode ec;
153 removeChild(tFoot(), ec);
154 }
155
createCaption()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
deleteCaption()166 void HTMLTableElement::deleteCaption()
167 {
168 ExceptionCode ec;
169 removeChild(caption(), ec);
170 }
171
lastBody() const172 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
insertRow(int index,ExceptionCode & ec)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
deleteRow(int index,ExceptionCode & ec)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
mapToEntry(const QualifiedName & attrName,MappedAttributeEntry & result) const244 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
isTableCellAncestor(Node * n)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
setTableCellsChanged(Node * n)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
parseMappedAttribute(Attribute * attr)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
additionalAttributeStyleDecls(Vector<CSSMutableStyleDeclaration * > & results)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
cellBorders() const478 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
addSharedCellDecls(Vector<CSSMutableStyleDeclaration * > & results)501 void HTMLTableElement::addSharedCellDecls(Vector<CSSMutableStyleDeclaration*>& results)
502 {
503 addSharedCellBordersDecl(results);
504 addSharedCellPaddingDecl(results);
505 }
506
addSharedCellBordersDecl(Vector<CSSMutableStyleDeclaration * > & results)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
addSharedCellPaddingDecl(Vector<CSSMutableStyleDeclaration * > & results)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
addSharedGroupDecls(bool rows,Vector<CSSMutableStyleDeclaration * > & results)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
attach()627 void HTMLTableElement::attach()
628 {
629 ASSERT(!attached());
630 HTMLElement::attach();
631 }
632
isURLAttribute(Attribute * attr) const633 bool HTMLTableElement::isURLAttribute(Attribute *attr) const
634 {
635 return attr->name() == backgroundAttr;
636 }
637
rows()638 PassRefPtr<HTMLCollection> HTMLTableElement::rows()
639 {
640 return HTMLTableRowsCollection::create(this);
641 }
642
tBodies()643 PassRefPtr<HTMLCollection> HTMLTableElement::tBodies()
644 {
645 return HTMLCollection::create(this, TableTBodies);
646 }
647
rules() const648 String HTMLTableElement::rules() const
649 {
650 return getAttribute(rulesAttr);
651 }
652
summary() const653 String HTMLTableElement::summary() const
654 {
655 return getAttribute(summaryAttr);
656 }
657
addSubresourceAttributeURLs(ListHashSet<KURL> & urls) const658 void HTMLTableElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
659 {
660 HTMLElement::addSubresourceAttributeURLs(urls);
661
662 addSubresourceURL(urls, document()->completeURL(getAttribute(backgroundAttr)));
663 }
664
665 }
666