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