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