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_usesDescendantRules;
 676     bool m_usesSiblingRules;
 677
 678     DOMString m_title;
 679
 680     RenderArena* m_renderArena;
 681
 682     QPtrDict< QValueList<DocumentMarker> > m_markers;
 683
 684 #if APPLE_CHANGES
 685     KWQAccObjectCache* m_accCache;
 686 #endif
 687
 688     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchSoonList;
 689     QPtrList<HTMLImageLoader> m_imageLoadEventDispatchingList;
 690     int m_imageLoadEventTimer;
 691
 692     NodeImpl* m_cssTarget;
 693
 694     bool m_processingLoadEvent;
 695     QTime m_startTime;
 696     bool m_overMinimumLayoutThreshold;
 697
 698 #ifdef KHTML_XSLT
 699     void* m_transformSource;
 700     DocumentImpl* m_transformSourceDocument;
 701 #endif
 702
 703 #ifndef KHTML_NO_XBL
 704     XBL::XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
 705 #endif
 706
 707     QMap<QString, HTMLMapElementImpl *> m_imageMapsByName;
 708
 709     DOMString m_policyBaseURL;
 710
 711     QPtrDict<NodeImpl> m_disconnectedNodesWithEventListeners;
 712
 713     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
 714
 715 #if APPLE_CHANGES
 716 public:
 717     KWQSignal m_finishedParsing;
 718
 719     static Document createInstance (DocumentImpl *impl);
 720
 721     bool inPageCache();
 722     void setInPageCache(bool flag);
 723     void restoreRenderer(khtml::RenderObject* render);
 724
 725     void passwordFieldAdded();
 726     void passwordFieldRemoved();
 727     bool hasPasswordField() const;
 728
 729     void secureFormAdded();
 730     void secureFormRemoved();
 731     bool hasSecureForm() const;
 732
 733     void setShouldCreateRenderers(bool f);
 734     bool shouldCreateRenderers();
 735
 736     void setDecoder(khtml::Decoder *);
 737     khtml::Decoder *decoder() const { return m_decoder; }
 738
 739     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
 740     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
 741     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
 742     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
 743     const QValueList<khtml::DashboardRegionValue> & dashboardRegions() const;
 744     void setDashboardRegions (const QValueList<khtml::DashboardRegionValue>& regions);
 745
 746     void removeAllEventListenersFromAllNodes();
 747
 748     void registerDisconnectedNodeWithEventListeners(NodeImpl *node);
 749     void unregisterDisconnectedNodeWithEventListeners(NodeImpl *node);
 750
 751 private:
 752     void removeAllDisconnectedNodeEventListeners();
 753
 754     JSEditor *jsEditor();
 755
 756     JSEditor *m_jsEditor;
 757     bool relinquishesEditingFocus(NodeImpl *node);
 758     bool acceptsEditingFocus(NodeImpl *node);
 759
 760     mutable DOMString m_domain;
 761     bool m_inPageCache;
 762     khtml::RenderObject *m_savedRenderer;
 763     int m_passwordFields;
 764     int m_secureForms;
 765
 766     khtml::Decoder *m_decoder;
 767
 768     QDict<ElementImpl> m_elementsById;
 769
 770     QDict<ElementImpl> m_elementsByAccessKey;
 771     bool m_accessKeyDictValid;
 772
 773     bool m_createRenderers;
 774
 775     InheritedBool m_designMode;
 776
 777     QValueList<khtml::DashboardRegionValue> m_dashboardRegions;
 778     bool m_hasDashboardRegions;
 779     bool m_dashboardRegionsDirty;
 780 #endif
 781 };
 782
 783 class DocumentFragmentImpl : public ContainerNodeImpl
 784 {
 785 public:
 786     DocumentFragmentImpl(DocumentPtr *doc);
 787
 788     // DOM methods overridden from  parent classes
 789     virtual DOMString nodeName() const;
 790     virtual unsigned short nodeType() const;
 791     virtual NodeImpl *cloneNode ( bool deep );
 792
 793     // Other methods (not part of DOM)
 794     virtual bool childTypeAllowed( unsigned short type );
 795
 796     virtual DOMString toString() const;
 797 };
 798
 799
 800 class DocumentTypeImpl : public NodeImpl
 801 {
 802 public:
 803     DocumentTypeImpl(DOMImplementationImpl *_implementation, DocumentPtr *doc,
 804                      const DOMString &qualifiedName, const DOMString &publicId,
 805                      const DOMString &systemId);
 806     ~DocumentTypeImpl();
 807
 808     // DOM methods & attributes for DocumentType
 809     NamedNodeMapImpl *entities() const { return m_entities; }
 810     NamedNodeMapImpl *notations() const { return m_notations; }
 811
 812     DOMString name() const { return m_qualifiedName; }
 813     DOMString publicId() const { return m_publicId; }
 814     DOMString systemId() const { return m_systemId; }
 815     DOMString internalSubset() const { return m_subset; }
 816
 817     // DOM methods overridden from  parent classes
 818     virtual DOMString nodeName() const;
 819     virtual unsigned short nodeType() const;
 820     virtual bool childTypeAllowed( unsigned short type );
 821     virtual NodeImpl *cloneNode ( bool deep );
 822
 823     // Other methods (not part of DOM)
 824     void setName(const DOMString& n) { m_qualifiedName = n; }
 825     void setPublicId(const DOMString& publicId) { m_publicId = publicId; }
 826     void setSystemId(const DOMString& systemId) { m_systemId = systemId; }
 827     DOMImplementationImpl *implementation() const { return m_implementation; }
 828     void copyFrom(const DocumentTypeImpl&);
 829
 830     virtual DOMString toString() const;
 831
 832 #if APPLE_CHANGES
 833     static DocumentType createInstance (DocumentTypeImpl *impl);
 834 #endif
 835
 836 protected:
 837     DOMImplementationImpl *m_implementation;
 838     NamedNodeMapImpl* m_entities;
 839     NamedNodeMapImpl* m_notations;
 840
 841     DOMString m_qualifiedName;
 842     DOMString m_publicId;
 843     DOMString m_systemId;
 844     DOMString m_subset;
 845 };
 846
 847
 848 }; //namespace
 849 #endif