Reviewed by Vicki.
[WebKit-https.git] / WebCore / khtml / xml / dom_docimpl.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 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 #ifndef _DOM_DocumentImpl_h_
26 #define _DOM_DocumentImpl_h_
27
28 #include "xml/dom_elementimpl.h"
29 #include "xml/dom2_traversalimpl.h"
30 #include "misc/shared.h"
31
32 #include <qstringlist.h>
33 #include <qptrlist.h>
34 #include <qobject.h>
35 #include <qdict.h>
36 #include <qptrdict.h>
37 #include <qmap.h>
38 #include <qdatetime.h>
39
40 #include <kurl.h>
41
42 #if APPLE_CHANGES
43 #include "KWQSignal.h"
44 #include "decoder.h"
45 #endif
46
47 class QPaintDevice;
48 class QPaintDeviceMetrics;
49 class KHTMLView;
50 class KHTMLPart;
51 class RenderArena;
52
53 #if APPLE_CHANGES
54 class KWQAccObjectCache;
55 #endif
56
57 namespace khtml {
58     class CSSStyleSelector;
59     class DocLoader;
60     class RenderImage;
61     class Tokenizer;
62     class XMLHandler;
63 #if APPLE_CHANGES    
64     struct DashboardRegionValue;
65 #endif
66 }
67
68 #ifndef KHTML_NO_XBL
69 namespace XBL {
70     class XBLBindingManager;
71 }
72 #endif
73
74 namespace DOM {
75     class AbstractViewImpl;
76     class AttrImpl;
77     class CDATASectionImpl;
78     class CSSStyleSheetImpl;
79     class CSSMappedAttributeDeclarationImpl;
80     class CommentImpl;
81     class DocumentFragmentImpl;
82     class DocumentImpl;
83     class DocumentType;
84     class DocumentTypeImpl;
85 #if APPLE_CHANGES
86     class DOMImplementation;
87 #endif
88     class EditingTextImpl;
89     class ElementImpl;
90     class EntityReferenceImpl;
91     class EventImpl;
92     class EventListener;
93     class GenericRONamedNodeMapImpl;
94     class HTMLDocumentImpl;
95     class HTMLElementImpl;
96     class HTMLImageLoader;
97     class HTMLMapElementImpl;
98     class JSEditor;
99     class NodeFilter;
100     class NodeFilterImpl;
101     class NodeIteratorImpl;
102     class NodeListImpl;
103     class ProcessingInstructionImpl;
104     class Range;
105     class RangeImpl;
106     class RegisteredEventListener;
107     class StyleSheetImpl;
108     class StyleSheetListImpl;
109     class TextImpl;
110     class TreeWalkerImpl;
111 #ifdef KHTML_XSLT
112     class XSLStyleSheetImpl;
113 #endif
114
115     // A range of a node within a document that is "marked", such as being misspelled
116     struct DocumentMarker
117     {
118         enum MarkerType {
119             Spelling
120             // Not doing grammar yet, but this is a placeholder for it
121             // Grammar
122         };
123         
124         enum MarkerType type;
125         ulong startOffset, endOffset;
126         
127         bool operator == (const DocumentMarker &o) const {
128             return type == o.type && startOffset == o.startOffset && endOffset == o.endOffset;
129         }
130         bool operator != (const DocumentMarker &o) const {
131             return !(*this == o);
132         }
133     };
134     
135 class DOMImplementationImpl : public khtml::Shared<DOMImplementationImpl>
136 {
137 public:
138     DOMImplementationImpl();
139     ~DOMImplementationImpl();
140
141     // DOM methods & attributes for DOMImplementation
142     bool hasFeature ( const DOMString &feature, const DOMString &version );
143     DocumentTypeImpl *createDocumentType( const DOMString &qualifiedName, const DOMString &publicId,
144                                           const DOMString &systemId, int &exceptioncode );
145     DocumentImpl *createDocument( const DOMString &namespaceURI, const DOMString &qualifiedName,
146                                   const DocumentType &doctype, int &exceptioncode );
147
148     DOMImplementationImpl* getInterface(const DOMString& feature) const;
149
150     // From the DOMImplementationCSS interface
151     CSSStyleSheetImpl *createCSSStyleSheet(DOMStringImpl *title, DOMStringImpl *media, int &exceptioncode);
152
153     // From the HTMLDOMImplementation interface
154     HTMLDocumentImpl* createHTMLDocument( const DOMString& title);
155
156     // Other methods (not part of DOM)
157     DocumentImpl *createDocument( KHTMLView *v = 0 );
158     HTMLDocumentImpl *createHTMLDocument( KHTMLView *v = 0 );
159
160     // Returns the static instance of this class - only one instance of this class should
161     // ever be present, and is used as a factory method for creating DocumentImpl objects
162     static DOMImplementationImpl *instance();
163
164 #if APPLE_CHANGES
165     static DOMImplementation createInstance (DOMImplementationImpl *impl);
166 #endif
167
168 protected:
169     static DOMImplementationImpl *m_instance;
170 };
171
172
173 /**
174  * @internal
175  */
176 class DocumentImpl : public QObject, public NodeBaseImpl
177 {
178     Q_OBJECT
179 public:
180     DocumentImpl(DOMImplementationImpl *_implementation, KHTMLView *v);
181     ~DocumentImpl();
182
183     // DOM methods & attributes for Document
184
185     DocumentTypeImpl *doctype() const;
186
187     DOMImplementationImpl *implementation() const;
188     virtual ElementImpl *documentElement() const;
189     virtual ElementImpl *createElement ( const DOMString &tagName, int &exceptioncode );
190     DocumentFragmentImpl *createDocumentFragment ();
191     TextImpl *createTextNode ( const DOMString &data );
192     CommentImpl *createComment ( const DOMString &data );
193     CDATASectionImpl *createCDATASection ( const DOMString &data );
194     ProcessingInstructionImpl *createProcessingInstruction ( const DOMString &target, const DOMString &data );
195     Attr createAttribute(NodeImpl::Id id);
196     EntityReferenceImpl *createEntityReference ( const DOMString &name );
197     NodeImpl *importNode( NodeImpl *importedNode, bool deep, int &exceptioncode );
198     virtual ElementImpl *createElementNS ( const DOMString &_namespaceURI, const DOMString &_qualifiedName, int &exceptioncode );
199     ElementImpl *getElementById ( const DOMString &elementId ) const;
200
201     // Actually part of HTMLDocument, but used for giving XML documents a window title as well
202     DOMString title() const { return m_title; }
203     void setTitle(DOMString _title);
204
205     // DOM methods overridden from  parent classes
206
207     virtual DOMString nodeName() const;
208     virtual unsigned short nodeType() const;
209
210     // Other methods (not part of DOM)
211     virtual bool isDocumentNode() const { return true; }
212     virtual bool isHTMLDocument() const { return false; }
213
214     ElementImpl *createHTMLElement(const DOMString &tagName, int &exceptioncode);
215     ElementImpl *createHTMLElement(unsigned short tagID);
216
217     khtml::CSSStyleSelector *styleSelector() { return m_styleSelector; }
218
219     ElementImpl *DocumentImpl::getElementByAccessKey( const DOMString &key );
220     
221     /**
222      * Updates the pending sheet count and then calls updateStyleSelector.
223      */
224     void stylesheetLoaded();
225
226     /**
227      * This method returns true if all top-level stylesheets have loaded (including
228      * any @imports that they may be loading).
229      */
230     bool haveStylesheetsLoaded() { return m_pendingStylesheets <= 0 || m_ignorePendingStylesheets; }
231
232     /**
233      * Increments the number of pending sheets.  The <link> elements
234      * invoke this to add themselves to the loading list.
235      */
236     void addPendingSheet() { m_pendingStylesheets++; }
237
238     /**
239      * Called when one or more stylesheets in the document may have been added, removed or changed.
240      *
241      * Creates a new style selector and assign it to this document. This is done by iterating through all nodes in
242      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
243      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
244      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
245      * found and is used to calculate the derived styles for all rendering objects.
246      */
247     void updateStyleSelector();
248
249     void recalcStyleSelector();
250
251     bool usesDescendantRules() { return m_usesDescendantRules; }
252     void setUsesDescendantRules(bool b) { m_usesDescendantRules = b; }
253     bool usesSiblingRules() { return m_usesSiblingRules; }
254     void setUsesSiblingRules(bool b) { m_usesSiblingRules = b; }\
255
256     QString nextState();
257
258     // Query all registered elements for their state
259     QStringList docState();
260     void registerMaintainsState(NodeImpl* e) { m_maintainsState.append(e); }
261     void deregisterMaintainsState(NodeImpl* e) { m_maintainsState.removeRef(e); }
262
263     // Set the state the document should restore to
264     void setRestoreState( const QStringList &s) { m_state = s; }
265     QStringList &restoreState( ) { return m_state; }
266
267     KHTMLView *view() const { return m_view; }
268     KHTMLPart *part() const;
269
270     RangeImpl *createRange();
271
272     NodeIteratorImpl *createNodeIterator(NodeImpl *root, unsigned long whatToShow,
273         NodeFilterImpl *filter, bool expandEntityReferences, int &exceptioncode);
274
275     TreeWalkerImpl *createTreeWalker(NodeImpl *root, unsigned long whatToShow, 
276         NodeFilterImpl *filter, bool expandEntityReferences, int &exceptioncode);
277
278     // Special support for editing
279     CSSStyleDeclarationImpl *createCSSStyleDeclaration();
280     EditingTextImpl *createEditingTextNode(const DOMString &text);
281
282     virtual void recalcStyle( StyleChange = NoChange );
283     static QPtrList<DocumentImpl> * changedDocuments;
284     virtual void updateRendering();
285     void updateLayout();
286     void updateLayoutIgnorePendingStylesheets();
287     static void updateDocumentsRendering();
288     khtml::DocLoader *docLoader() { return m_docLoader; }
289
290     virtual void attach();
291     virtual void detach();
292
293     RenderArena* renderArena() { return m_renderArena; }
294
295 #if APPLE_CHANGES
296     KWQAccObjectCache* getAccObjectCache();
297 #endif
298     
299     // to get visually ordered hebrew and arabic pages right
300     void setVisuallyOrdered();
301
302     void updateSelection();
303     
304     void open();
305     void implicitOpen();
306     void close();
307     void implicitClose();
308     void write ( const DOMString &text );
309     void write ( const QString &text );
310     void writeln ( const DOMString &text );
311     void finishParsing (  );
312     void clear();
313
314     QString URL() const { return m_url; }
315     void setURL(const QString& url);
316
317     QString baseURL() const { return m_baseURL.isEmpty() ? m_url : m_baseURL; }
318     void setBaseURL(const QString& baseURL) { m_baseURL = baseURL; }
319
320     QString baseTarget() const { return m_baseTarget; }
321     void setBaseTarget(const QString& baseTarget) { m_baseTarget = baseTarget; }
322
323 #if APPLE_CHANGES
324     QString completeURL(const QString &);
325 #else
326     QString completeURL(const QString& url) { return KURL(baseURL(),url).url(); };
327 #endif
328
329     // from cachedObjectClient
330     virtual void setStyleSheet(const DOMString &url, const DOMString &sheetStr);
331     void setUserStyleSheet(const QString& sheet);
332     QString userStyleSheet() const { return m_usersheet; }
333     void setPrintStyleSheet(const QString& sheet) { m_printSheet = sheet; }
334     QString printStyleSheet() const { return m_printSheet; }
335
336     CSSStyleSheetImpl* elementSheet();
337     virtual khtml::Tokenizer *createTokenizer();
338     khtml::Tokenizer *tokenizer() { return m_tokenizer; }
339     
340     QPaintDeviceMetrics *paintDeviceMetrics() { return m_paintDeviceMetrics; }
341     QPaintDevice *paintDevice() const { return m_paintDevice; }
342     void setPaintDevice( QPaintDevice *dev );
343
344     enum HTMLMode {
345         Html3,
346         Html4,
347         XHtml
348     };
349
350     enum ParseMode {
351         Compat,
352         AlmostStrict,
353         Strict
354     };
355     
356     virtual void determineParseMode( const QString &str );
357     void setParseMode( ParseMode m ) { pMode = m; }
358     ParseMode parseMode() const { return pMode; }
359
360     bool inCompatMode() { return pMode == Compat; }
361     bool inAlmostStrictMode() { return pMode == AlmostStrict; }
362     bool inStrictMode() { return pMode == Strict; }
363     
364     void setHTMLMode( HTMLMode m ) { hMode = m; }
365     HTMLMode htmlMode() const { return hMode; }
366
367     void setParsing(bool b);
368     bool parsing() const { return m_bParsing; }
369     int minimumLayoutDelay();
370     bool shouldScheduleLayout();
371     int elapsedTime() const;
372     
373     void setTextColor( QColor color ) { m_textColor = color; }
374     QColor textColor() const { return m_textColor; }
375
376     const QColor& linkColor() const { return m_linkColor; }
377     const QColor& visitedLinkColor() const { return m_visitedLinkColor; }
378     const QColor& activeLinkColor() const { return m_activeLinkColor; }
379     void setLinkColor(const QColor& c) { m_linkColor = c; }
380     void setVisitedLinkColor(const QColor& c) { m_visitedLinkColor = c; }
381     void setActiveLinkColor(const QColor& c) { m_activeLinkColor = c; }
382     void resetLinkColor();
383     void resetVisitedLinkColor();
384     void resetActiveLinkColor();
385     
386     // internal
387     NodeImpl *findElement( Id id );
388
389     bool prepareMouseEvent( bool readonly, int x, int y, MouseEvent *ev );
390
391     virtual bool childAllowed( NodeImpl *newChild );
392     virtual bool childTypeAllowed( unsigned short nodeType );
393     virtual NodeImpl *cloneNode ( bool deep );
394
395     // ### think about implementing ref'counting for the id's
396     // in order to be able to reassign those that are no longer in use
397     // (could make problems when it is still kept somewhere around, i.e. styleselector)
398     NodeImpl::Id tagId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly);
399     DOMString tagName(NodeImpl::Id _id) const;
400
401     NodeImpl::Id attrId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly);
402     DOMString attrName(NodeImpl::Id _id) const;
403
404     // the namespace uri is mapped to the same id for both
405     // tagnames as well as attributes.
406     DOMStringImpl* namespaceURI(NodeImpl::Id _id) const;
407
408     StyleSheetListImpl* styleSheets();
409
410     /* Newly proposed CSS3 mechanism for selecting alternate
411        stylesheets using the DOM. May be subject to change as
412        spec matures. - dwh
413     */
414     DOMString preferredStylesheetSet();
415     DOMString selectedStylesheetSet();
416     void setSelectedStylesheetSet(const DOMString& aString);
417
418     QStringList availableStyleSheets() const;
419
420     NodeImpl *focusNode() const { return m_focusNode; }
421     bool setFocusNode(NodeImpl *newFocusNode);
422
423     NodeImpl *hoverNode() const { return m_hoverNode; }
424     void setHoverNode(NodeImpl *newHoverNode);
425     
426     // Updates for :target (CSS3 selector).
427     void setCSSTarget(NodeImpl* n);
428     NodeImpl* getCSSTarget();
429     
430     void setDocumentChanged(bool);
431
432     void attachNodeIterator(NodeIteratorImpl *ni);
433     void detachNodeIterator(NodeIteratorImpl *ni);
434     void notifyBeforeNodeRemoval(NodeImpl *n);
435     AbstractViewImpl *defaultView() const;
436     EventImpl *createEvent(const DOMString &eventType, int &exceptioncode);
437
438     // keep track of what types of event listeners are registered, so we don't
439     // dispatch events unnecessarily
440     enum ListenerType {
441         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
442         DOMNODEINSERTED_LISTENER             = 0x02,
443         DOMNODEREMOVED_LISTENER              = 0x04,
444         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
445         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
446         DOMATTRMODIFIED_LISTENER             = 0x20,
447         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40
448     };
449
450     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
451     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
452
453     CSSStyleDeclarationImpl *getOverrideStyle(ElementImpl *elt, DOMStringImpl *pseudoElt);
454
455     typedef QMap<QString, ProcessingInstructionImpl*> LocalStyleRefs;
456     LocalStyleRefs* localStyleRefs() { return &m_localStyleRefs; }
457
458     virtual void defaultEventHandler(EventImpl *evt);
459     void setHTMLWindowEventListener(int id, EventListener *listener);
460     EventListener *getHTMLWindowEventListener(int id);
461     void removeHTMLWindowEventListener(int id);
462
463     void addWindowEventListener(int id, EventListener *listener, const bool useCapture);
464     void removeWindowEventListener(int id, EventListener *listener, bool useCapture);
465     bool hasWindowEventListener(int id);
466
467     EventListener *createHTMLEventListener(QString code, NodeImpl *node);
468     
469     /**
470      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
471      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
472      * first (from lowest to highest), and then elements without tab indexes (in document order).
473      *
474      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
475      *
476      * @return The focus node that comes after fromNode
477      *
478      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
479      */
480     NodeImpl *nextFocusNode(NodeImpl *fromNode);
481
482     /**
483      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
484      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
485      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
486      *
487      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
488      *
489      * @return The focus node that comes before fromNode
490      *
491      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
492      */
493     NodeImpl *previousFocusNode(NodeImpl *fromNode);
494
495     int nodeAbsIndex(NodeImpl *node);
496     NodeImpl *nodeWithAbsIndex(int absIndex);
497
498     /**
499      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
500      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
501      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
502      * specified in a HTML file.
503      *
504      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
505      * @param content The header value (value of the meta tag's "content" attribute)
506      */
507     void processHttpEquiv(const DOMString &equiv, const DOMString &content);
508     
509     void dispatchImageLoadEventSoon(HTMLImageLoader*);
510     void dispatchImageLoadEventsNow();
511     void removeImage(HTMLImageLoader*);
512     virtual void timerEvent(QTimerEvent *);
513     
514     // Returns the owning element in the parent document.
515     // Returns 0 if this is the top level document.
516     ElementImpl *ownerElement();
517
518     DOMString domain() const;
519     void setDomain( const DOMString &newDomain, bool force = false ); // not part of the DOM
520
521     DOMString policyBaseURL() const { return m_policyBaseURL; }
522     void setPolicyBaseURL(const DOMString &s) { m_policyBaseURL = s; }
523     
524     // The following implements the rule from HTML 4 for what valid names are.
525     // To get this right for all the XML cases, we probably have to improve this or move it
526     // and make it sensitive to the type of document.
527     static bool isValidName(const DOMString &);
528     
529     void addElementById(const DOMString &elementId, ElementImpl *element);
530     void removeElementById(const DOMString &elementId, ElementImpl *element);
531
532     void addImageMap(HTMLMapElementImpl *);
533     void removeImageMap(HTMLMapElementImpl *);
534     HTMLMapElementImpl *getImageMap(const DOMString &URL) const;
535
536     HTMLElementImpl* body();
537
538     DOMString toString() const;
539     
540     bool execCommand(const DOMString &command, bool userInterface, const DOMString &value);
541     bool queryCommandEnabled(const DOMString &command);
542     bool queryCommandIndeterm(const DOMString &command);
543     bool queryCommandState(const DOMString &command);
544     bool queryCommandSupported(const DOMString &command);
545     DOMString queryCommandValue(const DOMString &command);
546     
547     void addMarker(Range range, DocumentMarker::MarkerType type);
548     void removeMarker(Range range, DocumentMarker::MarkerType type);
549     void addMarker(NodeImpl *node, DocumentMarker marker);
550     void removeMarker(NodeImpl *node, DocumentMarker marker);
551     void removeAllMarkers(NodeImpl *node, ulong startOffset, long length);
552     void removeAllMarkers(NodeImpl *node);
553     void removeAllMarkers();
554     void shiftMarkers(NodeImpl *node, ulong startOffset, long delta);
555     QValueList<DocumentMarker> markersForNode(NodeImpl *node);
556     
557    /**
558     * designMode support
559     */
560     enum InheritedBool {
561         off=false,
562         on=true,
563         inherit
564     };
565     
566     void setDesignMode(InheritedBool value);
567     InheritedBool getDesignMode() const;
568     bool inDesignMode() const;
569     DocumentImpl *parentDocument() const;
570     DocumentImpl *topDocument() const;
571
572 #ifdef KHTML_XSLT
573     void applyXSLTransform(ProcessingInstructionImpl* pi);
574     void setTransformSource(void* doc) { m_transformSource = doc; }
575     const void* transformSource() { return m_transformSource; }
576     DocumentImpl* transformSourceDocument() { return m_transformSourceDocument; }
577     void setTransformSourceDocument(DocumentImpl* doc);
578 #endif
579
580 #ifndef KHTML_NO_XBL
581     // XBL methods
582     XBL::XBLBindingManager* bindingManager() const { return m_bindingManager; }
583 #endif
584
585     void incDOMTreeVersion() { ++m_domtree_version; }
586     unsigned int domTreeVersion() const { return m_domtree_version; }
587
588 signals:
589     void finishedParsing();
590
591 protected:
592     khtml::CSSStyleSelector *m_styleSelector;
593     KHTMLView *m_view;
594     QStringList m_state;
595
596     khtml::DocLoader *m_docLoader;
597     khtml::Tokenizer *m_tokenizer;
598     QString m_url;
599     QString m_baseURL;
600     QString m_baseTarget;
601
602     DocumentTypeImpl *m_doctype;
603     DOMImplementationImpl *m_implementation;
604
605     StyleSheetImpl *m_sheet;
606     QString m_usersheet;
607     QString m_printSheet;
608     QStringList m_availableSheets;
609
610     // Track the number of currently loading top-level stylesheets.  Sheets
611     // loaded using the @import directive are not included in this count.
612     // We use this count of pending sheets to detect when we can begin attaching
613     // elements.
614     int m_pendingStylesheets;
615
616     // But sometimes you need to ignore pending stylesheet count to
617     // force an immediate layout when requested by JS.
618     bool m_ignorePendingStylesheets;
619
620     CSSStyleSheetImpl *m_elemSheet;
621
622     QPaintDevice *m_paintDevice;
623     QPaintDeviceMetrics *m_paintDeviceMetrics;
624     ParseMode pMode;
625     HTMLMode hMode;
626
627     QColor m_textColor;
628
629     NodeImpl *m_focusNode;
630     NodeImpl *m_hoverNode;
631
632     unsigned int m_domtree_version;
633     
634     // ### replace me with something more efficient
635     // in lookup and insertion.
636     DOMStringImpl **m_elementNames;
637     unsigned short m_elementNameAlloc;
638     unsigned short m_elementNameCount;
639
640     DOMStringImpl **m_attrNames;
641     unsigned short m_attrNameAlloc;
642     unsigned short m_attrNameCount;
643
644     DOMStringImpl** m_namespaceURIs;
645     unsigned short m_namespaceURIAlloc;
646     unsigned short m_namespaceURICount;
647
648     QPtrList<NodeIteratorImpl> m_nodeIterators;
649     AbstractViewImpl *m_defaultView;
650
651     unsigned short m_listenerTypes;
652     StyleSheetListImpl* m_styleSheets;
653     LocalStyleRefs m_localStyleRefs; // references to inlined style elements
654     QPtrList<RegisteredEventListener> m_windowEventListeners;
655     QPtrList<NodeImpl> m_maintainsState;
656
657     QColor m_linkColor;
658     QColor m_visitedLinkColor;
659     QColor m_activeLinkColor;
660
661     DOMString m_preferredStylesheetSet;
662
663     bool m_loadingSheet;
664     bool visuallyOrdered;
665     bool m_bParsing;
666     bool m_bAllDataReceived;
667     bool m_docChanged;
668     bool m_styleSelectorDirty;
669     bool m_inStyleRecalc;
670     bool m_usesDescendantRules;
671     bool m_usesSiblingRules;
672
673     DOMString m_title;
674     
675     RenderArena* m_renderArena;
676
677     QPtrDict< QValueList<DocumentMarker> > m_markers;
678
679 #if APPLE_CHANGES
680     KWQAccObjectCache* m_accCache;
681 #endif
682     
683     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
684     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
685     int m_imageLoadEventTimer;
686
687     NodeImpl* m_cssTarget;
688     
689     bool m_processingLoadEvent;
690     QTime m_startTime;
691     bool m_overMinimumLayoutThreshold;
692     
693 #ifdef KHTML_XSLT
694     void* m_transformSource;
695     DocumentImpl* m_transformSourceDocument;
696 #endif
697
698 #ifndef KHTML_NO_XBL
699     XBL::XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
700 #endif
701     
702     QMap<QString, HTMLMapElementImpl *> m_imageMapsByName;
703
704     DOMString m_policyBaseURL;
705
706     QPtrDict<NodeImpl> m_disconnectedNodesWithEventListeners;
707
708 #if APPLE_CHANGES
709 public:
710     KWQSignal m_finishedParsing;
711
712     static Document createInstance (DocumentImpl *impl);
713
714     bool inPageCache();
715     void setInPageCache(bool flag);
716     void restoreRenderer(khtml::RenderObject* render);
717
718     void passwordFieldAdded();
719     void passwordFieldRemoved();
720     bool hasPasswordField() const;
721
722     void secureFormAdded();
723     void secureFormRemoved();
724     bool hasSecureForm() const;
725
726     void setShouldCreateRenderers(bool f);
727     bool shouldCreateRenderers();
728     
729     void setDecoder(khtml::Decoder *);
730     khtml::Decoder *decoder() const { return m_decoder; }
731
732     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
733     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
734     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
735     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
736     const QValueList<khtml::DashboardRegionValue> & dashboardRegions() const;
737     void setDashboardRegions (const QValueList<khtml::DashboardRegionValue>& regions);
738     
739     void removeAllEventListenersFromAllNodes();
740
741     void registerDisconnectedNodeWithEventListeners(NodeImpl *node);
742     void unregisterDisconnectedNodeWithEventListeners(NodeImpl *node);
743
744 private:
745     void removeAllDisconnectedNodeEventListeners();
746
747     JSEditor *jsEditor();
748
749     JSEditor *m_jsEditor;
750     bool relinquishesEditingFocus(NodeImpl *node);
751     bool acceptsEditingFocus(NodeImpl *node);
752
753     mutable DOMString m_domain;
754     bool m_inPageCache;
755     khtml::RenderObject *m_savedRenderer;
756     int m_passwordFields;
757     int m_secureForms;
758     
759     khtml::Decoder *m_decoder;
760
761     QDict<ElementImpl> m_elementsById;
762     
763     QDict<ElementImpl> m_elementsByAccessKey;
764     bool m_accessKeyDictValid;
765  
766     bool m_createRenderers;
767     
768     InheritedBool m_designMode;
769     
770     QValueList<khtml::DashboardRegionValue> m_dashboardRegions;
771     bool m_hasDashboardRegions;
772     bool m_dashboardRegionsDirty;
773 #endif
774 };
775
776 class DocumentFragmentImpl : public NodeBaseImpl
777 {
778 public:
779     DocumentFragmentImpl(DocumentPtr *doc);
780
781     // DOM methods overridden from  parent classes
782     virtual DOMString nodeName() const;
783     virtual unsigned short nodeType() const;
784     virtual NodeImpl *cloneNode ( bool deep );
785
786     // Other methods (not part of DOM)
787     virtual bool childTypeAllowed( unsigned short type );
788
789     virtual DOMString toString() const;
790 };
791
792
793 class DocumentTypeImpl : public NodeImpl
794 {
795 public:
796     DocumentTypeImpl(DOMImplementationImpl *_implementation, DocumentPtr *doc,
797                      const DOMString &qualifiedName, const DOMString &publicId,
798                      const DOMString &systemId);
799     ~DocumentTypeImpl();
800
801     // DOM methods & attributes for DocumentType
802     NamedNodeMapImpl *entities() const { return m_entities; }
803     NamedNodeMapImpl *notations() const { return m_notations; }
804
805     DOMString name() const { return m_qualifiedName; }
806     DOMString publicId() const { return m_publicId; }
807     DOMString systemId() const { return m_systemId; }
808     DOMString internalSubset() const { return m_subset; }
809
810     // DOM methods overridden from  parent classes
811     virtual DOMString nodeName() const;
812     virtual unsigned short nodeType() const;
813     virtual bool childTypeAllowed( unsigned short type );
814     virtual NodeImpl *cloneNode ( bool deep );
815
816     // Other methods (not part of DOM)
817     void setName(const DOMString& n) { m_qualifiedName = n; }
818     void setPublicId(const DOMString& publicId) { m_publicId = publicId; }
819     void setSystemId(const DOMString& systemId) { m_systemId = systemId; }
820     DOMImplementationImpl *implementation() const { return m_implementation; }
821     void copyFrom(const DocumentTypeImpl&);
822
823     virtual DOMString toString() const;
824
825 #if APPLE_CHANGES
826     static DocumentType createInstance (DocumentTypeImpl *impl);
827 #endif
828
829 protected:
830     DOMImplementationImpl *m_implementation;
831     NamedNodeMapImpl* m_entities;
832     NamedNodeMapImpl* m_notations;
833
834     DOMString m_qualifiedName;
835     DOMString m_publicId;
836     DOMString m_systemId;
837     DOMString m_subset;
838 };
839
840
841 }; //namespace
842 #endif