4dcf998ce0dbf18c8b5f90b044ff60f990b8885c
[WebKit.git] / WebCore / html / HTMLElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
5  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #include "config.h"
25 #include "HTMLElement.h"
26
27 #include "Attribute.h"
28 #include "CSSPropertyNames.h"
29 #include "CSSValueKeywords.h"
30 #include "DocumentFragment.h"
31 #include "Event.h"
32 #include "EventListener.h"
33 #include "EventNames.h"
34 #include "ExceptionCode.h"
35 #include "Frame.h"
36 #include "HTMLBRElement.h"
37 #include "HTMLCollection.h"
38 #include "HTMLDocument.h"
39 #include "HTMLElementFactory.h"
40 #include "HTMLFormElement.h"
41 #include "HTMLNames.h"
42 #include "HTMLParserIdioms.h"
43 #include "RenderWordBreak.h"
44 #include "ScriptEventListener.h"
45 #include "Settings.h"
46 #include "Text.h"
47 #include "TextIterator.h"
48 #include "markup.h"
49 #include <wtf/StdLibExtras.h>
50 #include <wtf/text/CString.h>
51
52 namespace WebCore {
53
54 using namespace HTMLNames;
55
56 using std::min;
57 using std::max;
58
59 PassRefPtr<HTMLElement> HTMLElement::create(const QualifiedName& tagName, Document* document)
60 {
61     return adoptRef(new HTMLElement(tagName, document));
62 }
63
64 String HTMLElement::nodeName() const
65 {
66     // FIXME: Would be nice to have an atomicstring lookup based off uppercase
67     // chars that does not have to copy the string on a hit in the hash.
68     // FIXME: We should have a way to detect XHTML elements and replace the hasPrefix() check with it.
69     if (document()->isHTMLDocument() && !tagQName().hasPrefix())
70         return tagQName().localNameUpper();
71     return Element::nodeName();
72 }
73
74 bool HTMLElement::ieForbidsInsertHTML() const
75 {
76     // FIXME: Supposedly IE disallows settting innerHTML, outerHTML
77     // and createContextualFragment on these tags.  We have no tests to
78     // verify this however, so this list could be totally wrong.
79     // This list was moved from the previous endTagRequirement() implementation.
80     // This is also called from editing and assumed to be the list of tags
81     // for which no end tag should be serialized. It's unclear if the list for
82     // IE compat and the list for serialization sanity are the same.
83     if (hasLocalName(areaTag)
84         || hasLocalName(baseTag)
85         || hasLocalName(basefontTag)
86         || hasLocalName(brTag)
87         || hasLocalName(colTag)
88 #if ENABLE(DATAGRID)
89         || hasLocalName(dcellTag)
90         || hasLocalName(dcolTag)
91 #endif
92         || hasLocalName(embedTag)
93         || hasLocalName(frameTag)
94         || hasLocalName(hrTag)
95         || hasLocalName(imageTag)
96         || hasLocalName(imgTag)
97         || hasLocalName(inputTag)
98         || hasLocalName(isindexTag)
99         || hasLocalName(linkTag)
100         || hasLocalName(metaTag)
101         || hasLocalName(paramTag)
102         || hasLocalName(sourceTag)
103         || hasLocalName(wbrTag))
104         return true;
105     // FIXME: I'm not sure why dashboard mode would want to change the
106     // serialization of <canvas>, that seems like a bad idea.
107 #if ENABLE(DASHBOARD_SUPPORT)
108     if (hasLocalName(canvasTag)) {
109         Settings* settings = document()->settings();
110         if (settings && settings->usesDashboardBackwardCompatibilityMode())
111             return true;
112     }
113 #endif
114     return false;
115 }
116
117 bool HTMLElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
118 {
119     if (attrName == alignAttr ||
120         attrName == contenteditableAttr) {
121         result = eUniversal;
122         return false;
123     }
124     if (attrName == dirAttr) {
125         result = hasLocalName(bdoTag) ? eBDO : eUniversal;
126         return false;
127     }
128
129     return StyledElement::mapToEntry(attrName, result);
130 }
131     
132 void HTMLElement::parseMappedAttribute(Attribute* attr)
133 {
134     if (isIdAttributeName(attr->name()) || attr->name() == classAttr || attr->name() == styleAttr)
135         return StyledElement::parseMappedAttribute(attr);
136
137     String indexstring;
138     if (attr->name() == alignAttr) {
139         if (equalIgnoringCase(attr->value(), "middle"))
140             addCSSProperty(attr, CSSPropertyTextAlign, "center");
141         else
142             addCSSProperty(attr, CSSPropertyTextAlign, attr->value());
143     } else if (attr->name() == contenteditableAttr) {
144         setContentEditable(attr);
145     } else if (attr->name() == tabindexAttr) {
146         indexstring = getAttribute(tabindexAttr);
147         int tabindex = 0;
148         if (parseHTMLInteger(indexstring, tabindex)) {
149             // Clamp tabindex to the range of 'short' to match Firefox's behavior.
150             setTabIndexExplicitly(max(static_cast<int>(std::numeric_limits<short>::min()), min(tabindex, static_cast<int>(std::numeric_limits<short>::max()))));
151         }
152     } else if (attr->name() == langAttr) {
153         // FIXME: Implement
154     } else if (attr->name() == dirAttr) {
155         addCSSProperty(attr, CSSPropertyDirection, attr->value());
156         addCSSProperty(attr, CSSPropertyUnicodeBidi, hasLocalName(bdoTag) ? CSSValueBidiOverride : CSSValueEmbed);
157     } else if (attr->name() == draggableAttr) {
158         const AtomicString& value = attr->value();
159         if (equalIgnoringCase(value, "true")) {
160             addCSSProperty(attr, CSSPropertyWebkitUserDrag, CSSValueElement);
161             addCSSProperty(attr, CSSPropertyWebkitUserSelect, CSSValueNone);
162         } else if (equalIgnoringCase(value, "false"))
163             addCSSProperty(attr, CSSPropertyWebkitUserDrag, CSSValueNone);
164     }
165 // standard events
166     else if (attr->name() == onclickAttr) {
167         setAttributeEventListener(eventNames().clickEvent, createAttributeEventListener(this, attr));
168     } else if (attr->name() == oncontextmenuAttr) {
169         setAttributeEventListener(eventNames().contextmenuEvent, createAttributeEventListener(this, attr));
170     } else if (attr->name() == ondblclickAttr) {
171         setAttributeEventListener(eventNames().dblclickEvent, createAttributeEventListener(this, attr));
172     } else if (attr->name() == onmousedownAttr) {
173         setAttributeEventListener(eventNames().mousedownEvent, createAttributeEventListener(this, attr));
174     } else if (attr->name() == onmousemoveAttr) {
175         setAttributeEventListener(eventNames().mousemoveEvent, createAttributeEventListener(this, attr));
176     } else if (attr->name() == onmouseoutAttr) {
177         setAttributeEventListener(eventNames().mouseoutEvent, createAttributeEventListener(this, attr));
178     } else if (attr->name() == onmouseoverAttr) {
179         setAttributeEventListener(eventNames().mouseoverEvent, createAttributeEventListener(this, attr));
180     } else if (attr->name() == onmouseupAttr) {
181         setAttributeEventListener(eventNames().mouseupEvent, createAttributeEventListener(this, attr));
182     } else if (attr->name() == onmousewheelAttr) {
183         setAttributeEventListener(eventNames().mousewheelEvent, createAttributeEventListener(this, attr));
184     } else if (attr->name() == onfocusAttr) {
185         setAttributeEventListener(eventNames().focusEvent, createAttributeEventListener(this, attr));
186     } else if (attr->name() == onfocusinAttr) {
187         setAttributeEventListener(eventNames().focusinEvent, createAttributeEventListener(this, attr));
188     } else if (attr->name() == onfocusoutAttr) {
189         setAttributeEventListener(eventNames().focusoutEvent, createAttributeEventListener(this, attr));
190     } else if (attr->name() == onblurAttr) {
191         setAttributeEventListener(eventNames().blurEvent, createAttributeEventListener(this, attr));
192     } else if (attr->name() == onkeydownAttr) {
193         setAttributeEventListener(eventNames().keydownEvent, createAttributeEventListener(this, attr));
194     } else if (attr->name() == onkeypressAttr) {
195         setAttributeEventListener(eventNames().keypressEvent, createAttributeEventListener(this, attr));
196     } else if (attr->name() == onkeyupAttr) {
197         setAttributeEventListener(eventNames().keyupEvent, createAttributeEventListener(this, attr));
198     } else if (attr->name() == onscrollAttr) {
199         setAttributeEventListener(eventNames().scrollEvent, createAttributeEventListener(this, attr));
200     } else if (attr->name() == onbeforecutAttr) {
201         setAttributeEventListener(eventNames().beforecutEvent, createAttributeEventListener(this, attr));
202     } else if (attr->name() == oncutAttr) {
203         setAttributeEventListener(eventNames().cutEvent, createAttributeEventListener(this, attr));
204     } else if (attr->name() == onbeforecopyAttr) {
205         setAttributeEventListener(eventNames().beforecopyEvent, createAttributeEventListener(this, attr));
206     } else if (attr->name() == oncopyAttr) {
207         setAttributeEventListener(eventNames().copyEvent, createAttributeEventListener(this, attr));
208     } else if (attr->name() == onbeforepasteAttr) {
209         setAttributeEventListener(eventNames().beforepasteEvent, createAttributeEventListener(this, attr));
210     } else if (attr->name() == onpasteAttr) {
211         setAttributeEventListener(eventNames().pasteEvent, createAttributeEventListener(this, attr));
212     } else if (attr->name() == ondragenterAttr) {
213         setAttributeEventListener(eventNames().dragenterEvent, createAttributeEventListener(this, attr));
214     } else if (attr->name() == ondragoverAttr) {
215         setAttributeEventListener(eventNames().dragoverEvent, createAttributeEventListener(this, attr));
216     } else if (attr->name() == ondragleaveAttr) {
217         setAttributeEventListener(eventNames().dragleaveEvent, createAttributeEventListener(this, attr));
218     } else if (attr->name() == ondropAttr) {
219         setAttributeEventListener(eventNames().dropEvent, createAttributeEventListener(this, attr));
220     } else if (attr->name() == ondragstartAttr) {
221         setAttributeEventListener(eventNames().dragstartEvent, createAttributeEventListener(this, attr));
222     } else if (attr->name() == ondragAttr) {
223         setAttributeEventListener(eventNames().dragEvent, createAttributeEventListener(this, attr));
224     } else if (attr->name() == ondragendAttr) {
225         setAttributeEventListener(eventNames().dragendEvent, createAttributeEventListener(this, attr));
226     } else if (attr->name() == onselectstartAttr) {
227         setAttributeEventListener(eventNames().selectstartEvent, createAttributeEventListener(this, attr));
228     } else if (attr->name() == onsubmitAttr) {
229         setAttributeEventListener(eventNames().submitEvent, createAttributeEventListener(this, attr));
230     } else if (attr->name() == onerrorAttr) {
231         setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, attr));
232     } else if (attr->name() == onwebkitanimationstartAttr) {
233         setAttributeEventListener(eventNames().webkitAnimationStartEvent, createAttributeEventListener(this, attr));
234     } else if (attr->name() == onwebkitanimationiterationAttr) {
235         setAttributeEventListener(eventNames().webkitAnimationIterationEvent, createAttributeEventListener(this, attr));
236     } else if (attr->name() == onwebkitanimationendAttr) {
237         setAttributeEventListener(eventNames().webkitAnimationEndEvent, createAttributeEventListener(this, attr));
238     } else if (attr->name() == onwebkittransitionendAttr) {
239         setAttributeEventListener(eventNames().webkitTransitionEndEvent, createAttributeEventListener(this, attr));
240     } else if (attr->name() == oninputAttr) {
241         setAttributeEventListener(eventNames().inputEvent, createAttributeEventListener(this, attr));
242     } else if (attr->name() == oninvalidAttr) {
243         setAttributeEventListener(eventNames().invalidEvent, createAttributeEventListener(this, attr));
244     } else if (attr->name() == ontouchstartAttr) {
245         setAttributeEventListener(eventNames().touchstartEvent, createAttributeEventListener(this, attr));
246     } else if (attr->name() == ontouchmoveAttr) {
247         setAttributeEventListener(eventNames().touchmoveEvent, createAttributeEventListener(this, attr));
248     } else if (attr->name() == ontouchendAttr) {
249         setAttributeEventListener(eventNames().touchendEvent, createAttributeEventListener(this, attr));
250     } else if (attr->name() == ontouchcancelAttr) {
251         setAttributeEventListener(eventNames().touchcancelEvent, createAttributeEventListener(this, attr));
252 #if ENABLE(FULLSCREEN_API)
253     } else if (attr->name() == onwebkitfullscreenchangeAttr) {
254         setAttributeEventListener(eventNames().webkitfullscreenchangeEvent, createAttributeEventListener(this, attr));
255 #endif
256     }
257 }
258
259 String HTMLElement::innerHTML() const
260 {
261     return createMarkup(this, ChildrenOnly);
262 }
263
264 String HTMLElement::outerHTML() const
265 {
266     return createMarkup(this);
267 }
268
269 // FIXME: This logic should move into Range::createContextualFragment
270 PassRefPtr<DocumentFragment> HTMLElement::deprecatedCreateContextualFragment(const String& markup, FragmentScriptingPermission scriptingPermission)
271 {
272     // The following is in accordance with the definition as used by IE.
273     if (ieForbidsInsertHTML())
274         return 0;
275
276     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag)
277         || hasLocalName(headTag) || hasLocalName(styleTag) || hasLocalName(titleTag))
278         return 0;
279
280     return Element::deprecatedCreateContextualFragment(markup, scriptingPermission);
281 }
282
283 static inline bool hasOneChild(ContainerNode* node)
284 {
285     Node* firstChild = node->firstChild();
286     return firstChild && !firstChild->nextSibling();
287 }
288
289 static inline bool hasOneTextChild(ContainerNode* node)
290 {
291     return hasOneChild(node) && node->firstChild()->isTextNode();
292 }
293
294 static void replaceChildrenWithFragment(HTMLElement* element, PassRefPtr<DocumentFragment> fragment, ExceptionCode& ec)
295 {
296     if (!fragment->firstChild()) {
297         element->removeChildren();
298         return;
299     }
300
301     if (hasOneTextChild(element) && hasOneTextChild(fragment.get())) {
302         static_cast<Text*>(element->firstChild())->setData(static_cast<Text*>(fragment->firstChild())->data(), ec);
303         return;
304     }
305
306     if (hasOneChild(element)) {
307         element->replaceChild(fragment, element->firstChild(), ec);
308         return;
309     }
310
311     element->removeChildren();
312     element->appendChild(fragment, ec);
313 }
314
315 static void replaceChildrenWithText(HTMLElement* element, const String& text, ExceptionCode& ec)
316 {
317     if (hasOneTextChild(element)) {
318         static_cast<Text*>(element->firstChild())->setData(text, ec);
319         return;
320     }
321
322     RefPtr<Text> textNode = Text::create(element->document(), text);
323
324     if (hasOneChild(element)) {
325         element->replaceChild(textNode.release(), element->firstChild(), ec);
326         return;
327     }
328
329     element->removeChildren();
330     element->appendChild(textNode.release(), ec);
331 }
332
333 // We may want to move a version of this function into DocumentFragment.h/cpp
334 static PassRefPtr<DocumentFragment> createFragmentFromSource(const String& markup, Element* contextElement, ExceptionCode& ec)
335 {
336     Document* document = contextElement->document();
337     RefPtr<DocumentFragment> fragment;
338
339     fragment = DocumentFragment::create(document);
340     if (document->isHTMLDocument()) {
341         fragment->parseHTML(markup, contextElement);
342         return fragment;
343     }
344
345     bool wasValid = fragment->parseXML(markup, contextElement);
346     if (!wasValid) {
347         ec = INVALID_STATE_ERR;
348         return 0;
349     }
350     return fragment;
351 }
352
353 void HTMLElement::setInnerHTML(const String& html, ExceptionCode& ec)
354 {
355     RefPtr<DocumentFragment> fragment = createFragmentFromSource(html, this, ec);
356     if (fragment)
357         replaceChildrenWithFragment(this, fragment.release(), ec);
358 }
359
360 void HTMLElement::setOuterHTML(const String& html, ExceptionCode& ec)
361 {
362     Node* p = parentNode();
363     if (!p || !p->isHTMLElement()) {
364         ec = NO_MODIFICATION_ALLOWED_ERR;
365         return;
366     }
367     HTMLElement* parent = static_cast<HTMLElement*>(p);
368
369     RefPtr<DocumentFragment> fragment = createFragmentFromSource(html, parent, ec);
370     if (fragment) {
371         // FIXME: Why doesn't this have code to merge neighboring text nodes the way setOuterText does?
372         parent->replaceChild(fragment.release(), this, ec);
373     }
374 }
375
376 void HTMLElement::setInnerText(const String& text, ExceptionCode& ec)
377 {
378     if (ieForbidsInsertHTML()) {
379         ec = NO_MODIFICATION_ALLOWED_ERR;
380         return;
381     }
382     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
383         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 
384         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
385         hasLocalName(trTag)) {
386         ec = NO_MODIFICATION_ALLOWED_ERR;
387         return;
388     }
389
390     // FIXME: This doesn't take whitespace collapsing into account at all.
391
392     if (!text.contains('\n') && !text.contains('\r')) {
393         if (text.isEmpty()) {
394             removeChildren();
395             return;
396         }
397         replaceChildrenWithText(this, text, ec);
398         return;
399     }
400
401     // FIXME: Do we need to be able to detect preserveNewline style even when there's no renderer?
402     // FIXME: Can the renderer be out of date here? Do we need to call updateStyleIfNeeded?
403     // For example, for the contents of textarea elements that are display:none?
404     RenderObject* r = renderer();
405     if (r && r->style()->preserveNewline()) {
406         if (!text.contains('\r')) {
407             replaceChildrenWithText(this, text, ec);
408             return;
409         }
410         String textWithConsistentLineBreaks = text;
411         textWithConsistentLineBreaks.replace("\r\n", "\n");
412         textWithConsistentLineBreaks.replace('\r', '\n');
413         replaceChildrenWithText(this, textWithConsistentLineBreaks, ec);
414         return;
415     }
416
417     // Add text nodes and <br> elements.
418     ec = 0;
419     RefPtr<DocumentFragment> fragment = DocumentFragment::create(document());
420     int lineStart = 0;
421     UChar prev = 0;
422     int length = text.length();
423     for (int i = 0; i < length; ++i) {
424         UChar c = text[i];
425         if (c == '\n' || c == '\r') {
426             if (i > lineStart) {
427                 fragment->appendChild(Text::create(document(), text.substring(lineStart, i - lineStart)), ec);
428                 if (ec)
429                     return;
430             }
431             if (!(c == '\n' && i != 0 && prev == '\r')) {
432                 fragment->appendChild(HTMLBRElement::create(document()), ec);
433                 if (ec)
434                     return;
435             }
436             lineStart = i + 1;
437         }
438         prev = c;
439     }
440     if (length > lineStart)
441         fragment->appendChild(Text::create(document(), text.substring(lineStart, length - lineStart)), ec);
442     replaceChildrenWithFragment(this, fragment.release(), ec);
443 }
444
445 void HTMLElement::setOuterText(const String &text, ExceptionCode& ec)
446 {
447     if (ieForbidsInsertHTML()) {
448         ec = NO_MODIFICATION_ALLOWED_ERR;
449         return;
450     }
451     if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||
452         hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 
453         hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||
454         hasLocalName(trTag)) {
455         ec = NO_MODIFICATION_ALLOWED_ERR;
456         return;
457     }
458
459     ContainerNode* parent = parentNode();
460     if (!parent) {
461         ec = NO_MODIFICATION_ALLOWED_ERR;
462         return;
463     }
464
465     // FIXME: This creates a new text node even when the text is empty.
466     // FIXME: This creates a single text node even when the text has CR and LF
467     // characters in it. Instead it should create <br> elements.
468     RefPtr<Text> t = Text::create(document(), text);
469     ec = 0;
470     parent->replaceChild(t, this, ec);
471     if (ec)
472         return;
473
474     // Is previous node a text node? If so, merge into it.
475     Node* prev = t->previousSibling();
476     if (prev && prev->isTextNode()) {
477         Text* textPrev = static_cast<Text*>(prev);
478         textPrev->appendData(t->data(), ec);
479         if (ec)
480             return;
481         t->remove(ec);
482         if (ec)
483             return;
484         t = textPrev;
485     }
486
487     // Is next node a text node? If so, merge it in.
488     Node* next = t->nextSibling();
489     if (next && next->isTextNode()) {
490         Text* textNext = static_cast<Text*>(next);
491         t->appendData(textNext->data(), ec);
492         if (ec)
493             return;
494         textNext->remove(ec);
495         if (ec)
496             return;
497     }
498 }
499
500 Node* HTMLElement::insertAdjacent(const String& where, Node* newChild, ExceptionCode& ec)
501 {
502     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
503     // a document fragment is created and the elements appended in the correct order. This document
504     // fragment isn't returned anywhere.
505     //
506     // This is impossible for us to implement as the DOM tree does not allow for such structures,
507     // Opera also appears to disallow such usage.
508
509     if (equalIgnoringCase(where, "beforeBegin")) {
510         ContainerNode* parent = this->parentNode();
511         return (parent && parent->insertBefore(newChild, this, ec)) ? newChild : 0;
512     }
513
514     if (equalIgnoringCase(where, "afterBegin"))
515         return insertBefore(newChild, firstChild(), ec) ? newChild : 0;
516
517     if (equalIgnoringCase(where, "beforeEnd"))
518         return appendChild(newChild, ec) ? newChild : 0;
519
520     if (equalIgnoringCase(where, "afterEnd")) {
521         ContainerNode* parent = this->parentNode();
522         return (parent && parent->insertBefore(newChild, nextSibling(), ec)) ? newChild : 0;
523     }
524     
525     // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
526     ec = NOT_SUPPORTED_ERR;
527     return 0;
528 }
529
530 Element* HTMLElement::insertAdjacentElement(const String& where, Element* newChild, ExceptionCode& ec)
531 {
532     if (!newChild) {
533         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
534         ec = TYPE_MISMATCH_ERR;
535         return 0;
536     }
537
538     Node* returnValue = insertAdjacent(where, newChild, ec);
539     ASSERT(!returnValue || returnValue->isElementNode());
540     return static_cast<Element*>(returnValue); 
541 }
542
543 // Step 3 of http://www.whatwg.org/specs/web-apps/current-work/multipage/apis-in-html-documents.html#insertadjacenthtml()
544 static Element* contextElementForInsertion(const String& where, Element* element, ExceptionCode& ec)
545 {
546     if (equalIgnoringCase(where, "beforeBegin") || equalIgnoringCase(where, "afterEnd")) {
547         ContainerNode* parent = element->parentNode();
548         if (parent && parent->isDocumentNode()) {
549             ec = NO_MODIFICATION_ALLOWED_ERR;
550             return 0;
551         }
552         ASSERT(!parent || parent->isElementNode());
553         return static_cast<Element*>(parent);
554     }
555     if (equalIgnoringCase(where, "afterBegin") || equalIgnoringCase(where, "beforeEnd"))
556         return element;
557     ec =  SYNTAX_ERR;
558     return 0;
559 }
560
561 void HTMLElement::insertAdjacentHTML(const String& where, const String& markup, ExceptionCode& ec)
562 {
563     RefPtr<DocumentFragment> fragment = document()->createDocumentFragment();
564     Element* contextElement = contextElementForInsertion(where, this, ec);
565     if (!contextElement)
566         return;
567
568     if (document()->isHTMLDocument())
569          fragment->parseHTML(markup, contextElement);
570     else {
571         if (!fragment->parseXML(markup, contextElement))
572             // FIXME: We should propagate a syntax error exception out here.
573             return;
574     }
575
576     insertAdjacent(where, fragment.get(), ec);
577 }
578
579 void HTMLElement::insertAdjacentText(const String& where, const String& text, ExceptionCode& ec)
580 {
581     RefPtr<Text> textNode = document()->createTextNode(text);
582     insertAdjacent(where, textNode.get(), ec);
583 }
584
585 void HTMLElement::addHTMLAlignment(Attribute* attr)
586 {
587     addHTMLAlignmentToStyledElement(this, attr);
588 }
589
590 void HTMLElement::addHTMLAlignmentToStyledElement(StyledElement* element, Attribute* attr)
591 {
592     // Vertical alignment with respect to the current baseline of the text
593     // right or left means floating images.
594     int floatValue = CSSValueInvalid;
595     int verticalAlignValue = CSSValueInvalid;
596
597     const AtomicString& alignment = attr->value();
598     if (equalIgnoringCase(alignment, "absmiddle"))
599         verticalAlignValue = CSSValueMiddle;
600     else if (equalIgnoringCase(alignment, "absbottom"))
601         verticalAlignValue = CSSValueBottom;
602     else if (equalIgnoringCase(alignment, "left")) {
603         floatValue = CSSValueLeft;
604         verticalAlignValue = CSSValueTop;
605     } else if (equalIgnoringCase(alignment, "right")) {
606         floatValue = CSSValueRight;
607         verticalAlignValue = CSSValueTop;
608     } else if (equalIgnoringCase(alignment, "top"))
609         verticalAlignValue = CSSValueTop;
610     else if (equalIgnoringCase(alignment, "middle"))
611         verticalAlignValue = CSSValueWebkitBaselineMiddle;
612     else if (equalIgnoringCase(alignment, "center"))
613         verticalAlignValue = CSSValueMiddle;
614     else if (equalIgnoringCase(alignment, "bottom"))
615         verticalAlignValue = CSSValueBaseline;
616     else if (equalIgnoringCase(alignment, "texttop"))
617         verticalAlignValue = CSSValueTextTop;
618
619     if (floatValue != CSSValueInvalid)
620         element->addCSSProperty(attr, CSSPropertyFloat, floatValue);
621
622     if (verticalAlignValue != CSSValueInvalid)
623         element->addCSSProperty(attr, CSSPropertyVerticalAlign, verticalAlignValue);
624 }
625
626 bool HTMLElement::supportsFocus() const
627 {
628     return Element::supportsFocus() || (isContentEditable() && parentNode() && !parentNode()->isContentEditable());
629 }
630
631 bool HTMLElement::isContentEditable() const 
632 {
633     if (document()->frame() && document()->frame()->isContentEditable())
634         return true;
635
636     // Ideally we'd call ASSERT!needsStyleRecalc()) here, but
637     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
638     // would fire in the middle of Document::setFocusedNode().
639
640     if (!renderer()) {
641         if (parentNode())
642             return parentNode()->isContentEditable();
643         else
644             return false;
645     }
646     
647     return renderer()->style()->userModify() == READ_WRITE || renderer()->style()->userModify() == READ_WRITE_PLAINTEXT_ONLY;
648 }
649
650 bool HTMLElement::isContentRichlyEditable() const
651 {
652     if (document()->frame() && document()->frame()->isContentEditable())
653         return true;
654
655     if (!renderer()) {
656         if (parentNode())
657             return parentNode()->isContentEditable();
658         else
659             return false;
660     }
661     
662     return renderer()->style()->userModify() == READ_WRITE;
663 }
664
665 String HTMLElement::contentEditable() const 
666 {
667     if (!renderer())
668         return "false";
669     
670     switch (renderer()->style()->userModify()) {
671         case READ_WRITE:
672             return "true";
673         case READ_ONLY:
674             return "false";
675         case READ_WRITE_PLAINTEXT_ONLY:
676             return "plaintext-only";
677         default:
678             return "inherit";
679     }
680 }
681
682 void HTMLElement::setContentEditable(Attribute* attr) 
683 {
684     const AtomicString& enabled = attr->value();
685     if (enabled.isEmpty() || equalIgnoringCase(enabled, "true")) {
686         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadWrite);
687         addCSSProperty(attr, CSSPropertyWordWrap, CSSValueBreakWord);
688         addCSSProperty(attr, CSSPropertyWebkitNbspMode, CSSValueSpace);
689         addCSSProperty(attr, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
690     } else if (equalIgnoringCase(enabled, "false")) {
691         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadOnly);
692         attr->decl()->removeProperty(CSSPropertyWordWrap, false);
693         attr->decl()->removeProperty(CSSPropertyWebkitNbspMode, false);
694         attr->decl()->removeProperty(CSSPropertyWebkitLineBreak, false);
695     } else if (equalIgnoringCase(enabled, "inherit")) {
696         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueInherit);
697         attr->decl()->removeProperty(CSSPropertyWordWrap, false);
698         attr->decl()->removeProperty(CSSPropertyWebkitNbspMode, false);
699         attr->decl()->removeProperty(CSSPropertyWebkitLineBreak, false);
700     } else if (equalIgnoringCase(enabled, "plaintext-only")) {
701         addCSSProperty(attr, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
702         addCSSProperty(attr, CSSPropertyWordWrap, CSSValueBreakWord);
703         addCSSProperty(attr, CSSPropertyWebkitNbspMode, CSSValueSpace);
704         addCSSProperty(attr, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
705     }
706 }
707
708 void HTMLElement::setContentEditable(const String &enabled)
709 {
710     if (enabled == "inherit") {
711         ExceptionCode ec;
712         removeAttribute(contenteditableAttr, ec);
713     }
714     else
715         setAttribute(contenteditableAttr, enabled.isEmpty() ? "true" : enabled);
716 }
717
718 bool HTMLElement::draggable() const
719 {
720     return equalIgnoringCase(getAttribute(draggableAttr), "true");
721 }
722
723 void HTMLElement::setDraggable(bool value)
724 {
725     setAttribute(draggableAttr, value ? "true" : "false");
726 }
727
728 bool HTMLElement::spellcheck() const
729 {
730     return isSpellCheckingEnabled();
731 }
732
733 void HTMLElement::setSpellcheck(bool enable)
734 {
735     setAttribute(spellcheckAttr, enable ? "true" : "false");
736 }
737
738
739 void HTMLElement::click()
740 {
741     dispatchSimulatedClick(0, false, false);
742 }
743
744 // accessKeyAction is used by the accessibility support code
745 // to send events to elements that our JavaScript caller does
746 // does not.  The elements JS is interested in have subclasses
747 // that override this method to direct the click appropriately.
748 // Here in the base class, then, we only send the click if
749 // the caller wants it to go to any HTMLElement, and we say
750 // to send the mouse events in addition to the click.
751 void HTMLElement::accessKeyAction(bool sendToAnyElement)
752 {
753     if (sendToAnyElement)
754         dispatchSimulatedClick(0, true);
755 }
756
757 String HTMLElement::title() const
758 {
759     return getAttribute(titleAttr);
760 }
761
762 short HTMLElement::tabIndex() const
763 {
764     if (supportsFocus())
765         return Element::tabIndex();
766     return -1;
767 }
768
769 void HTMLElement::setTabIndex(int value)
770 {
771     setAttribute(tabindexAttr, String::number(value));
772 }
773
774 PassRefPtr<HTMLCollection> HTMLElement::children()
775 {
776     return HTMLCollection::create(this, NodeChildren);
777 }
778
779 bool HTMLElement::rendererIsNeeded(RenderStyle *style)
780 {
781 #if !ENABLE(XHTMLMP)
782     if (hasLocalName(noscriptTag)) {
783         Frame* frame = document()->frame();
784         if (frame && frame->script()->canExecuteScripts(NotAboutToExecuteScript))
785             return false;
786     } else
787 #endif
788     if (hasLocalName(noembedTag)) {
789         Frame* frame = document()->frame();
790         if (frame && frame->loader()->subframeLoader()->allowPlugins(NotAboutToInstantiatePlugin))
791             return false;
792     }
793     return StyledElement::rendererIsNeeded(style);
794 }
795
796 RenderObject* HTMLElement::createRenderer(RenderArena* arena, RenderStyle* style)
797 {
798     if (hasLocalName(wbrTag))
799         return new (arena) RenderWordBreak(this);
800     return RenderObject::createObject(this, style);
801 }
802
803 HTMLFormElement* HTMLElement::findFormAncestor() const
804 {
805     for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
806         if (ancestor->hasTagName(formTag))
807             return static_cast<HTMLFormElement*>(ancestor);
808     }
809     return 0;
810 }
811
812 HTMLFormElement* HTMLElement::virtualForm() const
813 {
814     return findFormAncestor();
815 }
816
817 } // namespace WebCore
818
819 #ifndef NDEBUG
820
821 // For use in the debugger
822 void dumpInnerHTML(WebCore::HTMLElement*);
823
824 void dumpInnerHTML(WebCore::HTMLElement* element)
825 {
826     printf("%s\n", element->innerHTML().ascii().data());
827 }
828 #endif