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