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, 2011 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 "core/html/HTMLTableElement.h"
27
28 #include "bindings/core/v8/ExceptionState.h"
29 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
30 #include "core/CSSPropertyNames.h"
31 #include "core/CSSValueKeywords.h"
32 #include "core/HTMLNames.h"
33 #include "core/css/CSSImageValue.h"
34 #include "core/css/CSSValuePool.h"
35 #include "core/css/StylePropertySet.h"
36 #include "core/dom/Attribute.h"
37 #include "core/dom/ElementTraversal.h"
38 #include "core/dom/ExceptionCode.h"
39 #include "core/dom/NodeListsNodeData.h"
40 #include "core/frame/UseCounter.h"
41 #include "core/html/HTMLTableCaptionElement.h"
42 #include "core/html/HTMLTableCellElement.h"
43 #include "core/html/HTMLTableRowElement.h"
44 #include "core/html/HTMLTableRowsCollection.h"
45 #include "core/html/HTMLTableSectionElement.h"
46 #include "core/html/parser/HTMLParserIdioms.h"
47 #include "core/rendering/RenderTable.h"
48 #include "platform/weborigin/Referrer.h"
49 #include "wtf/StdLibExtras.h"
50
51 namespace blink {
52
53 using namespace HTMLNames;
54
HTMLTableElement(Document & document)55 inline HTMLTableElement::HTMLTableElement(Document& document)
56 : HTMLElement(tableTag, document)
57 , m_borderAttr(false)
58 , m_borderColorAttr(false)
59 , m_frameAttr(false)
60 , m_rulesAttr(UnsetRules)
61 , m_padding(1)
62 {
63 }
64
DEFINE_NODE_FACTORY(HTMLTableElement)65 DEFINE_NODE_FACTORY(HTMLTableElement)
66
67 HTMLTableCaptionElement* HTMLTableElement::caption() const
68 {
69 return Traversal<HTMLTableCaptionElement>::firstChild(*this);
70 }
71
setCaption(PassRefPtrWillBeRawPtr<HTMLTableCaptionElement> newCaption,ExceptionState & exceptionState)72 void HTMLTableElement::setCaption(PassRefPtrWillBeRawPtr<HTMLTableCaptionElement> newCaption, ExceptionState& exceptionState)
73 {
74 deleteCaption();
75 insertBefore(newCaption, firstChild(), exceptionState);
76 }
77
tHead() const78 HTMLTableSectionElement* HTMLTableElement::tHead() const
79 {
80 return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(theadTag)));
81 }
82
setTHead(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newHead,ExceptionState & exceptionState)83 void HTMLTableElement::setTHead(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newHead, ExceptionState& exceptionState)
84 {
85 deleteTHead();
86
87 HTMLElement* child;
88 for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
89 if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
90 break;
91 }
92
93 insertBefore(newHead, child, exceptionState);
94 }
95
tFoot() const96 HTMLTableSectionElement* HTMLTableElement::tFoot() const
97 {
98 return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(tfootTag)));
99 }
100
setTFoot(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newFoot,ExceptionState & exceptionState)101 void HTMLTableElement::setTFoot(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newFoot, ExceptionState& exceptionState)
102 {
103 deleteTFoot();
104
105 HTMLElement* child;
106 for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
107 if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
108 break;
109 }
110
111 insertBefore(newFoot, child, exceptionState);
112 }
113
createTHead()114 PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTHead()
115 {
116 if (HTMLTableSectionElement* existingHead = tHead())
117 return existingHead;
118 RefPtrWillBeRawPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
119 setTHead(head, IGNORE_EXCEPTION);
120 return head.release();
121 }
122
deleteTHead()123 void HTMLTableElement::deleteTHead()
124 {
125 removeChild(tHead(), IGNORE_EXCEPTION);
126 }
127
createTFoot()128 PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTFoot()
129 {
130 if (HTMLTableSectionElement* existingFoot = tFoot())
131 return existingFoot;
132 RefPtrWillBeRawPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
133 setTFoot(foot, IGNORE_EXCEPTION);
134 return foot.release();
135 }
136
deleteTFoot()137 void HTMLTableElement::deleteTFoot()
138 {
139 removeChild(tFoot(), IGNORE_EXCEPTION);
140 }
141
createTBody()142 PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTBody()
143 {
144 RefPtrWillBeRawPtr<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
145 Node* referenceElement = lastBody() ? lastBody()->nextSibling() : 0;
146
147 insertBefore(body, referenceElement);
148 return body.release();
149 }
150
createCaption()151 PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createCaption()
152 {
153 if (HTMLTableCaptionElement* existingCaption = caption())
154 return existingCaption;
155 RefPtrWillBeRawPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(document());
156 setCaption(caption, IGNORE_EXCEPTION);
157 return caption.release();
158 }
159
deleteCaption()160 void HTMLTableElement::deleteCaption()
161 {
162 removeChild(caption(), IGNORE_EXCEPTION);
163 }
164
lastBody() const165 HTMLTableSectionElement* HTMLTableElement::lastBody() const
166 {
167 return toHTMLTableSectionElement(Traversal<HTMLElement>::lastChild(*this, HasHTMLTagName(tbodyTag)));
168 }
169
insertRow(int index,ExceptionState & exceptionState)170 PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::insertRow(int index, ExceptionState& exceptionState)
171 {
172 if (index < -1) {
173 exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
174 return nullptr;
175 }
176
177 RefPtrWillBeRawPtr<Node> protectFromMutationEvents(this);
178
179 RefPtrWillBeRawPtr<HTMLTableRowElement> lastRow = nullptr;
180 RefPtrWillBeRawPtr<HTMLTableRowElement> row = nullptr;
181 if (index == -1)
182 lastRow = HTMLTableRowsCollection::lastRow(*this);
183 else {
184 for (int i = 0; i <= index; ++i) {
185 row = HTMLTableRowsCollection::rowAfter(*this, lastRow.get());
186 if (!row) {
187 if (i != index) {
188 exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than the number of rows in the table (" + String::number(i) + ").");
189 return nullptr;
190 }
191 break;
192 }
193 lastRow = row;
194 }
195 }
196
197 RefPtrWillBeRawPtr<ContainerNode> parent;
198 if (lastRow)
199 parent = row ? row->parentNode() : lastRow->parentNode();
200 else {
201 parent = lastBody();
202 if (!parent) {
203 RefPtrWillBeRawPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
204 RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
205 newBody->appendChild(newRow, exceptionState);
206 appendChild(newBody.release(), exceptionState);
207 return newRow.release();
208 }
209 }
210
211 RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
212 parent->insertBefore(newRow, row.get(), exceptionState);
213 return newRow.release();
214 }
215
deleteRow(int index,ExceptionState & exceptionState)216 void HTMLTableElement::deleteRow(int index, ExceptionState& exceptionState)
217 {
218 if (index < -1) {
219 exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
220 return;
221 }
222
223 HTMLTableRowElement* row = 0;
224 int i = 0;
225 if (index == -1)
226 row = HTMLTableRowsCollection::lastRow(*this);
227 else {
228 for (i = 0; i <= index; ++i) {
229 row = HTMLTableRowsCollection::rowAfter(*this, row);
230 if (!row)
231 break;
232 }
233 }
234 if (!row) {
235 exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than the number of rows in the table (" + String::number(i) + ").");
236 return;
237 }
238 row->remove(exceptionState);
239 }
240
setNeedsTableStyleRecalc() const241 void HTMLTableElement::setNeedsTableStyleRecalc() const
242 {
243 Element* element = ElementTraversal::next(*this, this);
244 while (element) {
245 element->setNeedsStyleRecalc(LocalStyleChange);
246 if (isHTMLTableCellElement(*element))
247 element = ElementTraversal::nextSkippingChildren(*element, this);
248 else
249 element = ElementTraversal::next(*element, this);
250 }
251 }
252
getBordersFromFrameAttributeValue(const AtomicString & value,bool & borderTop,bool & borderRight,bool & borderBottom,bool & borderLeft)253 static bool getBordersFromFrameAttributeValue(const AtomicString& value, bool& borderTop, bool& borderRight, bool& borderBottom, bool& borderLeft)
254 {
255 borderTop = false;
256 borderRight = false;
257 borderBottom = false;
258 borderLeft = false;
259
260 if (equalIgnoringCase(value, "above"))
261 borderTop = true;
262 else if (equalIgnoringCase(value, "below"))
263 borderBottom = true;
264 else if (equalIgnoringCase(value, "hsides"))
265 borderTop = borderBottom = true;
266 else if (equalIgnoringCase(value, "vsides"))
267 borderLeft = borderRight = true;
268 else if (equalIgnoringCase(value, "lhs"))
269 borderLeft = true;
270 else if (equalIgnoringCase(value, "rhs"))
271 borderRight = true;
272 else if (equalIgnoringCase(value, "box") || equalIgnoringCase(value, "border"))
273 borderTop = borderBottom = borderLeft = borderRight = true;
274 else if (!equalIgnoringCase(value, "void"))
275 return false;
276 return true;
277 }
278
collectStyleForPresentationAttribute(const QualifiedName & name,const AtomicString & value,MutableStylePropertySet * style)279 void HTMLTableElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
280 {
281 if (name == widthAttr)
282 addHTMLLengthToStyle(style, CSSPropertyWidth, value);
283 else if (name == heightAttr)
284 addHTMLLengthToStyle(style, CSSPropertyHeight, value);
285 else if (name == borderAttr)
286 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, parseBorderWidthAttribute(value), CSSPrimitiveValue::CSS_PX);
287 else if (name == bordercolorAttr) {
288 if (!value.isEmpty())
289 addHTMLColorToStyle(style, CSSPropertyBorderColor, value);
290 } else if (name == bgcolorAttr)
291 addHTMLColorToStyle(style, CSSPropertyBackgroundColor, value);
292 else if (name == backgroundAttr) {
293 String url = stripLeadingAndTrailingHTMLSpaces(value);
294 if (!url.isEmpty()) {
295 RefPtrWillBeRawPtr<CSSImageValue> imageValue = CSSImageValue::create(url, document().completeURL(url));
296 imageValue->setReferrer(Referrer(document().outgoingReferrer(), document().referrerPolicy()));
297 style->setProperty(CSSProperty(CSSPropertyBackgroundImage, imageValue.release()));
298 }
299 } else if (name == valignAttr) {
300 if (!value.isEmpty())
301 addPropertyToPresentationAttributeStyle(style, CSSPropertyVerticalAlign, value);
302 } else if (name == cellspacingAttr) {
303 if (!value.isEmpty())
304 addHTMLLengthToStyle(style, CSSPropertyBorderSpacing, value);
305 } else if (name == vspaceAttr) {
306 UseCounter::countDeprecation(document(), UseCounter::HTMLTableElementVspace);
307 addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
308 addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
309 } else if (name == hspaceAttr) {
310 UseCounter::countDeprecation(document(), UseCounter::HTMLTableElementHspace);
311 addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
312 addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
313 } else if (name == alignAttr) {
314 if (!value.isEmpty()) {
315 if (equalIgnoringCase(value, "center")) {
316 addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitMarginStart, CSSValueAuto);
317 addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitMarginEnd, CSSValueAuto);
318 } else
319 addPropertyToPresentationAttributeStyle(style, CSSPropertyFloat, value);
320 }
321 } else if (name == rulesAttr) {
322 // The presence of a valid rules attribute causes border collapsing to be enabled.
323 if (m_rulesAttr != UnsetRules)
324 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderCollapse, CSSValueCollapse);
325 } else if (name == frameAttr) {
326 bool borderTop;
327 bool borderRight;
328 bool borderBottom;
329 bool borderLeft;
330 if (getBordersFromFrameAttributeValue(value, borderTop, borderRight, borderBottom, borderLeft)) {
331 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, CSSValueThin);
332 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderTopStyle, borderTop ? CSSValueSolid : CSSValueHidden);
333 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderBottomStyle, borderBottom ? CSSValueSolid : CSSValueHidden);
334 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderLeftStyle, borderLeft ? CSSValueSolid : CSSValueHidden);
335 addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderRightStyle, borderRight ? CSSValueSolid : CSSValueHidden);
336 }
337 } else
338 HTMLElement::collectStyleForPresentationAttribute(name, value, style);
339 }
340
isPresentationAttribute(const QualifiedName & name) const341 bool HTMLTableElement::isPresentationAttribute(const QualifiedName& name) const
342 {
343 if (name == widthAttr || name == heightAttr || name == bgcolorAttr || name == backgroundAttr || name == valignAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr || name == cellspacingAttr || name == borderAttr || name == bordercolorAttr || name == frameAttr || name == rulesAttr)
344 return true;
345 return HTMLElement::isPresentationAttribute(name);
346 }
347
parseAttribute(const QualifiedName & name,const AtomicString & value)348 void HTMLTableElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
349 {
350 CellBorders bordersBefore = cellBorders();
351 unsigned short oldPadding = m_padding;
352
353 if (name == borderAttr) {
354 // FIXME: This attribute is a mess.
355 m_borderAttr = parseBorderWidthAttribute(value);
356 } else if (name == bordercolorAttr) {
357 m_borderColorAttr = !value.isEmpty();
358 } else if (name == frameAttr) {
359 // FIXME: This attribute is a mess.
360 bool borderTop;
361 bool borderRight;
362 bool borderBottom;
363 bool borderLeft;
364 m_frameAttr = getBordersFromFrameAttributeValue(value, borderTop, borderRight, borderBottom, borderLeft);
365 } else if (name == rulesAttr) {
366 m_rulesAttr = UnsetRules;
367 if (equalIgnoringCase(value, "none"))
368 m_rulesAttr = NoneRules;
369 else if (equalIgnoringCase(value, "groups"))
370 m_rulesAttr = GroupsRules;
371 else if (equalIgnoringCase(value, "rows"))
372 m_rulesAttr = RowsRules;
373 else if (equalIgnoringCase(value, "cols"))
374 m_rulesAttr = ColsRules;
375 else if (equalIgnoringCase(value, "all"))
376 m_rulesAttr = AllRules;
377 } else if (name == cellpaddingAttr) {
378 if (!value.isEmpty())
379 m_padding = max(0, value.toInt());
380 else
381 m_padding = 1;
382 } else if (name == colsAttr) {
383 // ###
384 } else
385 HTMLElement::parseAttribute(name, value);
386
387 if (bordersBefore != cellBorders() || oldPadding != m_padding) {
388 m_sharedCellStyle = nullptr;
389 setNeedsTableStyleRecalc();
390 }
391 }
392
createBorderStyle(CSSValueID value)393 static PassRefPtrWillBeRawPtr<StylePropertySet> createBorderStyle(CSSValueID value)
394 {
395 RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
396 style->setProperty(CSSPropertyBorderTopStyle, value);
397 style->setProperty(CSSPropertyBorderBottomStyle, value);
398 style->setProperty(CSSPropertyBorderLeftStyle, value);
399 style->setProperty(CSSPropertyBorderRightStyle, value);
400 return style.release();
401 }
402
additionalPresentationAttributeStyle()403 const StylePropertySet* HTMLTableElement::additionalPresentationAttributeStyle()
404 {
405 if (m_frameAttr)
406 return 0;
407
408 if (!m_borderAttr && !m_borderColorAttr) {
409 // Setting the border to 'hidden' allows it to win over any border
410 // set on the table's cells during border-conflict resolution.
411 if (m_rulesAttr != UnsetRules) {
412 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, solidBorderStyle, (createBorderStyle(CSSValueHidden)));
413 return solidBorderStyle;
414 }
415 return 0;
416 }
417
418 if (m_borderColorAttr) {
419 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, solidBorderStyle, (createBorderStyle(CSSValueSolid)));
420 return solidBorderStyle;
421 }
422 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, outsetBorderStyle, (createBorderStyle(CSSValueOutset)));
423 return outsetBorderStyle;
424 }
425
cellBorders() const426 HTMLTableElement::CellBorders HTMLTableElement::cellBorders() const
427 {
428 switch (m_rulesAttr) {
429 case NoneRules:
430 case GroupsRules:
431 return NoBorders;
432 case AllRules:
433 return SolidBorders;
434 case ColsRules:
435 return SolidBordersColsOnly;
436 case RowsRules:
437 return SolidBordersRowsOnly;
438 case UnsetRules:
439 if (!m_borderAttr)
440 return NoBorders;
441 if (m_borderColorAttr)
442 return SolidBorders;
443 return InsetBorders;
444 }
445 ASSERT_NOT_REACHED();
446 return NoBorders;
447 }
448
createSharedCellStyle()449 PassRefPtrWillBeRawPtr<StylePropertySet> HTMLTableElement::createSharedCellStyle()
450 {
451 RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
452
453 switch (cellBorders()) {
454 case SolidBordersColsOnly:
455 style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
456 style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
457 style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
458 style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
459 style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
460 break;
461 case SolidBordersRowsOnly:
462 style->setProperty(CSSPropertyBorderTopWidth, CSSValueThin);
463 style->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin);
464 style->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid);
465 style->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid);
466 style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
467 break;
468 case SolidBorders:
469 style->setProperty(CSSPropertyBorderWidth, cssValuePool().createValue(1, CSSPrimitiveValue::CSS_PX));
470 style->setProperty(CSSPropertyBorderStyle, cssValuePool().createIdentifierValue(CSSValueSolid));
471 style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
472 break;
473 case InsetBorders:
474 style->setProperty(CSSPropertyBorderWidth, cssValuePool().createValue(1, CSSPrimitiveValue::CSS_PX));
475 style->setProperty(CSSPropertyBorderStyle, cssValuePool().createIdentifierValue(CSSValueInset));
476 style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
477 break;
478 case NoBorders:
479 // If 'rules=none' then allow any borders set at cell level to take effect.
480 break;
481 }
482
483 if (m_padding)
484 style->setProperty(CSSPropertyPadding, cssValuePool().createValue(m_padding, CSSPrimitiveValue::CSS_PX));
485
486 return style.release();
487 }
488
additionalCellStyle()489 const StylePropertySet* HTMLTableElement::additionalCellStyle()
490 {
491 if (!m_sharedCellStyle)
492 m_sharedCellStyle = createSharedCellStyle();
493 return m_sharedCellStyle.get();
494 }
495
createGroupBorderStyle(int rows)496 static PassRefPtrWillBeRawPtr<StylePropertySet> createGroupBorderStyle(int rows)
497 {
498 RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
499 if (rows) {
500 style->setProperty(CSSPropertyBorderTopWidth, CSSValueThin);
501 style->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin);
502 style->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid);
503 style->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid);
504 } else {
505 style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
506 style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
507 style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
508 style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
509 }
510 return style.release();
511 }
512
additionalGroupStyle(bool rows)513 const StylePropertySet* HTMLTableElement::additionalGroupStyle(bool rows)
514 {
515 if (m_rulesAttr != GroupsRules)
516 return 0;
517
518 if (rows) {
519 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, rowBorderStyle, (createGroupBorderStyle(true)));
520 return rowBorderStyle;
521 }
522 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, columnBorderStyle, (createGroupBorderStyle(false)));
523 return columnBorderStyle;
524 }
525
isURLAttribute(const Attribute & attribute) const526 bool HTMLTableElement::isURLAttribute(const Attribute& attribute) const
527 {
528 return attribute.name() == backgroundAttr || HTMLElement::isURLAttribute(attribute);
529 }
530
hasLegalLinkAttribute(const QualifiedName & name) const531 bool HTMLTableElement::hasLegalLinkAttribute(const QualifiedName& name) const
532 {
533 return name == backgroundAttr || HTMLElement::hasLegalLinkAttribute(name);
534 }
535
subResourceAttributeName() const536 const QualifiedName& HTMLTableElement::subResourceAttributeName() const
537 {
538 return backgroundAttr;
539 }
540
rows()541 PassRefPtrWillBeRawPtr<HTMLTableRowsCollection> HTMLTableElement::rows()
542 {
543 return ensureCachedCollection<HTMLTableRowsCollection>(TableRows);
544 }
545
tBodies()546 PassRefPtrWillBeRawPtr<HTMLCollection> HTMLTableElement::tBodies()
547 {
548 return ensureCachedCollection<HTMLCollection>(TableTBodies);
549 }
550
rules() const551 const AtomicString& HTMLTableElement::rules() const
552 {
553 return getAttribute(rulesAttr);
554 }
555
summary() const556 const AtomicString& HTMLTableElement::summary() const
557 {
558 return getAttribute(summaryAttr);
559 }
560
trace(Visitor * visitor)561 void HTMLTableElement::trace(Visitor* visitor)
562 {
563 visitor->trace(m_sharedCellStyle);
564 HTMLElement::trace(visitor);
565 }
566
567 }
568