b4d159e3390e57849f58994805a8bb38474f0b74
[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 close();
306     void closeInternal ( bool checkTokenizer );
307     void write ( const DOMString &text );
308     void write ( const QString &text );
309     void writeln ( const DOMString &text );
310     void finishParsing (  );
311     void clear();
312
313     QString URL() const { return m_url; }
314     void setURL(const QString& url);
315
316     QString baseURL() const { return m_baseURL.isEmpty() ? m_url : m_baseURL; }
317     void setBaseURL(const QString& baseURL) { m_baseURL = baseURL; }
318
319     QString baseTarget() const { return m_baseTarget; }
320     void setBaseTarget(const QString& baseTarget) { m_baseTarget = baseTarget; }
321
322 #if APPLE_CHANGES
323     QString completeURL(const QString &);
324 #else
325     QString completeURL(const QString& url) { return KURL(baseURL(),url).url(); };
326 #endif
327
328     // from cachedObjectClient
329     virtual void setStyleSheet(const DOMString &url, const DOMString &sheetStr);
330     void setUserStyleSheet(const QString& sheet);
331     QString userStyleSheet() const { return m_usersheet; }
332     void setPrintStyleSheet(const QString& sheet) { m_printSheet = sheet; }
333     QString printStyleSheet() const { return m_printSheet; }
334
335     CSSStyleSheetImpl* elementSheet();
336     virtual khtml::Tokenizer *createTokenizer();
337     khtml::Tokenizer *tokenizer() { return m_tokenizer; }
338     
339     QPaintDeviceMetrics *paintDeviceMetrics() { return m_paintDeviceMetrics; }
340     QPaintDevice *paintDevice() const { return m_paintDevice; }
341     void setPaintDevice( QPaintDevice *dev );
342
343     enum HTMLMode {
344         Html3,
345         Html4,
346         XHtml
347     };
348
349     enum ParseMode {
350         Compat,
351         AlmostStrict,
352         Strict
353     };
354     
355     virtual void determineParseMode( const QString &str );
356     void setParseMode( ParseMode m ) { pMode = m; }
357     ParseMode parseMode() const { return pMode; }
358
359     bool inCompatMode() { return pMode == Compat; }
360     bool inAlmostStrictMode() { return pMode == AlmostStrict; }
361     bool inStrictMode() { return pMode == Strict; }
362     
363     void setHTMLMode( HTMLMode m ) { hMode = m; }
364     HTMLMode htmlMode() const { return hMode; }
365
366     void setParsing(bool b);
367     bool parsing() const { return m_bParsing; }
368     int minimumLayoutDelay();
369     bool shouldScheduleLayout();
370     int elapsedTime() const;
371     
372     void setTextColor( QColor color ) { m_textColor = color; }
373     QColor textColor() const { return m_textColor; }
374
375     const QColor& linkColor() const { return m_linkColor; }
376     const QColor& visitedLinkColor() const { return m_visitedLinkColor; }
377     const QColor& activeLinkColor() const { return m_activeLinkColor; }
378     void setLinkColor(const QColor& c) { m_linkColor = c; }
379     void setVisitedLinkColor(const QColor& c) { m_visitedLinkColor = c; }
380     void setActiveLinkColor(const QColor& c) { m_activeLinkColor = c; }
381     void resetLinkColor();
382     void resetVisitedLinkColor();
383     void resetActiveLinkColor();
384     
385     // internal
386     NodeImpl *findElement( Id id );
387
388     bool prepareMouseEvent( bool readonly, int x, int y, MouseEvent *ev );
389
390     virtual bool childAllowed( NodeImpl *newChild );
391     virtual bool childTypeAllowed( unsigned short nodeType );
392     virtual NodeImpl *cloneNode ( bool deep );
393
394     // ### think about implementing ref'counting for the id's
395     // in order to be able to reassign those that are no longer in use
396     // (could make problems when it is still kept somewhere around, i.e. styleselector)
397     NodeImpl::Id tagId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly);
398     DOMString tagName(NodeImpl::Id _id) const;
399
400     NodeImpl::Id attrId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly);
401     DOMString attrName(NodeImpl::Id _id) const;
402
403     // the namespace uri is mapped to the same id for both
404     // tagnames as well as attributes.
405     DOMStringImpl* namespaceURI(NodeImpl::Id _id) const;
406
407     StyleSheetListImpl* styleSheets();
408
409     /* Newly proposed CSS3 mechanism for selecting alternate
410        stylesheets using the DOM. May be subject to change as
411        spec matures. - dwh
412     */
413     DOMString preferredStylesheetSet();
414     DOMString selectedStylesheetSet();
415     void setSelectedStylesheetSet(const DOMString& aString);
416
417     QStringList availableStyleSheets() const;
418
419     NodeImpl *focusNode() const { return m_focusNode; }
420     bool setFocusNode(NodeImpl *newFocusNode);
421
422     NodeImpl *hoverNode() const { return m_hoverNode; }
423     void setHoverNode(NodeImpl *newHoverNode);
424     
425     // Updates for :target (CSS3 selector).
426     void setCSSTarget(NodeImpl* n);
427     NodeImpl* getCSSTarget();
428     
429     void setDocumentChanged(bool);
430
431     void attachNodeIterator(NodeIteratorImpl *ni);
432     void detachNodeIterator(NodeIteratorImpl *ni);
433     void notifyBeforeNodeRemoval(NodeImpl *n);
434     AbstractViewImpl *defaultView() const;
435     EventImpl *createEvent(const DOMString &eventType, int &exceptioncode);
436
437     // keep track of what types of event listeners are registered, so we don't
438     // dispatch events unnecessarily
439     enum ListenerType {
440         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
441         DOMNODEINSERTED_LISTENER             = 0x02,
442         DOMNODEREMOVED_LISTENER              = 0x04,
443         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
444         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
445         DOMATTRMODIFIED_LISTENER             = 0x20,
446         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40
447     };
448
449     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
450     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
451
452     CSSStyleDeclarationImpl *getOverrideStyle(ElementImpl *elt, DOMStringImpl *pseudoElt);
453
454     typedef QMap<QString, ProcessingInstructionImpl*> LocalStyleRefs;
455     LocalStyleRefs* localStyleRefs() { return &m_localStyleRefs; }
456
457     virtual void defaultEventHandler(EventImpl *evt);
458     void setHTMLWindowEventListener(int id, EventListener *listener);
459     EventListener *getHTMLWindowEventListener(int id);
460     void removeHTMLWindowEventListener(int id);
461
462     void addWindowEventListener(int id, EventListener *listener, const bool useCapture);
463     void removeWindowEventListener(int id, EventListener *listener, bool useCapture);
464     bool hasWindowEventListener(int id);
465
466     EventListener *createHTMLEventListener(QString code);
467     
468     /**
469      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
470      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
471      * first (from lowest to highest), and then elements without tab indexes (in document order).
472      *
473      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
474      *
475      * @return The focus node that comes after fromNode
476      *
477      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
478      */
479     NodeImpl *nextFocusNode(NodeImpl *fromNode);
480
481     /**
482      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
483      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
484      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
485      *
486      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
487      *
488      * @return The focus node that comes before fromNode
489      *
490      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
491      */
492     NodeImpl *previousFocusNode(NodeImpl *fromNode);
493
494     int nodeAbsIndex(NodeImpl *node);
495     NodeImpl *nodeWithAbsIndex(int absIndex);
496
497     /**
498      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
499      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
500      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
501      * specified in a HTML file.
502      *
503      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
504      * @param content The header value (value of the meta tag's "content" attribute)
505      */
506     void processHttpEquiv(const DOMString &equiv, const DOMString &content);
507     
508     void dispatchImageLoadEventSoon(HTMLImageLoader*);
509     void dispatchImageLoadEventsNow();
510     void removeImage(HTMLImageLoader*);
511     virtual void timerEvent(QTimerEvent *);
512     
513     // Returns the owning element in the parent document.
514     // Returns 0 if this is the top level document.
515     ElementImpl *ownerElement();
516
517     DOMString domain() const;
518     void setDomain( const DOMString &newDomain, bool force = false ); // not part of the DOM
519
520     DOMString policyBaseURL() const { return m_policyBaseURL; }
521     void setPolicyBaseURL(const DOMString &s) { m_policyBaseURL = s; }
522     
523     // The following implements the rule from HTML 4 for what valid names are.
524     // To get this right for all the XML cases, we probably have to improve this or move it
525     // and make it sensitive to the type of document.
526     static bool isValidName(const DOMString &);
527     
528     void addElementById(const DOMString &elementId, ElementImpl *element);
529     void removeElementById(const DOMString &elementId, ElementImpl *element);
530
531     void addImageMap(HTMLMapElementImpl *);
532     void removeImageMap(HTMLMapElementImpl *);
533     HTMLMapElementImpl *getImageMap(const DOMString &URL) const;
534
535     HTMLElementImpl* body();
536
537     DOMString toString() const;
538     
539     bool execCommand(const DOMString &command, bool userInterface, const DOMString &value);
540     bool queryCommandEnabled(const DOMString &command);
541     bool queryCommandIndeterm(const DOMString &command);
542     bool queryCommandState(const DOMString &command);
543     bool queryCommandSupported(const DOMString &command);
544     DOMString queryCommandValue(const DOMString &command);
545     
546     void addMarker(Range range, DocumentMarker::MarkerType type);
547     void removeMarker(Range range, DocumentMarker::MarkerType type);
548     void addMarker(NodeImpl *node, DocumentMarker marker);
549     void removeMarker(NodeImpl *node, DocumentMarker marker);
550     void removeAllMarkers(NodeImpl *node, ulong startOffset, long length);
551     void removeAllMarkers(NodeImpl *node);
552     void removeAllMarkers();
553     void shiftMarkers(NodeImpl *node, ulong startOffset, long delta);
554     QValueList<DocumentMarker> markersForNode(NodeImpl *node);
555     
556    /**
557     * designMode support
558     */
559     enum InheritedBool {
560         off=false,
561         on=true,
562         inherit
563     };
564     
565     void setDesignMode(InheritedBool value);
566     InheritedBool getDesignMode() const;
567     bool inDesignMode() const;
568     DocumentImpl *parentDocument() const;
569     DocumentImpl *topDocument() const;
570
571 #ifdef KHTML_XSLT
572     void applyXSLTransform(ProcessingInstructionImpl* pi);
573     void setTransformSource(void* doc) { m_transformSource = doc; }
574     const void* transformSource() { return m_transformSource; }
575     DocumentImpl* transformSourceDocument() { return m_transformSourceDocument; }
576     void setTransformSourceDocument(DocumentImpl* doc);
577 #endif
578
579 #ifndef KHTML_NO_XBL
580     // XBL methods
581     XBL::XBLBindingManager* bindingManager() const { return m_bindingManager; }
582 #endif
583
584     void incDOMTreeVersion() { ++m_domtree_version; }
585     unsigned int domTreeVersion() const { return m_domtree_version; }
586
587 signals:
588     void finishedParsing();
589
590 protected:
591     khtml::CSSStyleSelector *m_styleSelector;
592     KHTMLView *m_view;
593     QStringList m_state;
594
595     khtml::DocLoader *m_docLoader;
596     khtml::Tokenizer *m_tokenizer;
597     QString m_url;
598     QString m_baseURL;
599     QString m_baseTarget;
600
601     DocumentTypeImpl *m_doctype;
602     DOMImplementationImpl *m_implementation;
603
604     StyleSheetImpl *m_sheet;
605     QString m_usersheet;
606     QString m_printSheet;
607     QStringList m_availableSheets;
608
609     // Track the number of currently loading top-level stylesheets.  Sheets
610     // loaded using the @import directive are not included in this count.
611     // We use this count of pending sheets to detect when we can begin attaching
612     // elements.
613     int m_pendingStylesheets;
614
615     // But sometimes you need to ignore pending stylesheet count to
616     // force an immediate layout when requested by JS.
617     bool m_ignorePendingStylesheets;
618
619     CSSStyleSheetImpl *m_elemSheet;
620
621     QPaintDevice *m_paintDevice;
622     QPaintDeviceMetrics *m_paintDeviceMetrics;
623     ParseMode pMode;
624     HTMLMode hMode;
625
626     QColor m_textColor;
627
628     NodeImpl *m_focusNode;
629     NodeImpl *m_hoverNode;
630
631     unsigned int m_domtree_version;
632     
633     // ### replace me with something more efficient
634     // in lookup and insertion.
635     DOMStringImpl **m_elementNames;
636     unsigned short m_elementNameAlloc;
637     unsigned short m_elementNameCount;
638
639     DOMStringImpl **m_attrNames;
640     unsigned short m_attrNameAlloc;
641     unsigned short m_attrNameCount;
642
643     DOMStringImpl** m_namespaceURIs;
644     unsigned short m_namespaceURIAlloc;
645     unsigned short m_namespaceURICount;
646
647     QPtrList<NodeIteratorImpl> m_nodeIterators;
648     AbstractViewImpl *m_defaultView;
649
650     unsigned short m_listenerTypes;
651     StyleSheetListImpl* m_styleSheets;
652     LocalStyleRefs m_localStyleRefs; // references to inlined style elements
653     QPtrList<RegisteredEventListener> m_windowEventListeners;
654     QPtrList<NodeImpl> m_maintainsState;
655
656     QColor m_linkColor;
657     QColor m_visitedLinkColor;
658     QColor m_activeLinkColor;
659
660     DOMString m_preferredStylesheetSet;
661
662     bool m_loadingSheet;
663     bool visuallyOrdered;
664     bool m_bParsing;
665     bool m_bAllDataReceived;
666     bool m_docChanged;
667     bool m_styleSelectorDirty;
668     bool m_inStyleRecalc;
669     bool m_usesDescendantRules;
670     bool m_usesSiblingRules;
671
672     DOMString m_title;
673     
674     RenderArena* m_renderArena;
675
676     QPtrDict< QValueList<DocumentMarker> > m_markers;
677
678 #if APPLE_CHANGES
679     KWQAccObjectCache* m_accCache;
680 #endif
681     
682     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
683     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
684     int m_imageLoadEventTimer;
685
686     NodeImpl* m_cssTarget;
687     
688     bool m_processingLoadEvent;
689     QTime m_startTime;
690     bool m_overMinimumLayoutThreshold;
691     
692 #ifdef KHTML_XSLT
693     void* m_transformSource;
694     DocumentImpl* m_transformSourceDocument;
695 #endif
696
697 #ifndef KHTML_NO_XBL
698     XBL::XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
699 #endif
700     
701     QMap<QString, HTMLMapElementImpl *> m_imageMapsByName;
702
703     DOMString m_policyBaseURL;
704
705 #if APPLE_CHANGES
706 public:
707     KWQSignal m_finishedParsing;
708
709     static Document createInstance (DocumentImpl *impl);
710
711     bool inPageCache();
712     void setInPageCache(bool flag);
713     void restoreRenderer(khtml::RenderObject* render);
714
715     void passwordFieldAdded();
716     void passwordFieldRemoved();
717     bool hasPasswordField() const;
718
719     void secureFormAdded();
720     void secureFormRemoved();
721     bool hasSecureForm() const;
722
723     void setShouldCreateRenderers(bool f);
724     bool shouldCreateRenderers();
725     
726     void setDecoder(khtml::Decoder *);
727     khtml::Decoder *decoder() const { return m_decoder; }
728
729     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
730     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
731     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
732     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
733     const QValueList<khtml::DashboardRegionValue> & dashboardRegions() const;
734     void setDashboardRegions (const QValueList<khtml::DashboardRegionValue>& regions);
735     
736 private:
737     JSEditor *jsEditor();
738
739     JSEditor *m_jsEditor;
740     bool relinquishesEditingFocus(NodeImpl *node);
741     bool acceptsEditingFocus(NodeImpl *node);
742
743     mutable DOMString m_domain;
744     bool m_inPageCache;
745     khtml::RenderObject *m_savedRenderer;
746     int m_passwordFields;
747     int m_secureForms;
748     
749     khtml::Decoder *m_decoder;
750
751     QDict<ElementImpl> m_elementsById;
752     
753     QDict<ElementImpl> m_elementsByAccessKey;
754     bool m_accessKeyDictValid;
755  
756     bool m_createRenderers;
757     
758     InheritedBool m_designMode;
759     
760     QValueList<khtml::DashboardRegionValue> m_dashboardRegions;
761     bool m_hasDashboardRegions;
762     bool m_dashboardRegionsDirty;
763 #endif
764 };
765
766 class DocumentFragmentImpl : public NodeBaseImpl
767 {
768 public:
769     DocumentFragmentImpl(DocumentPtr *doc);
770
771     // DOM methods overridden from  parent classes
772     virtual DOMString nodeName() const;
773     virtual unsigned short nodeType() const;
774     virtual NodeImpl *cloneNode ( bool deep );
775
776     // Other methods (not part of DOM)
777     virtual bool childTypeAllowed( unsigned short type );
778
779     virtual DOMString toString() const;
780 };
781
782
783 class DocumentTypeImpl : public NodeImpl
784 {
785 public:
786     DocumentTypeImpl(DOMImplementationImpl *_implementation, DocumentPtr *doc,
787                      const DOMString &qualifiedName, const DOMString &publicId,
788                      const DOMString &systemId);
789     ~DocumentTypeImpl();
790
791     // DOM methods & attributes for DocumentType
792     NamedNodeMapImpl *entities() const { return m_entities; }
793     NamedNodeMapImpl *notations() const { return m_notations; }
794
795     DOMString name() const { return m_qualifiedName; }
796     DOMString publicId() const { return m_publicId; }
797     DOMString systemId() const { return m_systemId; }
798     DOMString internalSubset() const { return m_subset; }
799
800     // DOM methods overridden from  parent classes
801     virtual DOMString nodeName() const;
802     virtual unsigned short nodeType() const;
803     virtual bool childTypeAllowed( unsigned short type );
804     virtual NodeImpl *cloneNode ( bool deep );
805
806     // Other methods (not part of DOM)
807     void setName(const DOMString& n) { m_qualifiedName = n; }
808     void setPublicId(const DOMString& publicId) { m_publicId = publicId; }
809     void setSystemId(const DOMString& systemId) { m_systemId = systemId; }
810     DOMImplementationImpl *implementation() const { return m_implementation; }
811     void copyFrom(const DocumentTypeImpl&);
812
813     virtual DOMString toString() const;
814
815 #if APPLE_CHANGES
816     static DocumentType createInstance (DocumentTypeImpl *impl);
817 #endif
818
819 protected:
820     DOMImplementationImpl *m_implementation;
821     NamedNodeMapImpl* m_entities;
822     NamedNodeMapImpl* m_notations;
823
824     DOMString m_qualifiedName;
825     DOMString m_publicId;
826     DOMString m_systemId;
827     DOMString m_subset;
828 };
829
830
831 }; //namespace
832 #endif