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