WebCore:
[WebKit-https.git] / WebCore / dom / Document.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
6  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
7  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
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
26 #ifndef Document_h
27 #define Document_h
28
29 #include "Attr.h"
30 #include "Color.h"
31 #include "DocumentMarker.h"
32 #include "HTMLCollection.h"
33 #include "HTMLFormElement.h"
34 #include "ScriptExecutionContext.h"
35 #include "StringHash.h"
36 #include "Timer.h"
37 #include <wtf/HashCountedSet.h>
38 #include <wtf/ListHashSet.h>
39
40 // FIXME: We should move Mac off of the old Frame-based user stylesheet loading
41 // code and onto the new code in Page. We can't do that until the code in Page
42 // supports non-file: URLs, however.
43 #if PLATFORM(MAC) || PLATFORM(QT)
44 #define FRAME_LOADS_USER_STYLESHEET 1
45 #else
46 #define FRAME_LOADS_USER_STYLESHEET 0
47 #endif
48
49 namespace WebCore {
50
51     class AXObjectCache;
52     class Attr;
53     class Attribute;
54     class CDATASection;
55     class CachedCSSStyleSheet;
56     class CanvasRenderingContext2D;
57     class CharacterData;
58     class CSSStyleDeclaration;
59     class CSSStyleSelector;
60     class CSSStyleSheet;
61     class Comment;
62     class Database;
63     class DOMImplementation;
64     class DOMSelection;
65     class DOMWindow;
66     class DatabaseThread;
67     class DocLoader;
68     class DocumentFragment;
69     class DocumentType;
70     class EditingText;
71     class Element;
72     class EntityReference;
73     class Event;
74     class EventListener;
75     class FormControlElementWithState;
76     class Frame;
77     class FrameView;
78     class HitTestRequest;
79     class HTMLCanvasElement;
80     class HTMLDocument;
81     class HTMLElement;
82     class HTMLFormElement;
83     class HTMLHeadElement;
84     class HTMLInputElement;
85     class HTMLMapElement;
86     class ImageLoader;
87     class IntPoint;
88     class JSNode;
89     class MouseEventWithHitTestResults;
90     class NodeFilter;
91     class NodeIterator;
92     class Page;
93     class PlatformMouseEvent;
94     class ProcessingInstruction;
95     class Range;
96     class RegisteredEventListener;
97     class RenderArena;
98     class RenderView;
99     class SecurityOrigin;
100     class SegmentedString;
101     class Settings;
102     class StyleSheet;
103     class StyleSheetList;
104     class Text;
105     class TextResourceDecoder;
106     class Tokenizer;
107     class TreeWalker;
108     class XMLHttpRequest;
109
110 #if ENABLE(SVG)
111     class SVGDocumentExtensions;
112 #endif
113     
114 #if ENABLE(XBL)
115     class XBLBindingManager;
116 #endif
117
118 #if ENABLE(XPATH)
119     class XPathEvaluator;
120     class XPathExpression;
121     class XPathNSResolver;
122     class XPathResult;
123 #endif
124
125 #if ENABLE(DASHBOARD_SUPPORT)
126     struct DashboardRegionValue;
127 #endif
128
129     typedef int ExceptionCode;
130
131 class FormElementKey {
132 public:
133     FormElementKey(AtomicStringImpl* = 0, AtomicStringImpl* = 0);
134     ~FormElementKey();
135     FormElementKey(const FormElementKey&);
136     FormElementKey& operator=(const FormElementKey&);
137
138     AtomicStringImpl* name() const { return m_name; }
139     AtomicStringImpl* type() const { return m_type; }
140
141     // Hash table deleted values, which are only constructed and never copied or destroyed.
142     FormElementKey(WTF::HashTableDeletedValueType) : m_name(hashTableDeletedValue()) { }
143     bool isHashTableDeletedValue() const { return m_name == hashTableDeletedValue(); }
144
145 private:
146     void ref() const;
147     void deref() const;
148
149     static AtomicStringImpl* hashTableDeletedValue() { return reinterpret_cast<AtomicStringImpl*>(-1); }
150
151     AtomicStringImpl* m_name;
152     AtomicStringImpl* m_type;
153 };
154
155 inline bool operator==(const FormElementKey& a, const FormElementKey& b)
156 {
157     return a.name() == b.name() && a.type() == b.type();
158 }
159
160 struct FormElementKeyHash {
161     static unsigned hash(const FormElementKey&);
162     static bool equal(const FormElementKey& a, const FormElementKey& b) { return a == b; }
163     static const bool safeToCompareToEmptyOrDeleted = true;
164 };
165
166 struct FormElementKeyHashTraits : WTF::GenericHashTraits<FormElementKey> {
167     static void constructDeletedValue(FormElementKey& slot) { new (&slot) FormElementKey(WTF::HashTableDeletedValue); }
168     static bool isDeletedValue(const FormElementKey& value) { return value.isHashTableDeletedValue(); }
169 };
170
171 class Document : public ContainerNode, public ScriptExecutionContext {
172 public:
173     static PassRefPtr<Document> create(Frame* frame)
174     {
175         return new Document(frame, false);
176     }
177     static PassRefPtr<Document> createXHTML(Frame* frame)
178     {
179         return new Document(frame, true);
180     }
181     virtual ~Document();
182
183     virtual bool isDocument() const { return true; }
184
185     using ContainerNode::ref;
186     using ContainerNode::deref;
187     virtual void removedLastRef();
188
189     // Nodes belonging to this document hold "self-only" references -
190     // these are enough to keep the document from being destroyed, but
191     // not enough to keep it from removing its children. This allows a
192     // node that outlives its document to still have a valid document
193     // pointer without introducing reference cycles
194
195     void selfOnlyRef()
196     {
197         ASSERT(!m_deletionHasBegun);
198         ++m_selfOnlyRefCount;
199     }
200     void selfOnlyDeref()
201     {
202         ASSERT(!m_deletionHasBegun);
203         --m_selfOnlyRefCount;
204         if (!m_selfOnlyRefCount && !refCount()) {
205 #ifndef NDEBUG
206             m_deletionHasBegun = true;
207 #endif
208             delete this;
209         }
210     }
211
212     // DOM methods & attributes for Document
213
214     DocumentType* doctype() const { return m_docType.get(); }
215
216     DOMImplementation* implementation() const;
217     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
218     
219     Element* documentElement() const
220     {
221         if (!m_documentElement)
222             cacheDocumentElement();
223         return m_documentElement.get();
224     }
225     
226     virtual PassRefPtr<Element> createElement(const AtomicString& tagName, ExceptionCode&);
227     PassRefPtr<DocumentFragment> createDocumentFragment ();
228     PassRefPtr<Text> createTextNode(const String& data);
229     PassRefPtr<Comment> createComment(const String& data);
230     PassRefPtr<CDATASection> createCDATASection(const String& data, ExceptionCode&);
231     PassRefPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionCode&);
232     PassRefPtr<Attr> createAttribute(const String& name, ExceptionCode& ec) { return createAttributeNS(String(), name, ec, true); }
233     PassRefPtr<Attr> createAttributeNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&, bool shouldIgnoreNamespaceChecks = false);
234     PassRefPtr<EntityReference> createEntityReference(const String& name, ExceptionCode&);
235     PassRefPtr<Node> importNode(Node* importedNode, bool deep, ExceptionCode&);
236     virtual PassRefPtr<Element> createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
237     PassRefPtr<Element> createElement(const QualifiedName&, bool createdByParser);
238     Element* getElementById(const AtomicString&) const;
239     bool hasElementWithId(AtomicStringImpl* id) const;
240     bool containsMultipleElementsWithId(const AtomicString& elementId) { return m_duplicateIds.contains(elementId.impl()); }
241
242     Element* elementFromPoint(int x, int y) const;
243     String readyState() const;
244
245     String defaultCharset() const;
246     
247     // Synonyms backing similar DOM attributes. Use Document::encoding() to avoid virtual dispatch.
248     String inputEncoding() const { return Document::encoding(); }
249     String charset() const { return Document::encoding(); }
250     String characterSet() const { return Document::encoding(); }
251
252     void setCharset(const String&);
253
254     String contentLanguage() const { return m_contentLanguage; }
255     void setContentLanguage(const String& lang) { m_contentLanguage = lang; }
256
257     String xmlEncoding() const { return m_xmlEncoding; }
258     String xmlVersion() const { return m_xmlVersion; }
259     bool xmlStandalone() const { return m_xmlStandalone; }
260
261     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLTokenizer
262     void setXMLVersion(const String&, ExceptionCode&);
263     void setXMLStandalone(bool, ExceptionCode&);
264
265     String documentURI() const { return m_documentURI; }
266     void setDocumentURI(const String&);
267
268     virtual KURL baseURI() const;
269
270     PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
271
272     PassRefPtr<HTMLCollection> images();
273     PassRefPtr<HTMLCollection> embeds();
274     PassRefPtr<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
275     PassRefPtr<HTMLCollection> applets();
276     PassRefPtr<HTMLCollection> links();
277     PassRefPtr<HTMLCollection> forms();
278     PassRefPtr<HTMLCollection> anchors();
279     PassRefPtr<HTMLCollection> all();
280     PassRefPtr<HTMLCollection> objects();
281     PassRefPtr<HTMLCollection> scripts();
282     PassRefPtr<HTMLCollection> windowNamedItems(const String& name);
283     PassRefPtr<HTMLCollection> documentNamedItems(const String& name);
284
285     // Find first anchor with the given name.
286     // First searches for an element with the given ID, but if that fails, then looks
287     // for an anchor with the given name. ID matching is always case sensitive, but
288     // Anchor name matching is case sensitive in strict mode and not case sensitive in
289     // quirks mode for historical compatibility reasons.
290     Element* findAnchor(const String& name);
291
292     HTMLCollection::CollectionInfo* collectionInfo(HTMLCollection::Type type)
293     {
294         ASSERT(type >= HTMLCollection::FirstUnnamedDocumentCachedType);
295         unsigned index = type - HTMLCollection::FirstUnnamedDocumentCachedType;
296         ASSERT(index < HTMLCollection::NumUnnamedDocumentCachedTypes);
297         return &m_collectionInfo[index]; 
298     }
299
300     HTMLCollection::CollectionInfo* nameCollectionInfo(HTMLCollection::Type, const AtomicString& name);
301
302     // DOM methods overridden from  parent classes
303
304     virtual String nodeName() const;
305     virtual NodeType nodeType() const;
306
307     // Other methods (not part of DOM)
308     virtual bool isHTMLDocument() const { return false; }
309     virtual bool isImageDocument() const { return false; }
310 #if ENABLE(SVG)
311     virtual bool isSVGDocument() const { return false; }
312 #endif
313     virtual bool isPluginDocument() const { return false; }
314     virtual bool isMediaDocument() const { return false; }
315 #if ENABLE(WML)
316     virtual bool isWMLDocument() const { return false; }
317 #endif
318     virtual bool isFrameSet() const { return false; }
319     
320     CSSStyleSelector* styleSelector() const { return m_styleSelector; }
321
322     Element* getElementByAccessKey(const String& key) const;
323     
324     /**
325      * Updates the pending sheet count and then calls updateStyleSelector.
326      */
327     void removePendingSheet();
328
329     /**
330      * This method returns true if all top-level stylesheets have loaded (including
331      * any @imports that they may be loading).
332      */
333     bool haveStylesheetsLoaded() const
334     {
335         return m_pendingStylesheets <= 0 || m_ignorePendingStylesheets;
336     }
337
338     /**
339      * Increments the number of pending sheets.  The <link> elements
340      * invoke this to add themselves to the loading list.
341      */
342     void addPendingSheet() { m_pendingStylesheets++; }
343
344     void addStyleSheetCandidateNode(Node*, bool createdByParser);
345     void removeStyleSheetCandidateNode(Node*);
346
347     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
348     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
349
350     /**
351      * Called when one or more stylesheets in the document may have been added, removed or changed.
352      *
353      * Creates a new style selector and assign it to this document. This is done by iterating through all nodes in
354      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
355      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
356      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
357      * found and is used to calculate the derived styles for all rendering objects.
358      */
359     void updateStyleSelector();
360
361     void recalcStyleSelector();
362
363     bool usesDescendantRules() const { return m_usesDescendantRules; }
364     void setUsesDescendantRules(bool b) { m_usesDescendantRules = b; }
365     bool usesSiblingRules() const { return m_usesSiblingRules; }
366     void setUsesSiblingRules(bool b) { m_usesSiblingRules = b; }
367     bool usesFirstLineRules() const { return m_usesFirstLineRules; }
368     void setUsesFirstLineRules(bool b) { m_usesFirstLineRules = b; }
369     bool usesFirstLetterRules() const { return m_usesFirstLetterRules; }
370     void setUsesFirstLetterRules(bool b) { m_usesFirstLetterRules = b; }
371     bool usesBeforeAfterRules() const { return m_usesBeforeAfterRules; }
372     void setUsesBeforeAfterRules(bool b) { m_usesBeforeAfterRules = b; }
373
374     // Machinery for saving and restoring state when you leave and then go back to a page.
375     void registerFormElementWithState(FormControlElementWithState* e) { m_formElementsWithState.add(e); }
376     void unregisterFormElementWithState(FormControlElementWithState* e) { m_formElementsWithState.remove(e); }
377     Vector<String> formElementsState() const;
378     void setStateForNewFormElements(const Vector<String>&);
379     bool hasStateForNewFormElements() const;
380     bool takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state);
381
382     FrameView* view() const; // can be NULL
383     Frame* frame() const { return m_frame; } // can be NULL
384     Page* page() const; // can be NULL
385     Settings* settings() const; // can be NULL
386
387     PassRefPtr<Range> createRange();
388
389     PassRefPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow,
390         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
391
392     PassRefPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow, 
393         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
394
395     // Special support for editing
396     PassRefPtr<CSSStyleDeclaration> createCSSStyleDeclaration();
397     PassRefPtr<EditingText> createEditingTextNode(const String&);
398
399     virtual void recalcStyle( StyleChange = NoChange );
400     virtual void updateRendering();
401     void updateLayout();
402     void updateLayoutIgnorePendingStylesheets();
403     static void updateDocumentsRendering();
404     DocLoader* docLoader() { return m_docLoader; }
405
406     virtual void attach();
407     virtual void detach();
408
409     void clearFramePointer();
410
411     RenderArena* renderArena() { return m_renderArena; }
412
413     RenderView* renderView() const;
414
415     void clearAXObjectCache();
416     AXObjectCache* axObjectCache() const;
417     
418     // to get visually ordered hebrew and arabic pages right
419     void setVisuallyOrdered();
420
421     void open(Document* ownerDocument = 0);
422     void implicitOpen();
423     void close();
424     void implicitClose();
425     void cancelParsing();
426
427     void write(const SegmentedString& text, Document* ownerDocument = 0);
428     void write(const String& text, Document* ownerDocument = 0);
429     void writeln(const String& text, Document* ownerDocument = 0);
430     void finishParsing();
431     void clear();
432
433     bool wellFormed() const { return m_wellFormed; }
434
435     const KURL& url() const { return m_url; }
436     void setURL(const KURL&);
437
438     const KURL& baseURL() const { return m_baseURL; }
439     // Setting the BaseElementURL will change the baseURL.
440     void setBaseElementURL(const KURL&);
441
442     const String& baseTarget() const { return m_baseTarget; }
443     // Setting the BaseElementTarget will change the baseTarget.
444     void setBaseElementTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
445
446     KURL completeURL(const String&) const;
447
448     virtual String userAgent(const KURL&) const;
449     virtual String encoding() const;
450
451     // from cachedObjectClient
452     virtual void setCSSStyleSheet(const String& url, const String& charset, const CachedCSSStyleSheet*);
453
454 #if FRAME_LOADS_USER_STYLESHEET
455     void setUserStyleSheet(const String& sheet);
456 #endif
457
458     String userStyleSheet() const;
459
460     CSSStyleSheet* elementSheet();
461     CSSStyleSheet* mappedElementSheet();
462     virtual Tokenizer* createTokenizer();
463     Tokenizer* tokenizer() { return m_tokenizer; }
464     
465     bool printing() const { return m_printing; }
466     void setPrinting(bool p) { m_printing = p; }
467
468     enum ParseMode { Compat, AlmostStrict, Strict };
469
470 private:
471     virtual void determineParseMode() {}
472     
473 public:
474     void setParseMode(ParseMode m) { m_parseMode = m; }
475     ParseMode parseMode() const { return m_parseMode; }
476
477     bool inCompatMode() const { return m_parseMode == Compat; }
478     bool inAlmostStrictMode() const { return m_parseMode == AlmostStrict; }
479     bool inStrictMode() const { return m_parseMode == Strict; }
480     
481     void setParsing(bool);
482     bool parsing() const { return m_bParsing; }
483     int minimumLayoutDelay();
484     bool shouldScheduleLayout();
485     int elapsedTime() const;
486     
487     void setTextColor(const Color& color) { m_textColor = color; }
488     Color textColor() const { return m_textColor; }
489
490     const Color& linkColor() const { return m_linkColor; }
491     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
492     const Color& activeLinkColor() const { return m_activeLinkColor; }
493     void setLinkColor(const Color& c) { m_linkColor = c; }
494     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
495     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
496     void resetLinkColor();
497     void resetVisitedLinkColor();
498     void resetActiveLinkColor();
499     
500     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const IntPoint&, const PlatformMouseEvent&);
501
502     virtual bool childTypeAllowed(NodeType);
503     virtual PassRefPtr<Node> cloneNode(bool deep);
504
505     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
506     
507     StyleSheetList* styleSheets();
508
509     /* Newly proposed CSS3 mechanism for selecting alternate
510        stylesheets using the DOM. May be subject to change as
511        spec matures. - dwh
512     */
513     String preferredStylesheetSet() const;
514     String selectedStylesheetSet() const;
515     void setSelectedStylesheetSet(const String&);
516
517     bool setFocusedNode(PassRefPtr<Node>);
518     Node* focusedNode() const { return m_focusedNode.get(); }
519
520     // The m_ignoreAutofocus flag specifies whether or not the document has been changed by the user enough 
521     // for WebCore to ignore the autofocus attribute on any form controls
522     bool ignoreAutofocus() const { return m_ignoreAutofocus; };
523     void setIgnoreAutofocus(bool shouldIgnore = true) { m_ignoreAutofocus = shouldIgnore; };
524
525     void setHoverNode(PassRefPtr<Node>);
526     Node* hoverNode() const { return m_hoverNode.get(); }
527
528     void setActiveNode(PassRefPtr<Node>);
529     Node* activeNode() const { return m_activeNode.get(); }
530
531     void focusedNodeRemoved();
532     void removeFocusedNodeOfSubtree(Node*, bool amongChildrenOnly = false);
533     void hoveredNodeDetached(Node*);
534     void activeChainNodeDetached(Node*);
535
536     // Updates for :target (CSS3 selector).
537     void setCSSTarget(Element*);
538     Element* cssTarget() const { return m_cssTarget; }
539     
540     void setDocumentChanged(bool);
541
542     void attachNodeIterator(NodeIterator*);
543     void detachNodeIterator(NodeIterator*);
544
545     void attachRange(Range*);
546     void detachRange(Range*);
547
548     void nodeChildrenChanged(ContainerNode*);
549     void nodeWillBeRemoved(Node*);
550
551     void textInserted(Node*, unsigned offset, unsigned length);
552     void textRemoved(Node*, unsigned offset, unsigned length);
553     void textNodesMerged(Text* oldNode, unsigned offset);
554     void textNodeSplit(Text* oldNode);
555
556     DOMWindow* defaultView() const { return domWindow(); } 
557     DOMWindow* domWindow() const;
558
559     PassRefPtr<Event> createEvent(const String& eventType, ExceptionCode&);
560
561     // keep track of what types of event listeners are registered, so we don't
562     // dispatch events unnecessarily
563     enum ListenerType {
564         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
565         DOMNODEINSERTED_LISTENER             = 0x02,
566         DOMNODEREMOVED_LISTENER              = 0x04,
567         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
568         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
569         DOMATTRMODIFIED_LISTENER             = 0x20,
570         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40,
571         OVERFLOWCHANGED_LISTENER             = 0x80,
572         ANIMATIONEND_LISTENER                = 0x100,
573         ANIMATIONSTART_LISTENER              = 0x200,
574         ANIMATIONITERATION_LISTENER          = 0x400,
575         TRANSITIONEND_LISTENER               = 0x800
576     };
577
578     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
579     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
580     void addListenerTypeIfNeeded(const AtomicString& eventType);
581
582     CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
583
584     void handleWindowEvent(Event*, bool useCapture);
585     void setWindowInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener>);
586     EventListener* windowInlineEventListenerForType(const AtomicString& eventType);
587     void removeWindowInlineEventListenerForType(const AtomicString& eventType);
588
589     void setWindowInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute*);
590
591     void addWindowEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
592     void removeWindowEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
593     bool hasWindowEventListener(const AtomicString& eventType);
594     
595     void addPendingFrameUnloadEventCount();
596     void removePendingFrameUnloadEventCount();
597     void addPendingFrameBeforeUnloadEventCount();
598     void removePendingFrameBeforeUnloadEventCount();
599
600     PassRefPtr<EventListener> createEventListener(const String& functionName, const String& code, Node*);
601
602     /**
603      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
604      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
605      * first (from lowest to highest), and then elements without tab indexes (in document order).
606      *
607      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
608      *
609      * @return The focus node that comes after fromNode
610      *
611      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
612      */
613     Node* nextFocusableNode(Node* start, KeyboardEvent*);
614
615     /**
616      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
617      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
618      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
619      *
620      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
621      *
622      * @return The focus node that comes before fromNode
623      *
624      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
625      */
626     Node* previousFocusableNode(Node* start, KeyboardEvent*);
627
628     int nodeAbsIndex(Node*);
629     Node* nodeWithAbsIndex(int absIndex);
630
631     /**
632      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
633      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
634      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
635      * specified in a HTML file.
636      *
637      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
638      * @param content The header value (value of the meta tag's "content" attribute)
639      */
640     void processHttpEquiv(const String& equiv, const String& content);
641     
642     void dispatchImageLoadEventSoon(ImageLoader*);
643     void dispatchImageLoadEventsNow();
644     void removeImage(ImageLoader*);
645     
646     // Returns the owning element in the parent document.
647     // Returns 0 if this is the top level document.
648     Element* ownerElement() const;
649
650     String title() const { return m_title; }
651     void setTitle(const String&, Element* titleElement = 0);
652     void removeTitle(Element* titleElement);
653
654     String cookie() const;
655     void setCookie(const String&);
656
657     String referrer() const;
658
659     String domain() const;
660     void setDomain(const String& newDomain);
661
662     String lastModified() const;
663
664     const KURL& cookieURL() const { return m_cookieURL; }
665
666     const KURL& policyBaseURL() const { return m_policyBaseURL; }
667     void setPolicyBaseURL(const KURL& url) { m_policyBaseURL = url; }
668     
669     // The following implements the rule from HTML 4 for what valid names are.
670     // To get this right for all the XML cases, we probably have to improve this or move it
671     // and make it sensitive to the type of document.
672     static bool isValidName(const String&);
673
674     // The following breaks a qualified name into a prefix and a local name.
675     // It also does a validity check, and returns false if the qualified name
676     // is invalid.  It also sets ExceptionCode when name is invalid.
677     static bool parseQualifiedName(const String& qualifiedName, String& prefix, String& localName, ExceptionCode&);
678     
679     // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
680     static bool hasPrefixNamespaceMismatch(const QualifiedName&);
681     
682     void addElementById(const AtomicString& elementId, Element *element);
683     void removeElementById(const AtomicString& elementId, Element *element);
684
685     void addImageMap(HTMLMapElement*);
686     void removeImageMap(HTMLMapElement*);
687     HTMLMapElement* getImageMap(const String& url) const;
688
689     HTMLElement* body() const;
690     void setBody(PassRefPtr<HTMLElement>, ExceptionCode&);
691
692     HTMLHeadElement* head();
693
694     bool execCommand(const String& command, bool userInterface = false, const String& value = String());
695     bool queryCommandEnabled(const String& command);
696     bool queryCommandIndeterm(const String& command);
697     bool queryCommandState(const String& command);
698     bool queryCommandSupported(const String& command);
699     String queryCommandValue(const String& command);
700     
701     void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
702     void addMarker(Node*, DocumentMarker);
703     void copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
704     void removeMarkers(Range*, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
705     void removeMarkers(Node*, unsigned startOffset, int length, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
706     void removeMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
707     void removeMarkers(Node*);
708     void repaintMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
709     void setRenderedRectForMarker(Node*, DocumentMarker, const IntRect&);
710     void invalidateRenderedRectsForMarkersInRect(const IntRect&);
711     void shiftMarkers(Node*, unsigned startOffset, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
712
713     DocumentMarker* markerContainingPoint(const IntPoint&, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
714     Vector<DocumentMarker> markersForNode(Node*);
715     Vector<IntRect> renderedRectsForMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
716     
717     // designMode support
718     enum InheritedBool { off = false, on = true, inherit };    
719     void setDesignMode(InheritedBool value);
720     InheritedBool getDesignMode() const;
721     bool inDesignMode() const;
722
723     Document* parentDocument() const;
724     Document* topDocument() const;
725
726     int docID() const { return m_docID; }
727
728 #if ENABLE(XSLT)
729     void applyXSLTransform(ProcessingInstruction* pi);
730     void setTransformSource(void* doc);
731     const void* transformSource() { return m_transformSource; }
732     PassRefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
733     void setTransformSourceDocument(Document* doc) { m_transformSourceDocument = doc; }
734 #endif
735
736 #if ENABLE(XBL)
737     // XBL methods
738     XBLBindingManager* bindingManager() const { return m_bindingManager; }
739 #endif
740
741     void incDOMTreeVersion() { ++m_domtree_version; }
742     unsigned domTreeVersion() const { return m_domtree_version; }
743
744     void setDocType(PassRefPtr<DocumentType>);
745
746     virtual void finishedParsing();
747
748 #if ENABLE(XPATH)
749     // XPathEvaluator methods
750     PassRefPtr<XPathExpression> createExpression(const String& expression,
751                                                  XPathNSResolver* resolver,
752                                                  ExceptionCode& ec);
753     PassRefPtr<XPathNSResolver> createNSResolver(Node *nodeResolver);
754     PassRefPtr<XPathResult> evaluate(const String& expression,
755                                      Node* contextNode,
756                                      XPathNSResolver* resolver,
757                                      unsigned short type,
758                                      XPathResult* result,
759                                      ExceptionCode& ec);
760 #endif // ENABLE(XPATH)
761     
762     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
763
764     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
765     
766     void setHasNodesWithPlaceholderStyle() { m_hasNodesWithPlaceholderStyle = true; }
767
768     const String& iconURL() const { return m_iconURL; }
769     void setIconURL(const String& iconURL, const String& type);
770
771     void setUseSecureKeyboardEntryWhenActive(bool);
772     bool useSecureKeyboardEntryWhenActive() const;
773
774     void addNodeListCache() { ++m_numNodeListCaches; }
775     void removeNodeListCache() { ASSERT(m_numNodeListCaches > 0); --m_numNodeListCaches; }
776     bool hasNodeListCaches() const { return m_numNodeListCaches; }
777
778     void updateFocusAppearanceSoon();
779     void cancelFocusAppearanceUpdate();
780         
781     // FF method for accessing the selection added for compatability.
782     DOMSelection* getSelection() const;
783     
784     // Extension for manipulating canvas drawing contexts for use in CSS
785     CanvasRenderingContext2D* getCSSCanvasContext(const String& type, const String& name, int width, int height);
786     HTMLCanvasElement* getCSSCanvasElement(const String& name);
787
788     bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
789     void initDNSPrefetch();
790     void parseDNSPrefetchControlHeader(const String&);
791
792     virtual void reportException(const String& errorMessage, int lineNumber, const String& sourceURL);
793     virtual void addMessage(MessageDestination, MessageSource, MessageLevel, const String& message, unsigned lineNumber, const String& sourceURL);
794     virtual void resourceRetrievedByXMLHttpRequest(unsigned long identifier, const ScriptString& sourceString);
795     virtual void postTask(PassRefPtr<Task>); // Executes the task on context's thread asynchronously.
796
797 protected:
798     Document(Frame*, bool isXHTML);
799
800 private:
801     virtual void refScriptExecutionContext() { ref(); }
802     virtual void derefScriptExecutionContext() { deref(); }
803
804     virtual const KURL& virtualURL() const; // Same as url(), but needed for ScriptExecutionContext to implement it without a performance loss for direct calls.
805     virtual KURL virtualCompleteURL(const String&) const; // Same as completeURL() for the same reason as above.
806
807     CSSStyleSelector* m_styleSelector;
808     bool m_didCalculateStyleSelector;
809
810     Frame* m_frame;
811     DocLoader* m_docLoader;
812     Tokenizer* m_tokenizer;
813     bool m_wellFormed;
814
815     // Document URLs.
816     KURL m_url;  // Document.URL: The URL from which this document was retrieved.
817     KURL m_baseURL;  // Node.baseURI: The URL to use when resolving relative URLs.
818     KURL m_baseElementURL;  // The URL set by the <base> element.
819     KURL m_cookieURL;  // The URL to use for cookie access.
820     KURL m_policyBaseURL;  // The policy URL for third-party cookie blocking.
821
822     // Document.documentURI:
823     // Although URL-like, Document.documentURI can actually be set to any
824     // string by content.  Document.documentURI affects m_baseURL unless the
825     // document contains a <base> element, in which case the <base> element
826     // takes precedence.
827     String m_documentURI;
828
829     String m_baseTarget;
830
831     RefPtr<DocumentType> m_docType;
832     mutable RefPtr<DOMImplementation> m_implementation;
833
834     RefPtr<StyleSheet> m_sheet;
835 #if FRAME_LOADS_USER_STYLESHEET
836     String m_usersheet;
837 #endif
838
839     // Track the number of currently loading top-level stylesheets.  Sheets
840     // loaded using the @import directive are not included in this count.
841     // We use this count of pending sheets to detect when we can begin attaching
842     // elements.
843     int m_pendingStylesheets;
844
845     // But sometimes you need to ignore pending stylesheet count to
846     // force an immediate layout when requested by JS.
847     bool m_ignorePendingStylesheets;
848
849     // If we do ignore the pending stylesheet count, then we need to add a boolean
850     // to track that this happened so that we can do a full repaint when the stylesheets
851     // do eventually load.
852     PendingSheetLayout m_pendingSheetLayout;
853     
854     bool m_hasNodesWithPlaceholderStyle;
855
856     RefPtr<CSSStyleSheet> m_elemSheet;
857     RefPtr<CSSStyleSheet> m_mappedElementSheet;
858
859     bool m_printing;
860     
861     bool m_ignoreAutofocus;
862
863     ParseMode m_parseMode;
864
865     Color m_textColor;
866
867     RefPtr<Node> m_focusedNode;
868     RefPtr<Node> m_hoverNode;
869     RefPtr<Node> m_activeNode;
870     mutable RefPtr<Element> m_documentElement;
871
872     unsigned m_domtree_version;
873     
874     HashSet<NodeIterator*> m_nodeIterators;
875     HashSet<Range*> m_ranges;
876
877     unsigned short m_listenerTypes;
878
879     RefPtr<StyleSheetList> m_styleSheets; // All of the stylesheets that are currently in effect for our media type and stylesheet set.
880     ListHashSet<Node*> m_styleSheetCandidateNodes; // All of the nodes that could potentially provide stylesheets to the document (<link>, <style>, <?xml-stylesheet>)
881
882     RegisteredEventListenerVector m_windowEventListeners;
883
884     typedef HashMap<FormElementKey, Vector<String>, FormElementKeyHash, FormElementKeyHashTraits> FormElementStateMap;
885     ListHashSet<FormControlElementWithState*> m_formElementsWithState;
886     FormElementStateMap m_stateForNewFormElements;
887     
888     Color m_linkColor;
889     Color m_visitedLinkColor;
890     Color m_activeLinkColor;
891
892     String m_preferredStylesheetSet;
893     String m_selectedStylesheetSet;
894
895     bool m_loadingSheet;
896     bool visuallyOrdered;
897     bool m_bParsing;
898     bool m_docChanged;
899     bool m_inStyleRecalc;
900     bool m_closeAfterStyleRecalc;
901     bool m_usesDescendantRules;
902     bool m_usesSiblingRules;
903     bool m_usesFirstLineRules;
904     bool m_usesFirstLetterRules;
905     bool m_usesBeforeAfterRules;
906     bool m_gotoAnchorNeededAfterStylesheetsLoad;
907     bool m_isDNSPrefetchEnabled;
908     bool m_haveExplicitlyDisabledDNSPrefetch;
909     bool m_frameElementsShouldIgnoreScrolling;
910
911     String m_title;
912     bool m_titleSetExplicitly;
913     RefPtr<Element> m_titleElement;
914     
915     RenderArena* m_renderArena;
916
917     typedef std::pair<Vector<DocumentMarker>, Vector<IntRect> > MarkerMapVectorPair;
918     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
919     MarkerMap m_markers;
920
921     mutable AXObjectCache* m_axObjectCache;
922     
923     Vector<ImageLoader*> m_imageLoadEventDispatchSoonList;
924     Vector<ImageLoader*> m_imageLoadEventDispatchingList;
925     Timer<Document> m_imageLoadEventTimer;
926
927     Timer<Document> m_updateFocusAppearanceTimer;
928
929     Element* m_cssTarget;
930     
931     bool m_processingLoadEvent;
932     double m_startTime;
933     bool m_overMinimumLayoutThreshold;
934     
935 #if ENABLE(XSLT)
936     void* m_transformSource;
937     RefPtr<Document> m_transformSourceDocument;
938 #endif
939
940 #if ENABLE(XBL)
941     XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
942 #endif
943     
944     typedef HashMap<AtomicStringImpl*, HTMLMapElement*> ImageMapsByName;
945     ImageMapsByName m_imageMapsByName;
946
947     HashSet<Node*> m_disconnectedNodesWithEventListeners;
948
949     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
950
951     String m_xmlEncoding;
952     String m_xmlVersion;
953     bool m_xmlStandalone;
954
955     String m_contentLanguage;
956
957 public:
958     bool inPageCache() const { return m_inPageCache; }
959     void setInPageCache(bool flag);
960     
961     // Elements can register themselves for the "documentWillBecomeInactive()" and  
962     // "documentDidBecomeActive()" callbacks
963     void registerForDocumentActivationCallbacks(Element*);
964     void unregisterForDocumentActivationCallbacks(Element*);
965     void documentWillBecomeInactive();
966     void documentDidBecomeActive();
967
968     void registerForMediaVolumeCallbacks(Element*);
969     void unregisterForMediaVolumeCallbacks(Element*);
970     void mediaVolumeDidChange();
971
972     void setShouldCreateRenderers(bool);
973     bool shouldCreateRenderers();
974     
975     void setDecoder(PassRefPtr<TextResourceDecoder>);
976     TextResourceDecoder* decoder() const { return m_decoder.get(); }
977
978     String displayStringModifiedByEncoding(const String&) const;
979     PassRefPtr<StringImpl> displayStringModifiedByEncoding(PassRefPtr<StringImpl>) const;
980     void displayBufferModifiedByEncoding(UChar* buffer, unsigned len) const;
981
982     // Quirk for the benefit of Apple's Dictionary application.
983     void setFrameElementsShouldIgnoreScrolling(bool ignore) { m_frameElementsShouldIgnoreScrolling = ignore; }
984     bool frameElementsShouldIgnoreScrolling() const { return m_frameElementsShouldIgnoreScrolling; }
985
986 #if ENABLE(DASHBOARD_SUPPORT)
987     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
988     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
989     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
990     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
991     const Vector<DashboardRegionValue>& dashboardRegions() const;
992     void setDashboardRegions(const Vector<DashboardRegionValue>&);
993 #endif
994
995     void removeAllEventListenersFromAllNodes();
996
997     void registerDisconnectedNodeWithEventListeners(Node*);
998     void unregisterDisconnectedNodeWithEventListeners(Node*);
999     
1000     HTMLFormElement::CheckedRadioButtons& checkedRadioButtons() { return m_checkedRadioButtons; }
1001     
1002 #if ENABLE(SVG)
1003     const SVGDocumentExtensions* svgExtensions();
1004     SVGDocumentExtensions* accessSVGExtensions();
1005 #endif
1006
1007     void initSecurityContext();
1008
1009     // Explicitly override the security origin for this document.
1010     // Note: It is dangerous to change the security origin of a document
1011     //       that already contains content.
1012     void setSecurityOrigin(SecurityOrigin*);
1013
1014     bool processingLoadEvent() const { return m_processingLoadEvent; }
1015
1016 #if ENABLE(DATABASE)
1017     void addOpenDatabase(Database*);
1018     void removeOpenDatabase(Database*);
1019     DatabaseThread* databaseThread();   // Creates the thread as needed, but not if it has been already terminated.
1020     void setHasOpenDatabases() { m_hasOpenDatabases = true; }
1021     bool hasOpenDatabases() { return m_hasOpenDatabases; }
1022     void stopDatabases();
1023 #endif
1024     
1025     void setUsingGeolocation(bool f) { m_usingGeolocation = f; }
1026     bool usingGeolocation() const { return m_usingGeolocation; };
1027
1028 #if ENABLE(WML)
1029     void resetWMLPageState();
1030 #endif
1031
1032 protected:
1033     void clearXMLVersion() { m_xmlVersion = String(); }
1034
1035 private:
1036     void updateTitle();
1037     void removeAllDisconnectedNodeEventListeners();
1038     void imageLoadEventTimerFired(Timer<Document>*);
1039     void updateFocusAppearanceTimerFired(Timer<Document>*);
1040     void updateBaseURL();
1041
1042     void cacheDocumentElement() const;
1043
1044     RenderObject* m_savedRenderer;
1045     int m_secureForms;
1046     
1047     RefPtr<TextResourceDecoder> m_decoder;
1048
1049     // We maintain the invariant that m_duplicateIds is the count of all elements with a given ID
1050     // excluding the one referenced in m_elementsById, if any. This means it one less than the total count
1051     // when the first node with a given ID is cached, otherwise the same as the total count.
1052     mutable HashMap<AtomicStringImpl*, Element*> m_elementsById;
1053     mutable HashCountedSet<AtomicStringImpl*> m_duplicateIds;
1054     
1055     mutable HashMap<StringImpl*, Element*, CaseFoldingHash> m_elementsByAccessKey;
1056     
1057     InheritedBool m_designMode;
1058     
1059     int m_selfOnlyRefCount;
1060
1061     HTMLFormElement::CheckedRadioButtons m_checkedRadioButtons;
1062
1063     typedef HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo*> NamedCollectionMap;
1064     HTMLCollection::CollectionInfo m_collectionInfo[HTMLCollection::NumUnnamedDocumentCachedTypes];
1065     NamedCollectionMap m_nameCollectionInfo[HTMLCollection::NumNamedDocumentCachedTypes];
1066
1067 #if ENABLE(XPATH)
1068     RefPtr<XPathEvaluator> m_xpathEvaluator;
1069 #endif
1070     
1071 #if ENABLE(SVG)
1072     OwnPtr<SVGDocumentExtensions> m_svgExtensions;
1073 #endif
1074     
1075 #if ENABLE(DASHBOARD_SUPPORT)
1076     Vector<DashboardRegionValue> m_dashboardRegions;
1077     bool m_hasDashboardRegions;
1078     bool m_dashboardRegionsDirty;
1079 #endif
1080
1081     HashMap<String, RefPtr<HTMLCanvasElement> > m_cssCanvasElements;
1082
1083     mutable bool m_accessKeyMapValid;
1084     bool m_createRenderers;
1085     bool m_inPageCache;
1086     String m_iconURL;
1087     
1088     HashSet<Element*> m_documentActivationCallbackElements;
1089     HashSet<Element*> m_mediaVolumeCallbackElements;
1090
1091     bool m_useSecureKeyboardEntryWhenActive;
1092
1093     bool m_isXHTML;
1094
1095     unsigned m_numNodeListCaches;
1096
1097 public:
1098     typedef HashMap<WebCore::Node*, JSNode*> JSWrapperCache;
1099     JSWrapperCache& wrapperCache() { return m_wrapperCache; }
1100 private:
1101     JSWrapperCache m_wrapperCache;
1102
1103 #if ENABLE(DATABASE)
1104     RefPtr<DatabaseThread> m_databaseThread;
1105     bool m_hasOpenDatabases;    // This never changes back to false, even as the database thread is closed.
1106     typedef HashSet<Database*> DatabaseSet;
1107     OwnPtr<DatabaseSet> m_openDatabaseSet;
1108 #endif
1109     
1110     bool m_usingGeolocation;
1111 };
1112
1113 inline bool Document::hasElementWithId(AtomicStringImpl* id) const
1114 {
1115     ASSERT(id);
1116     return m_elementsById.contains(id) || m_duplicateIds.contains(id);
1117 }
1118     
1119 inline bool Node::isDocumentNode() const
1120 {
1121     return this == m_document.get();
1122 }
1123
1124 } // namespace WebCore
1125
1126 #endif // Document_h