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