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