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