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