https://bugs.webkit.org/show_bug.cgi?id=46421, make multi-column layout work with...
[WebKit.git] / Source / WebCore / dom / Element.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Peter Kelly (pmk@post.com)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef Element_h
26 #define Element_h
27
28 #include "Document.h"
29 #include "FragmentScriptingPermission.h"
30 #include "NamedNodeMap.h"
31 #include "ScrollTypes.h"
32
33 namespace WebCore {
34
35 class Attribute;
36 class ClientRect;
37 class ClientRectList;
38 class DOMStringMap;
39 class DOMTokenList;
40 class ElementRareData;
41 class IntSize;
42
43 enum SpellcheckAttributeState {
44     SpellcheckAttributeTrue,
45     SpellcheckAttributeFalse,
46     SpellcheckAttributeDefault
47 };
48
49 class Element : public ContainerNode {
50 public:
51     static PassRefPtr<Element> create(const QualifiedName&, Document*);
52     virtual ~Element();
53
54     DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
55     DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
56     DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
57     DEFINE_ATTRIBUTE_EVENT_LISTENER(contextmenu);
58     DEFINE_ATTRIBUTE_EVENT_LISTENER(dblclick);
59     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragenter);
60     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragover);
61     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragleave);
62     DEFINE_ATTRIBUTE_EVENT_LISTENER(drop);
63     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragstart);
64     DEFINE_ATTRIBUTE_EVENT_LISTENER(drag);
65     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragend);
66     DEFINE_ATTRIBUTE_EVENT_LISTENER(formchange);
67     DEFINE_ATTRIBUTE_EVENT_LISTENER(forminput);
68     DEFINE_ATTRIBUTE_EVENT_LISTENER(input);
69     DEFINE_ATTRIBUTE_EVENT_LISTENER(invalid);
70     DEFINE_ATTRIBUTE_EVENT_LISTENER(keydown);
71     DEFINE_ATTRIBUTE_EVENT_LISTENER(keypress);
72     DEFINE_ATTRIBUTE_EVENT_LISTENER(keyup);
73     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousedown);
74     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousemove);
75     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseout);
76     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseover);
77     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseup);
78     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousewheel);
79     DEFINE_ATTRIBUTE_EVENT_LISTENER(scroll);
80     DEFINE_ATTRIBUTE_EVENT_LISTENER(select);
81     DEFINE_ATTRIBUTE_EVENT_LISTENER(submit);
82
83     // These four attribute event handler attributes are overridden by HTMLBodyElement
84     // and HTMLFrameSetElement to forward to the DOMWindow.
85     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(blur);
86     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(error);
87     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(focus);
88     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(load);
89
90     // WebKit extensions
91     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecut);
92     DEFINE_ATTRIBUTE_EVENT_LISTENER(cut);
93     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecopy);
94     DEFINE_ATTRIBUTE_EVENT_LISTENER(copy);
95     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforepaste);
96     DEFINE_ATTRIBUTE_EVENT_LISTENER(paste);
97     DEFINE_ATTRIBUTE_EVENT_LISTENER(reset);
98     DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
99     DEFINE_ATTRIBUTE_EVENT_LISTENER(selectstart);
100 #if ENABLE(TOUCH_EVENTS)
101     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchstart);
102     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchmove);
103     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
104     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
105 #endif
106 #if ENABLE(FULLSCREEN_API)
107     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenchange);
108 #endif
109
110     virtual PassRefPtr<DocumentFragment> deprecatedCreateContextualFragment(const String&, FragmentScriptingPermission = FragmentScriptingAllowed);
111
112     bool hasAttribute(const QualifiedName&) const;
113     const AtomicString& getAttribute(const QualifiedName&) const;
114     void setAttribute(const QualifiedName&, const AtomicString& value, ExceptionCode&);
115     void removeAttribute(const QualifiedName&, ExceptionCode&);
116
117     // Typed getters and setters for language bindings.
118     int getIntegralAttribute(const QualifiedName& attributeName) const;
119     void setIntegralAttribute(const QualifiedName& attributeName, int value);
120     unsigned getUnsignedIntegralAttribute(const QualifiedName& attributeName) const;
121     void setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value);
122
123     // Call this to get the value of an attribute that is known not to be the style
124     // attribute or one of the SVG animatable attributes.
125     bool fastHasAttribute(const QualifiedName&) const;
126     const AtomicString& fastGetAttribute(const QualifiedName&) const;
127
128     bool hasAttributes() const;
129
130     bool hasAttribute(const String& name) const;
131     bool hasAttributeNS(const String& namespaceURI, const String& localName) const;
132
133     const AtomicString& getAttribute(const String& name) const;
134     const AtomicString& getAttributeNS(const String& namespaceURI, const String& localName) const;
135
136     void setAttribute(const AtomicString& name, const AtomicString& value, ExceptionCode&);
137     void setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode&, FragmentScriptingPermission = FragmentScriptingAllowed);
138
139     bool isIdAttributeName(const QualifiedName&) const;
140     const AtomicString& getIdAttribute() const;
141     void setIdAttribute(const AtomicString&);
142
143     // Call this to get the value of the id attribute for style resolution purposes.
144     // The value will already be lowercased if the document is in compatibility mode,
145     // so this function is not suitable for non-style uses.
146     const AtomicString& idForStyleResolution() const;
147
148     void scrollIntoView(bool alignToTop = true);
149     void scrollIntoViewIfNeeded(bool centerIfNeeded = true);
150
151     void scrollByLines(int lines);
152     void scrollByPages(int pages);
153
154     int offsetLeft();
155     int offsetTop();
156     int offsetWidth();
157     int offsetHeight();
158     Element* offsetParent();
159     int clientLeft();
160     int clientTop();
161     int clientWidth();
162     int clientHeight();
163     virtual int scrollLeft() const;
164     virtual int scrollTop() const;
165     virtual void setScrollLeft(int);
166     virtual void setScrollTop(int);
167     virtual int scrollWidth() const;
168     virtual int scrollHeight() const;
169
170     IntRect boundsInWindowSpace() const;
171
172     PassRefPtr<ClientRectList> getClientRects() const;
173     PassRefPtr<ClientRect> getBoundingClientRect() const;
174     
175     // Returns the absolute bounding box translated into screen coordinates:
176     IntRect screenRect() const;
177
178     void removeAttribute(const String& name, ExceptionCode&);
179     void removeAttributeNS(const String& namespaceURI, const String& localName, ExceptionCode&);
180
181     PassRefPtr<Attr> getAttributeNode(const String& name);
182     PassRefPtr<Attr> getAttributeNodeNS(const String& namespaceURI, const String& localName);
183     PassRefPtr<Attr> setAttributeNode(Attr*, ExceptionCode&);
184     PassRefPtr<Attr> setAttributeNodeNS(Attr*, ExceptionCode&);
185     PassRefPtr<Attr> removeAttributeNode(Attr*, ExceptionCode&);
186     
187     virtual CSSStyleDeclaration* style();
188
189     const QualifiedName& tagQName() const { return m_tagName; }
190     String tagName() const { return nodeName(); }
191     bool hasTagName(const QualifiedName& tagName) const { return m_tagName.matches(tagName); }
192     
193     // A fast function for checking the local name against another atomic string.
194     bool hasLocalName(const AtomicString& other) const { return m_tagName.localName() == other; }
195     bool hasLocalName(const QualifiedName& other) const { return m_tagName.localName() == other.localName(); }
196
197     const AtomicString& localName() const { return m_tagName.localName(); }
198     const AtomicString& prefix() const { return m_tagName.prefix(); }
199     const AtomicString& namespaceURI() const { return m_tagName.namespaceURI(); }
200
201     virtual KURL baseURI() const;
202
203     virtual String nodeName() const;
204
205     PassRefPtr<Element> cloneElementWithChildren();
206     PassRefPtr<Element> cloneElementWithoutChildren();
207
208     void normalizeAttributes();
209     String nodeNamePreservingCase() const;
210
211     // convenience methods which ignore exceptions
212     void setAttribute(const QualifiedName&, const AtomicString& value);
213     void setBooleanAttribute(const QualifiedName& name, bool);
214     // Please don't use setCStringAttribute in performance-sensitive code;
215     // use a static AtomicString value instead to avoid the conversion overhead.
216     void setCStringAttribute(const QualifiedName&, const char* cStringValue);
217
218     NamedNodeMap* attributes(bool readonly = false) const;
219
220     // This method is called whenever an attribute is added, changed or removed.
221     virtual void attributeChanged(Attribute*, bool preserveDecls = false);
222
223     void setAttributeMap(PassRefPtr<NamedNodeMap>, FragmentScriptingPermission = FragmentScriptingAllowed);
224     NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
225
226     virtual void copyNonAttributeProperties(const Element* /*source*/) { }
227
228     virtual void attach();
229     virtual void detach();
230     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
231     virtual void recalcStyle(StyleChange = NoChange);
232
233     Node* shadowRoot();
234     void setShadowRoot(PassRefPtr<Node>);
235     virtual AtomicString shadowPseudoId() const;
236
237     RenderStyle* computedStyle(PseudoId = NOPSEUDO);
238
239     AtomicString computeInheritedLanguage() const;
240
241     void dispatchAttrRemovalEvent(Attribute*);
242     void dispatchAttrAdditionEvent(Attribute*);
243
244     virtual void accessKeyAction(bool /*sendToAnyEvent*/) { }
245
246     virtual bool isURLAttribute(Attribute*) const;
247
248     KURL getURLAttribute(const QualifiedName&) const;
249     KURL getNonEmptyURLAttribute(const QualifiedName&) const;
250
251     virtual const QualifiedName& imageSourceAttributeName() const;
252     virtual String target() const { return String(); }
253
254     virtual void focus(bool restorePreviousSelection = true);
255     virtual void updateFocusAppearance(bool restorePreviousSelection);
256     void blur();
257
258     String innerText() const;
259     String outerText() const;
260  
261     virtual String title() const;
262
263     String openTagStartToString() const;
264
265     void updateId(const AtomicString& oldId, const AtomicString& newId);
266
267     IntSize minimumSizeForResizing() const;
268     void setMinimumSizeForResizing(const IntSize&);
269
270     // Use Document::registerForDocumentActivationCallbacks() to subscribe to these
271     virtual void documentWillBecomeInactive() { }
272     virtual void documentDidBecomeActive() { }
273
274     // Use Document::registerForMediaVolumeCallbacks() to subscribe to this
275     virtual void mediaVolumeDidChange() { }
276
277     bool isFinishedParsingChildren() const { return isParsingChildrenFinished(); }
278     virtual void finishParsingChildren();
279     virtual void beginParsingChildren() { clearIsParsingChildrenFinished(); }
280
281     // ElementTraversal API
282     Element* firstElementChild() const;
283     Element* lastElementChild() const;
284     Element* previousElementSibling() const;
285     Element* nextElementSibling() const;
286     unsigned childElementCount() const;
287
288     bool webkitMatchesSelector(const String& selectors, ExceptionCode&);
289
290     DOMTokenList* classList();
291     DOMTokenList* optionalClassList() const;
292
293     DOMStringMap* dataset();
294     DOMStringMap* optionalDataset() const;
295
296 #if ENABLE(MATHML)
297     virtual bool isMathMLElement() const { return false; }
298 #else
299     static bool isMathMLElement() { return false; }
300 #endif
301
302     virtual bool isFormControlElement() const { return false; }
303     virtual bool isEnabledFormControl() const { return true; }
304     virtual bool isReadOnlyFormControl() const { return false; }
305     virtual bool isSpinButtonElement() const { return false; }
306     virtual bool isTextFormControl() const { return false; }
307     virtual bool isOptionalFormControl() const { return false; }
308     virtual bool isRequiredFormControl() const { return false; }
309     virtual bool isDefaultButtonForForm() const { return false; }
310     virtual bool willValidate() const { return false; }
311     virtual bool isValidFormControlElement() { return false; }
312     virtual bool hasUnacceptableValue() const { return false; }
313     virtual bool isInRange() const { return false; }
314     virtual bool isOutOfRange() const { return false; }
315
316     virtual bool formControlValueMatchesRenderer() const { return false; }
317     virtual void setFormControlValueMatchesRenderer(bool) { }
318
319     virtual const AtomicString& formControlName() const { return nullAtom; }
320     virtual const AtomicString& formControlType() const { return nullAtom; }
321
322     virtual bool shouldSaveAndRestoreFormControlState() const { return true; }
323     virtual bool saveFormControlState(String&) const { return false; }
324     virtual void restoreFormControlState(const String&) { }
325
326     virtual void dispatchFormControlChangeEvent() { }
327
328 #if ENABLE(SVG)
329     virtual bool childShouldCreateRenderer(Node*) const; 
330 #endif
331     
332 #if ENABLE(FULLSCREEN_API)
333     enum {
334         ALLOW_KEYBOARD_INPUT = 1
335     };
336     
337     void webkitRequestFullScreen(unsigned short flags);
338 #endif
339
340     virtual bool isSpellCheckingEnabled() const;
341
342 protected:
343     Element(const QualifiedName& tagName, Document* document, ConstructionType type)
344         : ContainerNode(document, type)
345         , m_tagName(tagName)
346     {
347     }
348
349     virtual void insertedIntoDocument();
350     virtual void removedFromDocument();
351     virtual void insertedIntoTree(bool);
352     virtual void removedFromTree(bool);
353     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
354
355     // The implementation of Element::attributeChanged() calls the following two functions.
356     // They are separated to allow a different flow of control in StyledElement::attributeChanged().
357     void recalcStyleIfNeededAfterAttributeChanged(Attribute*);
358     void updateAfterAttributeChanged(Attribute*);
359
360 private:
361     void scrollByUnits(int units, ScrollGranularity);
362
363     virtual void setPrefix(const AtomicString&, ExceptionCode&);
364     virtual NodeType nodeType() const;
365     virtual bool childTypeAllowed(NodeType);
366
367     virtual PassRefPtr<Attribute> createAttribute(const QualifiedName&, const AtomicString& value);
368     
369 #ifndef NDEBUG
370     virtual void formatForDebugger(char* buffer, unsigned length) const;
371 #endif
372
373     bool pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle);
374
375     void createAttributeMap() const;
376
377     virtual void updateStyleAttribute() const { }
378
379 #if ENABLE(SVG)
380     virtual void updateAnimatedSVGAttribute(const QualifiedName&) const { }
381 #endif
382
383     void cancelFocusAppearanceUpdate();
384
385     virtual const AtomicString& virtualPrefix() const { return prefix(); }
386     virtual const AtomicString& virtualLocalName() const { return localName(); }
387     virtual const AtomicString& virtualNamespaceURI() const { return namespaceURI(); }
388     virtual RenderStyle* virtualComputedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return computedStyle(pseudoElementSpecifier); }
389     
390     // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren
391     // are used instead.
392     virtual PassRefPtr<Node> cloneNode(bool deep);
393     virtual PassRefPtr<Element> cloneElementWithoutAttributesAndChildren() const;
394
395     QualifiedName m_tagName;
396     virtual NodeRareData* createRareData();
397
398     ElementRareData* rareData() const;
399     ElementRareData* ensureRareData();
400
401     SpellcheckAttributeState spellcheckAttributeState() const;
402     void removeShadowRoot();
403
404 private:
405     mutable RefPtr<NamedNodeMap> m_attributeMap;
406 };
407     
408 inline Element* toElement(Node* node)
409 {
410     ASSERT(!node || node->isElementNode());
411     return static_cast<Element*>(node);
412 }
413
414 inline const Element* toElement(const Node* node)
415 {
416     ASSERT(!node || node->isElementNode());
417     return static_cast<const Element*>(node);
418 }
419
420 // This will catch anyone doing an unnecessary cast.
421 void toElement(const Element*);
422
423 inline bool Node::hasTagName(const QualifiedName& name) const
424 {
425     return isElementNode() && toElement(this)->hasTagName(name);
426 }
427
428 inline bool Node::hasAttributes() const
429 {
430     return isElementNode() && toElement(this)->hasAttributes();
431 }
432
433 inline NamedNodeMap* Node::attributes() const
434 {
435     return isElementNode() ? toElement(this)->attributes() : 0;
436 }
437
438 inline Element* Node::parentElement() const
439 {
440     ContainerNode* parent = parentNode();
441     return parent && parent->isElementNode() ? toElement(parent) : 0;
442 }
443
444 inline NamedNodeMap* Element::attributes(bool readonly) const
445 {
446     if (!isStyleAttributeValid())
447         updateStyleAttribute();
448
449 #if ENABLE(SVG)
450     if (!areSVGAttributesValid())
451         updateAnimatedSVGAttribute(anyQName());
452 #endif
453
454     if (!readonly && !m_attributeMap)
455         createAttributeMap();
456     return m_attributeMap.get();
457 }
458
459 inline void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
460 {
461     if (!inDocument())
462         return;
463
464     if (oldId == newId)
465         return;
466
467     Document* doc = document();
468     if (!oldId.isEmpty())
469         doc->removeElementById(oldId, this);
470     if (!newId.isEmpty())
471         doc->addElementById(newId, this);
472 }
473
474 inline bool Element::fastHasAttribute(const QualifiedName& name) const
475 {
476     return m_attributeMap && m_attributeMap->getAttributeItem(name);
477 }
478
479 inline const AtomicString& Element::fastGetAttribute(const QualifiedName& name) const
480 {
481     if (m_attributeMap) {
482         if (Attribute* attribute = m_attributeMap->getAttributeItem(name))
483             return attribute->value();
484     }
485     return nullAtom;
486 }
487
488 inline const AtomicString& Element::idForStyleResolution() const
489 {
490     ASSERT(hasID());
491     return m_attributeMap->idForStyleResolution();
492 }
493
494 inline bool Element::isIdAttributeName(const QualifiedName& attributeName) const
495 {
496     // FIXME: This check is probably not correct for the case where the document has an id attribute
497     // with a non-null namespace, because it will return false, a false negative, if the prefixes
498     // don't match but the local name and namespace both do. However, since this has been like this
499     // for a while and the code paths may be hot, we'll have to measure performance if we fix it.
500     return attributeName == document()->idAttributeName();
501 }
502
503 inline const AtomicString& Element::getIdAttribute() const
504 {
505     return fastGetAttribute(document()->idAttributeName());
506 }
507
508 inline void Element::setIdAttribute(const AtomicString& value)
509 {
510     setAttribute(document()->idAttributeName(), value);
511 }
512
513 inline AtomicString Element::shadowPseudoId() const
514 {
515     return AtomicString();
516 }
517
518 } // namespace
519
520 #endif