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