9cac76127aa36486f31637f3fc0a60632fd82888
[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 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 Document_h
26 #define Document_h
27
28 #include "Attr.h"
29 #include "Color.h"
30 #include "DeprecatedPtrList.h"
31 #include "DeprecatedValueList.h"
32 #include "DocumentMarker.h"
33 #include "HTMLCollection.h"
34 #include "HTMLFormElement.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)
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 CSSStyleDeclaration;
57     class CSSStyleSelector;
58     class CSSStyleSheet;
59     class Comment;
60     class DOMImplementation;
61     class DOMWindow;
62     class DatabaseThread;
63     class DocLoader;
64     class DocumentFragment;
65     class DocumentType;
66     class EditingText;
67     class Element;
68     class EntityReference;
69     class Event;
70     class EventListener;
71     class Frame;
72     class FrameView;
73     class HTMLDocument;
74     class HTMLElement;
75     class HTMLFormControlElementWithState;
76     class HTMLFormElement;
77     class HTMLHeadElement;
78     class HTMLImageLoader;
79     class HTMLInputElement;
80     class HTMLMapElement;
81     class IntPoint;
82     class MouseEventWithHitTestResults;
83     class NameNodeList;
84     class NodeFilter;
85     class NodeIterator;
86     class NodeList;
87     class Page;
88     class PlatformMouseEvent;
89     class ProcessingInstruction;
90     class Range;
91     class RegisteredEventListener;
92     class RenderArena;
93     class SecurityOrigin;
94     class Settings;
95     class StyleSheet;
96     class StyleSheetList;
97     class Text;
98     class TextResourceDecoder;
99     class Tokenizer;
100     class TreeWalker;
101 #if ENABLE(XBL)
102     class XBLBindingManager;
103 #endif
104 #if ENABLE(XPATH)
105     class XPathEvaluator;
106     class XPathExpression;
107     class XPathNSResolver;
108     class XPathResult;
109 #endif
110     
111     struct DashboardRegionValue;
112     struct HitTestRequest;
113
114 #if ENABLE(SVG)
115     class SVGDocumentExtensions;
116 #endif
117
118     typedef int ExceptionCode;
119
120 class FormElementKey {
121 public:
122     FormElementKey(AtomicStringImpl* = 0, AtomicStringImpl* = 0);
123     ~FormElementKey();
124     FormElementKey(const FormElementKey&);
125     FormElementKey& operator=(const FormElementKey&);
126     AtomicStringImpl* name() const { return m_name; }
127     AtomicStringImpl* type() const { return m_type; }
128 private:
129     void ref() const;
130     void deref() const;
131     AtomicStringImpl* m_name;
132     AtomicStringImpl* m_type;
133 };
134
135 inline bool operator==(const FormElementKey& a, const FormElementKey& b)
136     { return a.name() == b.name() && a.type() == b.type(); }
137
138 struct FormElementKeyHash {
139     static unsigned hash(const FormElementKey&);
140     static bool equal(const FormElementKey& a, const FormElementKey& b) { return a == b; }
141     static const bool safeToCompareToEmptyOrDeleted = true;
142 };
143
144 struct FormElementKeyHashTraits : WTF::GenericHashTraits<FormElementKey> {
145     static FormElementKey deletedValue();
146 };
147
148 class Document : public ContainerNode {
149 public:
150     Document(DOMImplementation*, Frame*, bool isXHTML = false);
151     virtual ~Document();
152
153     virtual void removedLastRef();
154
155     // Nodes belonging to this document hold "self-only" references -
156     // these are enough to keep the document from being destroyed, but
157     // not enough to keep it from removing its children. This allows a
158     // node that outlives its document to still have a valid document
159     // pointer without introducing reference cycles
160
161     void selfOnlyRef()
162     {
163         ASSERT(!m_deletionHasBegun);
164         ++m_selfOnlyRefCount;
165     }
166     void selfOnlyDeref()
167     {
168         ASSERT(!m_deletionHasBegun);
169         --m_selfOnlyRefCount;
170         if (!m_selfOnlyRefCount && !refCount()) {
171 #ifndef NDEBUG
172             m_deletionHasBegun = true;
173 #endif
174             delete this;
175         }
176     }
177
178     // DOM methods & attributes for Document
179
180     virtual DocumentType* doctype() const; // May return 0 for HTML documents
181     DocumentType* realDocType() const { return m_docType.get(); }
182
183     DOMImplementation* implementation() const;
184     virtual void childrenChanged(bool changedByParser = false);
185     Element* documentElement() const;
186     virtual PassRefPtr<Element> createElement(const String& tagName, ExceptionCode&);
187     PassRefPtr<DocumentFragment> createDocumentFragment ();
188     PassRefPtr<Text> createTextNode(const String& data);
189     PassRefPtr<Comment> createComment(const String& data);
190     PassRefPtr<CDATASection> createCDATASection(const String& data, ExceptionCode&);
191     PassRefPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionCode&);
192     PassRefPtr<Attr> createAttribute(const String& name, ExceptionCode& ec) { return createAttributeNS(String(), name, ec); }
193     PassRefPtr<Attr> createAttributeNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
194     PassRefPtr<EntityReference> createEntityReference(const String& name, ExceptionCode&);
195     PassRefPtr<Node> importNode(Node* importedNode, bool deep, ExceptionCode&);
196     virtual PassRefPtr<Element> createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
197     PassRefPtr<Element> createElement(const QualifiedName&, bool createdByParser, ExceptionCode& ec);
198     Element* getElementById(const AtomicString&) const;
199
200     Element* elementFromPoint(int x, int y) const;
201     String readyState() const;
202     String inputEncoding() const;
203     String defaultCharset() const;
204
205     String charset() const { return inputEncoding(); }
206     String characterSet() const { return inputEncoding(); }
207
208     void setCharset(const String&);
209
210     String contentLanguage() const { return m_contentLanguage; }
211     void setContentLanguage(const String& lang) { m_contentLanguage = lang; }
212
213     String xmlEncoding() const { return m_xmlEncoding; }
214     String xmlVersion() const { return m_xmlVersion; }
215     bool xmlStandalone() const { return m_xmlStandalone; }
216
217     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLTokenizer
218     void setXMLVersion(const String&, ExceptionCode&);
219     void setXMLStandalone(bool, ExceptionCode&);
220
221     String documentURI() const;
222     void setDocumentURI(const String&);
223
224     virtual String baseURI() const;
225
226     PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
227
228     PassRefPtr<HTMLCollection> images();
229     PassRefPtr<HTMLCollection> embeds();
230     PassRefPtr<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
231     PassRefPtr<HTMLCollection> applets();
232     PassRefPtr<HTMLCollection> links();
233     PassRefPtr<HTMLCollection> forms();
234     PassRefPtr<HTMLCollection> anchors();
235     PassRefPtr<HTMLCollection> all();
236     PassRefPtr<HTMLCollection> objects();
237     PassRefPtr<HTMLCollection> scripts();
238     PassRefPtr<HTMLCollection> windowNamedItems(const String& name);
239     PassRefPtr<HTMLCollection> documentNamedItems(const String& name);
240
241     HTMLCollection::CollectionInfo* collectionInfo(HTMLCollection::Type type)
242     {
243         ASSERT(type >= HTMLCollection::FirstUnnamedDocumentCachedType);
244         unsigned index = type - HTMLCollection::FirstUnnamedDocumentCachedType;
245         ASSERT(index < HTMLCollection::NumUnnamedDocumentCachedTypes);
246         return &m_collectionInfo[index]; 
247     }
248
249     HTMLCollection::CollectionInfo* nameCollectionInfo(HTMLCollection::Type, const AtomicString& name);
250
251     // DOM methods overridden from  parent classes
252
253     virtual String nodeName() const;
254     virtual NodeType nodeType() const;
255
256     // Other methods (not part of DOM)
257     virtual bool isDocumentNode() const { return true; }
258     virtual bool isHTMLDocument() const { return false; }
259     virtual bool isImageDocument() const { return false; }
260 #if ENABLE(SVG)
261     virtual bool isSVGDocument() const { return false; }
262 #endif
263     virtual bool isPluginDocument() const { return false; }
264     
265     CSSStyleSelector* styleSelector() const { return m_styleSelector; }
266
267     Element* getElementByAccessKey(const String& key) const;
268     
269     /**
270      * Updates the pending sheet count and then calls updateStyleSelector.
271      */
272     void removePendingSheet();
273
274     /**
275      * This method returns true if all top-level stylesheets have loaded (including
276      * any @imports that they may be loading).
277      */
278     bool haveStylesheetsLoaded() const
279     {
280         return m_pendingStylesheets <= 0 || m_ignorePendingStylesheets
281 #if USE(LOW_BANDWIDTH_DISPLAY)
282             || m_inLowBandwidthDisplay
283 #endif
284             ;
285     }
286
287     /**
288      * Increments the number of pending sheets.  The <link> elements
289      * invoke this to add themselves to the loading list.
290      */
291     void addPendingSheet() { m_pendingStylesheets++; }
292
293     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
294     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
295
296     /**
297      * Called when one or more stylesheets in the document may have been added, removed or changed.
298      *
299      * Creates a new style selector and assign it to this document. This is done by iterating through all nodes in
300      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
301      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
302      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
303      * found and is used to calculate the derived styles for all rendering objects.
304      */
305     void updateStyleSelector();
306
307     void recalcStyleSelector();
308
309     bool usesDescendantRules() const { return m_usesDescendantRules; }
310     void setUsesDescendantRules(bool b) { m_usesDescendantRules = b; }
311     bool usesSiblingRules() const { return m_usesSiblingRules; }
312     void setUsesSiblingRules(bool b) { m_usesSiblingRules = b; }
313     bool usesFirstLineRules() const { return m_usesFirstLineRules; }
314     void setUsesFirstLineRules(bool b) { m_usesFirstLineRules = b; }
315     bool usesFirstLetterRules() const { return m_usesFirstLetterRules; }
316     void setUsesFirstLetterRules(bool b) { m_usesFirstLetterRules = b; }
317
318     // Machinery for saving and restoring state when you leave and then go back to a page.
319     void registerFormElementWithState(HTMLFormControlElementWithState* e) { m_formElementsWithState.add(e); }
320     void unregisterFormElementWithState(HTMLFormControlElementWithState* e) { m_formElementsWithState.remove(e); }
321     Vector<String> formElementsState() const;
322     void setStateForNewFormElements(const Vector<String>&);
323     bool hasStateForNewFormElements() const;
324     bool takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state);
325
326     FrameView* view() const; // can be NULL
327     Frame* frame() const { return m_frame; } // can be NULL
328     Page* page() const; // can be NULL
329     Settings* settings() const; // can be NULL
330
331     PassRefPtr<Range> createRange();
332
333     PassRefPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow,
334         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
335
336     PassRefPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow, 
337         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
338
339     // Special support for editing
340     PassRefPtr<CSSStyleDeclaration> createCSSStyleDeclaration();
341     PassRefPtr<EditingText> createEditingTextNode(const String&);
342
343     virtual void recalcStyle( StyleChange = NoChange );
344     static DeprecatedPtrList<Document>* changedDocuments;
345     virtual void updateRendering();
346     void updateLayout();
347     void updateLayoutIgnorePendingStylesheets();
348     static void updateDocumentsRendering();
349     DocLoader* docLoader() { return m_docLoader; }
350
351     virtual void attach();
352     virtual void detach();
353
354     RenderArena* renderArena() { return m_renderArena; }
355
356     AXObjectCache* axObjectCache() const;
357     
358     // to get visually ordered hebrew and arabic pages right
359     void setVisuallyOrdered();
360
361     void open();
362     void implicitOpen();
363     void close();
364     void implicitClose();
365     void cancelParsing();
366
367     void write(const String& text);
368     void writeln(const String& text);
369     void finishParsing();
370     void clear();
371
372     bool wellFormed() const { return m_wellFormed; }
373
374     DeprecatedString url() const { return m_url.isEmpty() ? "about:blank" : m_url; }
375     void setURL(const DeprecatedString& url);
376
377     DeprecatedString baseURL() const { return m_baseURL.isEmpty() ? url() : m_baseURL; }
378     void setBaseURL(const DeprecatedString& baseURL);
379
380     String baseTarget() const { return m_baseTarget; }
381     void setBaseTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
382
383     DeprecatedString completeURL(const DeprecatedString &);
384     String completeURL(const String&);
385
386     // from cachedObjectClient
387     virtual void setCSSStyleSheet(const String& url, const String& charset, const CachedCSSStyleSheet*);
388
389 #if FRAME_LOADS_USER_STYLESHEET
390     void setUserStyleSheet(const String& sheet);
391 #endif
392
393     String userStyleSheet() const;
394
395     CSSStyleSheet* elementSheet();
396     CSSStyleSheet* mappedElementSheet();
397     virtual Tokenizer* createTokenizer();
398     Tokenizer* tokenizer() { return m_tokenizer; }
399     
400     bool printing() const { return m_printing; }
401     void setPrinting(bool p) { m_printing = p; }
402
403     enum ParseMode { Compat, AlmostStrict, Strict };
404     
405     virtual void determineParseMode(const String&);
406     void setParseMode(ParseMode m) { pMode = m; }
407     ParseMode parseMode() const { return pMode; }
408
409     bool inCompatMode() const { return pMode == Compat; }
410     bool inAlmostStrictMode() const { return pMode == AlmostStrict; }
411     bool inStrictMode() const { return pMode == Strict; }
412     
413     enum HTMLMode { Html3, Html4, XHtml };
414
415     void setHTMLMode(HTMLMode m) { hMode = m; }
416     HTMLMode htmlMode() const { return hMode; }
417
418     void setParsing(bool);
419     bool parsing() const { return m_bParsing; }
420     int minimumLayoutDelay();
421     bool shouldScheduleLayout();
422     int elapsedTime() const;
423     
424     void setTextColor(const Color& color) { m_textColor = color; }
425     Color textColor() const { return m_textColor; }
426
427     const Color& linkColor() const { return m_linkColor; }
428     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
429     const Color& activeLinkColor() const { return m_activeLinkColor; }
430     void setLinkColor(const Color& c) { m_linkColor = c; }
431     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
432     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
433     void resetLinkColor();
434     void resetVisitedLinkColor();
435     void resetActiveLinkColor();
436     
437     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const IntPoint&, const PlatformMouseEvent&);
438
439     virtual bool childTypeAllowed(NodeType);
440     virtual PassRefPtr<Node> cloneNode(bool deep);
441
442     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
443     
444     StyleSheetList* styleSheets();
445
446     /* Newly proposed CSS3 mechanism for selecting alternate
447        stylesheets using the DOM. May be subject to change as
448        spec matures. - dwh
449     */
450     String preferredStylesheetSet() const;
451     String selectedStylesheetSet() const;
452     void setSelectedStylesheetSet(const String&);
453
454     bool setFocusedNode(PassRefPtr<Node>);
455     Node* focusedNode() const { return m_focusedNode.get(); }
456
457     void setHoverNode(PassRefPtr<Node>);
458     Node* hoverNode() const { return m_hoverNode.get(); }
459
460     void setActiveNode(PassRefPtr<Node>);
461     Node* activeNode() const { return m_activeNode.get(); }
462
463     void focusedNodeRemoved();
464     void removeFocusedNodeOfSubtree(Node*, bool amongChildrenOnly = false);
465     void hoveredNodeDetached(Node*);
466     void activeChainNodeDetached(Node*);
467
468     // Updates for :target (CSS3 selector).
469     void setCSSTarget(Node*);
470     Node* getCSSTarget() const;
471     
472     void setDocumentChanged(bool);
473
474     void attachNodeIterator(NodeIterator*);
475     void detachNodeIterator(NodeIterator*);
476     void notifyBeforeNodeRemoval(Node*);
477     DOMWindow* defaultView() const;
478     PassRefPtr<Event> createEvent(const String& eventType, ExceptionCode&);
479
480     // keep track of what types of event listeners are registered, so we don't
481     // dispatch events unnecessarily
482     enum ListenerType {
483         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
484         DOMNODEINSERTED_LISTENER             = 0x02,
485         DOMNODEREMOVED_LISTENER              = 0x04,
486         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
487         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
488         DOMATTRMODIFIED_LISTENER             = 0x20,
489         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40,
490         OVERFLOWCHANGED_LISTENER             = 0x80
491     };
492
493     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
494     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
495
496     CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
497
498     void handleWindowEvent(Event*, bool useCapture);
499     void setHTMLWindowEventListener(const AtomicString &eventType, PassRefPtr<EventListener>);
500     EventListener* getHTMLWindowEventListener(const AtomicString &eventType);
501     void removeHTMLWindowEventListener(const AtomicString &eventType);
502
503     void setHTMLWindowEventListener(const AtomicString& eventType, Attribute*);
504
505     void addWindowEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
506     void removeWindowEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
507     bool hasWindowEventListener(const AtomicString& eventType);
508
509     PassRefPtr<EventListener> createHTMLEventListener(const String& functionName, const String& code, Node*);
510     
511     /**
512      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
513      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
514      * first (from lowest to highest), and then elements without tab indexes (in document order).
515      *
516      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
517      *
518      * @return The focus node that comes after fromNode
519      *
520      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
521      */
522     Node* nextFocusableNode(Node* start, KeyboardEvent*);
523
524     /**
525      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
526      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
527      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
528      *
529      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
530      *
531      * @return The focus node that comes before fromNode
532      *
533      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
534      */
535     Node* previousFocusableNode(Node* start, KeyboardEvent*);
536
537     int nodeAbsIndex(Node*);
538     Node* nodeWithAbsIndex(int absIndex);
539
540     /**
541      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
542      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
543      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
544      * specified in a HTML file.
545      *
546      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
547      * @param content The header value (value of the meta tag's "content" attribute)
548      */
549     void processHttpEquiv(const String& equiv, const String& content);
550     
551     void dispatchImageLoadEventSoon(HTMLImageLoader*);
552     void dispatchImageLoadEventsNow();
553     void removeImage(HTMLImageLoader*);
554     
555     // Returns the owning element in the parent document.
556     // Returns 0 if this is the top level document.
557     Element* ownerElement() const;
558
559     String title() const { return m_title; }
560     void setTitle(const String&, Element* titleElement = 0);
561     void removeTitle(Element* titleElement);
562
563     String cookie() const;
564     void setCookie(const String&);
565
566     String referrer() const;
567
568     String domain() const;
569     void setDomain(const String& newDomain);
570
571     String lastModified() const;
572
573     String policyBaseURL() const { return m_policyBaseURL; }
574     void setPolicyBaseURL(const String& s) { m_policyBaseURL = s; }
575     
576     // The following implements the rule from HTML 4 for what valid names are.
577     // To get this right for all the XML cases, we probably have to improve this or move it
578     // and make it sensitive to the type of document.
579     static bool isValidName(const String&);
580
581     // The following breaks a qualified name into a prefix and a local name.
582     // It also does a validity check, and returns false if the qualified name is invalid
583     // (empty string or invalid characters).
584     static bool parseQualifiedName(const String& qualifiedName, String& prefix, String& localName);
585     
586     void addElementById(const AtomicString& elementId, Element *element);
587     void removeElementById(const AtomicString& elementId, Element *element);
588
589     void addImageMap(HTMLMapElement*);
590     void removeImageMap(HTMLMapElement*);
591     HTMLMapElement* getImageMap(const String& url) const;
592
593     HTMLElement* body();
594     void setBody(PassRefPtr<HTMLElement>, ExceptionCode&);
595
596     HTMLHeadElement* head();
597
598     String toString() const;
599     
600     bool execCommand(const String& command, bool userInterface = false, const String& value = String());
601     bool queryCommandEnabled(const String& command);
602     bool queryCommandIndeterm(const String& command);
603     bool queryCommandState(const String& command);
604     bool queryCommandSupported(const String& command);
605     String queryCommandValue(const String& command);
606     
607     void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
608     void addMarker(Node*, DocumentMarker);
609     void copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
610     void removeMarkers(Range*, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
611     void removeMarkers(Node*, unsigned startOffset, int length, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
612     void removeMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
613     void removeMarkers(Node*);
614     void repaintMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
615     void setRenderedRectForMarker(Node*, DocumentMarker, const IntRect&);
616     void invalidateRenderedRectsForMarkersInRect(const IntRect&);
617     void shiftMarkers(Node*, unsigned startOffset, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
618
619     DocumentMarker* markerContainingPoint(const IntPoint&, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
620     Vector<DocumentMarker> markersForNode(Node*);
621     Vector<IntRect> renderedRectsForMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
622     
623     // designMode support
624     enum InheritedBool { off = false, on = true, inherit };    
625     void setDesignMode(InheritedBool value);
626     InheritedBool getDesignMode() const;
627     bool inDesignMode() const;
628
629     Document* parentDocument() const;
630     Document* topDocument() const;
631
632     int docID() const { return m_docID; }
633
634 #if ENABLE(XSLT)
635     void applyXSLTransform(ProcessingInstruction* pi);
636     void setTransformSource(void* doc);
637     const void* transformSource() { return m_transformSource; }
638     PassRefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
639     void setTransformSourceDocument(Document* doc) { m_transformSourceDocument = doc; }
640 #endif
641
642 #if ENABLE(XBL)
643     // XBL methods
644     XBLBindingManager* bindingManager() const { return m_bindingManager; }
645 #endif
646
647     void incDOMTreeVersion() { ++m_domtree_version; }
648     unsigned domTreeVersion() const { return m_domtree_version; }
649
650     void setDocType(PassRefPtr<DocumentType>);
651
652     void finishedParsing();
653
654 #if ENABLE(XPATH)
655     // XPathEvaluator methods
656     PassRefPtr<XPathExpression> createExpression(const String& expression,
657                                                  XPathNSResolver* resolver,
658                                                  ExceptionCode& ec);
659     PassRefPtr<XPathNSResolver> createNSResolver(Node *nodeResolver);
660     PassRefPtr<XPathResult> evaluate(const String& expression,
661                                      Node* contextNode,
662                                      XPathNSResolver* resolver,
663                                      unsigned short type,
664                                      XPathResult* result,
665                                      ExceptionCode& ec);
666 #endif // ENABLE(XPATH)
667     
668     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
669
670     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
671     
672     void setHasNodesWithPlaceholderStyle() { m_hasNodesWithPlaceholderStyle = true; }
673
674     String iconURL();
675     void setIconURL(const String& iconURL, const String& type);
676
677     bool isAllowedToLoadLocalResources() const { return m_isAllowedToLoadLocalResources; }
678
679     void setUseSecureKeyboardEntryWhenActive(bool);
680     bool useSecureKeyboardEntryWhenActive() const;
681     
682 #if USE(LOW_BANDWIDTH_DISPLAY)
683     void setDocLoader(DocLoader* loader) { m_docLoader = loader; }
684     bool inLowBandwidthDisplay() const { return m_inLowBandwidthDisplay; }
685     void setLowBandwidthDisplay(bool lowBandWidth) { m_inLowBandwidthDisplay = lowBandWidth; }
686 #endif
687     
688     void addNodeList() { m_numNodeLists++; }
689     void removeNodeList() { m_numNodeLists--; }
690     bool hasNodeLists() const { return m_numNodeLists != 0; }
691
692     void updateFocusAppearanceSoon();
693     void cancelFocusAppearanceUpdate();
694     
695 private:
696     CSSStyleSelector* m_styleSelector;
697     bool m_didCalculateStyleSelector;
698
699     Frame* m_frame;
700     DocLoader* m_docLoader;
701     Tokenizer* m_tokenizer;
702     bool m_wellFormed;
703     DeprecatedString m_url;
704     DeprecatedString m_baseURL;
705     String m_baseTarget;
706
707     RefPtr<DocumentType> m_docType;
708     RefPtr<DOMImplementation> m_implementation;
709
710     RefPtr<StyleSheet> m_sheet;
711 #if FRAME_LOADS_USER_STYLESHEET
712     String m_usersheet;
713 #endif
714
715     // Track the number of currently loading top-level stylesheets.  Sheets
716     // loaded using the @import directive are not included in this count.
717     // We use this count of pending sheets to detect when we can begin attaching
718     // elements.
719     int m_pendingStylesheets;
720
721     // But sometimes you need to ignore pending stylesheet count to
722     // force an immediate layout when requested by JS.
723     bool m_ignorePendingStylesheets;
724
725     // If we do ignore the pending stylesheet count, then we need to add a boolean
726     // to track that this happened so that we can do a full repaint when the stylesheets
727     // do eventually load.
728     PendingSheetLayout m_pendingSheetLayout;
729     
730     bool m_hasNodesWithPlaceholderStyle;
731
732     RefPtr<CSSStyleSheet> m_elemSheet;
733     RefPtr<CSSStyleSheet> m_mappedElementSheet;
734
735     bool m_printing;
736
737     ParseMode pMode;
738     HTMLMode hMode;
739
740     Color m_textColor;
741
742     RefPtr<Node> m_focusedNode;
743     RefPtr<Node> m_hoverNode;
744     RefPtr<Node> m_activeNode;
745     mutable RefPtr<Element> m_documentElement;
746
747     unsigned m_domtree_version;
748     
749     HashSet<NodeIterator*> m_nodeIterators;
750
751     unsigned short m_listenerTypes;
752     RefPtr<StyleSheetList> m_styleSheets;
753     
754     typedef DeprecatedValueList<RefPtr<RegisteredEventListener> > RegisteredEventListenerList;
755     RegisteredEventListenerList m_windowEventListeners;
756
757     typedef HashMap<FormElementKey, Vector<String>, FormElementKeyHash, FormElementKeyHashTraits> FormElementStateMap;
758     ListHashSet<HTMLFormControlElementWithState*> m_formElementsWithState;
759     FormElementStateMap m_stateForNewFormElements;
760     
761     Color m_linkColor;
762     Color m_visitedLinkColor;
763     Color m_activeLinkColor;
764
765     String m_preferredStylesheetSet;
766     String m_selectedStylesheetSet;
767
768     bool m_loadingSheet;
769     bool visuallyOrdered;
770     bool m_bParsing;
771     bool m_docChanged;
772     bool m_inStyleRecalc;
773     bool m_closeAfterStyleRecalc;
774     bool m_usesDescendantRules;
775     bool m_usesSiblingRules;
776     bool m_usesFirstLineRules;
777     bool m_usesFirstLetterRules;
778     bool m_gotoAnchorNeededAfterStylesheetsLoad;
779
780     String m_title;
781     bool m_titleSetExplicitly;
782     RefPtr<Element> m_titleElement;
783     
784     RenderArena* m_renderArena;
785
786     typedef std::pair<Vector<DocumentMarker>, Vector<IntRect> > MarkerMapVectorPair;
787     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
788     MarkerMap m_markers;
789
790     mutable AXObjectCache* m_axObjectCache;
791     
792     DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
793     DeprecatedPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
794     Timer<Document> m_imageLoadEventTimer;
795
796     Timer<Document> m_updateFocusAppearanceTimer;
797
798     Node* m_cssTarget;
799     
800     bool m_processingLoadEvent;
801     double m_startTime;
802     bool m_overMinimumLayoutThreshold;
803     
804 #if ENABLE(XSLT)
805     void* m_transformSource;
806     RefPtr<Document> m_transformSourceDocument;
807 #endif
808
809 #if ENABLE(XBL)
810     XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
811 #endif
812     
813     typedef HashMap<AtomicStringImpl*, HTMLMapElement*> ImageMapsByName;
814     ImageMapsByName m_imageMapsByName;
815
816     String m_policyBaseURL;
817
818     HashSet<Node*> m_disconnectedNodesWithEventListeners;
819
820     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
821
822     String m_xmlEncoding;
823     String m_xmlVersion;
824     bool m_xmlStandalone;
825
826     String m_contentLanguage;
827
828 public:
829     bool inPageCache();
830     void setInPageCache(bool flag);
831     
832     // Elements can register themselves for the "willSaveToCache()" and  
833     // "didRestoreFromCache()" callbacks
834     void registerForCacheCallbacks(Element*);
835     void unregisterForCacheCallbacks(Element*);
836     void willSaveToCache();
837     void didRestoreFromCache();
838
839     void setShouldCreateRenderers(bool);
840     bool shouldCreateRenderers();
841     
842     void setDecoder(TextResourceDecoder*);
843     TextResourceDecoder* decoder() const { return m_decoder.get(); }
844
845     UChar backslashAsCurrencySymbol() const;
846
847     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
848     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
849     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
850     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
851     const Vector<DashboardRegionValue>& dashboardRegions() const;
852     void setDashboardRegions(const Vector<DashboardRegionValue>&);
853
854     void removeAllEventListenersFromAllNodes();
855
856     void registerDisconnectedNodeWithEventListeners(Node*);
857     void unregisterDisconnectedNodeWithEventListeners(Node*);
858     
859     HTMLFormElement::CheckedRadioButtons& checkedRadioButtons() { return m_checkedRadioButtons; }
860     
861 #if ENABLE(SVG)
862     const SVGDocumentExtensions* svgExtensions();
863     SVGDocumentExtensions* accessSVGExtensions();
864 #endif
865
866     void initSecurityOrigin();
867     SecurityOrigin* securityOrigin() const { return m_securityOrigin.get(); }
868
869     // Explicitly override the security origin for this document.
870     // Note: It is dangerous to change the security origin of a document
871     //       that already contains content.
872     void setSecurityOrigin(SecurityOrigin*);
873
874     bool processingLoadEvent() const { return m_processingLoadEvent; }
875
876 #if ENABLE(DATABASE)
877     DatabaseThread* databaseThread();
878     void setHasOpenDatabases() { m_hasOpenDatabases = true; }
879     bool hasOpenDatabases() { return m_hasOpenDatabases; }
880 #endif
881 protected:
882     void clearXMLVersion() { m_xmlVersion = String(); }
883
884 private:
885     bool shouldBeAllowedToLoadLocalResources() const;
886
887     void updateTitle();
888     void removeAllDisconnectedNodeEventListeners();
889     void imageLoadEventTimerFired(Timer<Document>*);
890     void updateFocusAppearanceTimerFired(Timer<Document>*);
891
892     RefPtr<SecurityOrigin> m_securityOrigin;
893
894     RenderObject* m_savedRenderer;
895     int m_secureForms;
896     
897     RefPtr<TextResourceDecoder> m_decoder;
898
899     // We maintain the invariant that m_duplicateIds is the count of all elements with a given ID
900     // excluding the one referenced in m_elementsById, if any. This means it one less than the total count
901     // when the first node with a given ID is cached, otherwise the same as the total count.
902     mutable HashMap<AtomicStringImpl*, Element*> m_elementsById;
903     mutable HashCountedSet<AtomicStringImpl*> m_duplicateIds;
904     
905     mutable HashMap<StringImpl*, Element*, CaseFoldingHash> m_elementsByAccessKey;
906     
907     InheritedBool m_designMode;
908     
909     int m_selfOnlyRefCount;
910
911     HTMLFormElement::CheckedRadioButtons m_checkedRadioButtons;
912
913     typedef HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo*> NamedCollectionMap;
914     HTMLCollection::CollectionInfo m_collectionInfo[HTMLCollection::NumUnnamedDocumentCachedTypes];
915     NamedCollectionMap m_nameCollectionInfo[HTMLCollection::NumNamedDocumentCachedTypes];
916
917 #if ENABLE(XPATH)
918     RefPtr<XPathEvaluator> m_xpathEvaluator;
919 #endif
920     
921 #if ENABLE(SVG)
922     SVGDocumentExtensions* m_svgExtensions;
923 #endif
924     
925     Vector<DashboardRegionValue> m_dashboardRegions;
926     bool m_hasDashboardRegions;
927     bool m_dashboardRegionsDirty;
928
929     mutable bool m_accessKeyMapValid;
930     bool m_createRenderers;
931     bool m_inPageCache;
932     String m_iconURL;
933     
934     HashSet<Element*> m_pageCacheCallbackElements;
935
936     bool m_isAllowedToLoadLocalResources;
937
938     bool m_useSecureKeyboardEntryWhenActive;
939
940     bool m_isXHTML;
941
942     unsigned m_numNodeLists;
943
944 #if ENABLE(DATABASE)
945     RefPtr<DatabaseThread> m_databaseThread;
946     bool m_hasOpenDatabases;
947 #endif
948 #if USE(LOW_BANDWIDTH_DISPLAY)
949     bool m_inLowBandwidthDisplay;
950 #endif
951 };
952
953 } // namespace WebCore
954
955 #endif // Document_h