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