Reviewed by Darin.
[WebKit-https.git] / WebCore / khtml / xml / dom_docimpl.cpp
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 #include "dom/dom_exception.h"
26
27 #include "xml/dom_textimpl.h"
28 #include "xml/dom_xmlimpl.h"
29 #include "xml/dom2_rangeimpl.h"
30 #include "xml/dom2_eventsimpl.h"
31 #include "xml/xml_tokenizer.h"
32
33 #include "xml_namespace_table.h"
34
35 #include "css/csshelper.h"
36 #include "css/cssstyleselector.h"
37 #include "css/css_stylesheetimpl.h"
38 #include "css/css_valueimpl.h"
39 #include "misc/htmlhashes.h"
40 #include "misc/helper.h"
41 #include "ecma/kjs_proxy.h"
42 #include "ecma/kjs_binding.h"
43
44 #include <qptrstack.h>
45 #include <qpaintdevicemetrics.h>
46 #include <qregexp.h>
47 #include <kdebug.h>
48 #include <kstaticdeleter.h>
49
50 #include "rendering/render_canvas.h"
51 #include "rendering/render_frames.h"
52 #include "rendering/render_image.h"
53 #include "rendering/render_object.h"
54 #include "render_arena.h"
55
56 #include "khtmlview.h"
57 #include "khtml_part.h"
58
59 #include <kglobalsettings.h>
60 #include <kstringhandler.h>
61 #include "khtml_settings.h"
62 #include "khtmlpart_p.h"
63
64 #include "html/html_baseimpl.h"
65 #include "html/html_blockimpl.h"
66 #include "html/html_canvasimpl.h"
67 #include "html/html_documentimpl.h"
68 #include "html/html_formimpl.h"
69 #include "html/html_headimpl.h"
70 #include "html/html_imageimpl.h"
71 #include "html/html_listimpl.h"
72 #include "html/html_miscimpl.h"
73 #include "html/html_tableimpl.h"
74 #include "html/html_objectimpl.h"
75
76 #include "cssvalues.h"
77
78 #include "editing/jsediting.h"
79 #include "editing/visible_position.h"
80 #include "editing/visible_text.h"
81
82 #include <kio/job.h>
83
84 #ifdef KHTML_XSLT
85 #include "xsl_stylesheetimpl.h"
86 #include "xslt_processorimpl.h"
87 #endif
88
89 #ifndef KHTML_NO_XBL
90 #include "xbl/xbl_binding_manager.h"
91 using XBL::XBLBindingManager;
92 #endif
93
94 #if APPLE_CHANGES
95 #include "KWQAccObjectCache.h"
96 #include "KWQLogging.h"
97 #endif
98
99 using namespace DOM;
100 using namespace khtml;
101
102 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
103
104 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
105 // FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high
106 // for dual G5s. :)
107 const int cLayoutScheduleThreshold = 250;
108
109 DOMImplementationImpl *DOMImplementationImpl::m_instance = 0;
110
111 DOMImplementationImpl::DOMImplementationImpl()
112 {
113 }
114
115 DOMImplementationImpl::~DOMImplementationImpl()
116 {
117 }
118
119 bool DOMImplementationImpl::hasFeature ( const DOMString &feature, const DOMString &version )
120 {
121     QString lower = feature.string().lower();
122     if (lower == "core" || lower == "html" || lower == "xml")
123         return version.isEmpty() || version == "1.0" || version == "2.0";
124     if (lower == "css"
125             || lower == "css2"
126             || lower == "events"
127             || lower == "htmlevents"
128             || lower == "mouseevents"
129             || lower == "mutationevents"
130             || lower == "range"
131             || lower == "stylesheets"
132             || lower == "traversal"
133             || lower == "uievents"
134             || lower == "views")
135         return version.isEmpty() || version == "2.0";
136     return false;
137 }
138
139 DocumentTypeImpl *DOMImplementationImpl::createDocumentType( const DOMString &qualifiedName, const DOMString &publicId,
140                                                              const DOMString &systemId, int &exceptioncode )
141 {
142     // Not mentioned in spec: throw NAMESPACE_ERR if no qualifiedName supplied
143     if (qualifiedName.isNull()) {
144         exceptioncode = DOMException::NAMESPACE_ERR;
145         return 0;
146     }
147
148     // INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.
149     if (!Element::khtmlValidQualifiedName(qualifiedName)) {
150         exceptioncode = DOMException::INVALID_CHARACTER_ERR;
151         return 0;
152     }
153
154     // NAMESPACE_ERR: Raised if the qualifiedName is malformed.
155     if (Element::khtmlMalformedQualifiedName(qualifiedName)) {
156         exceptioncode = DOMException::NAMESPACE_ERR;
157         return 0;
158     }
159
160     return new DocumentTypeImpl(this,0,qualifiedName,publicId,systemId);
161 }
162
163 DOMImplementationImpl* DOMImplementationImpl::getInterface(const DOMString& /*feature*/) const
164 {
165     // ###
166     return 0;
167 }
168
169 DocumentImpl *DOMImplementationImpl::createDocument( const DOMString &namespaceURI, const DOMString &qualifiedName,
170                                                      const DocumentType &doctype, int &exceptioncode )
171 {
172     exceptioncode = 0;
173
174     // Not mentioned in spec: throw NAMESPACE_ERR if no qualifiedName supplied
175     if (qualifiedName.isNull()) {
176         exceptioncode = DOMException::NAMESPACE_ERR;
177         return 0;
178     }
179
180     // INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.
181     if (!Element::khtmlValidQualifiedName(qualifiedName)) {
182         exceptioncode = DOMException::INVALID_CHARACTER_ERR;
183         return 0;
184     }
185
186     // NAMESPACE_ERR:
187     // - Raised if the qualifiedName is malformed,
188     // - if the qualifiedName has a prefix and the namespaceURI is null, or
189     // - if the qualifiedName has a prefix that is "xml" and the namespaceURI is different
190     //   from "http://www.w3.org/XML/1998/namespace" [Namespaces].
191     int colonpos = -1;
192     uint i;
193     DOMStringImpl *qname = qualifiedName.implementation();
194     for (i = 0; i < qname->l && colonpos < 0; i++) {
195         if ((*qname)[i] == ':')
196             colonpos = i;
197     }
198
199     if (Element::khtmlMalformedQualifiedName(qualifiedName) ||
200         (colonpos >= 0 && namespaceURI.isNull()) ||
201         (colonpos == 3 && qualifiedName[0] == 'x' && qualifiedName[1] == 'm' && qualifiedName[2] == 'l' &&
202          namespaceURI != "http://www.w3.org/XML/1998/namespace")) {
203
204         exceptioncode = DOMException::NAMESPACE_ERR;
205         return 0;
206     }
207
208     DocumentTypeImpl *dtype = static_cast<DocumentTypeImpl*>(doctype.handle());
209     // WRONG_DOCUMENT_ERR: Raised if doctype has already been used with a different document or was
210     // created from a different implementation.
211     if (dtype && (dtype->getDocument() || dtype->implementation() != this)) {
212         exceptioncode = DOMException::WRONG_DOCUMENT_ERR;
213         return 0;
214     }
215
216     // ### this is completely broken.. without a view it will not work (Dirk)
217     DocumentImpl *doc = new DocumentImpl(this, 0);
218
219     // now get the interesting parts of the doctype
220     // ### create new one if not there (currently always there)
221     if (doc->doctype() && dtype)
222         doc->doctype()->copyFrom(*dtype);
223
224     return doc;
225 }
226
227 CSSStyleSheetImpl *DOMImplementationImpl::createCSSStyleSheet(DOMStringImpl */*title*/, DOMStringImpl *media,
228                                                               int &/*exceptioncode*/)
229 {
230     // ### TODO : title should be set, and media could have wrong syntax, in which case we should
231         // generate an exception.
232         CSSStyleSheetImpl *parent = 0L;
233         CSSStyleSheetImpl *sheet = new CSSStyleSheetImpl(parent, DOMString());
234         sheet->setMedia(new MediaListImpl(sheet, media));
235         return sheet;
236 }
237
238 DocumentImpl *DOMImplementationImpl::createDocument( KHTMLView *v )
239 {
240     return new DocumentImpl(this, v);
241 }
242
243 HTMLDocumentImpl *DOMImplementationImpl::createHTMLDocument( KHTMLView *v )
244 {
245     return new HTMLDocumentImpl(this, v);
246 }
247
248 DOMImplementationImpl *DOMImplementationImpl::instance()
249 {
250     if (!m_instance) {
251         m_instance = new DOMImplementationImpl();
252         m_instance->ref();
253     }
254
255     return m_instance;
256 }
257
258 // ------------------------------------------------------------------------
259
260 KStaticDeleter< QPtrList<DocumentImpl> > s_changedDocumentsDeleter;
261 QPtrList<DocumentImpl> * DocumentImpl::changedDocuments = 0;
262
263 // KHTMLView might be 0
264 DocumentImpl::DocumentImpl(DOMImplementationImpl *_implementation, KHTMLView *v)
265     : NodeBaseImpl( new DocumentPtr() )
266       , m_domtree_version(0)
267       , m_imageLoadEventTimer(0)
268 #ifndef KHTML_NO_XBL
269       , m_bindingManager(new XBLBindingManager(this))
270 #endif
271 #ifdef KHTML_XSLT
272     , m_transformSource(NULL)
273     , m_transformSourceDocument(0)
274 #endif
275 #if APPLE_CHANGES
276     , m_finishedParsing(this, SIGNAL(finishedParsing()))
277     , m_inPageCache(false)
278     , m_savedRenderer(0)
279     , m_passwordFields(0)
280     , m_secureForms(0)
281     , m_decoder(0)
282     , m_createRenderers(true)
283     , m_designMode(inherit)
284     , m_hasDashboardRegions(false)
285     , m_dashboardRegionsDirty(false)
286 #endif
287 {
288     document->doc = this;
289
290     m_paintDevice = 0;
291     m_paintDeviceMetrics = 0;
292
293     m_view = v;
294     m_renderArena = 0;
295
296 #if APPLE_CHANGES
297     m_accCache = 0;
298 #endif
299     
300     if ( v ) {
301         m_docLoader = new DocLoader(v->part(), this );
302         setPaintDevice( m_view );
303     }
304     else
305         m_docLoader = new DocLoader( 0, this );
306
307     visuallyOrdered = false;
308     m_loadingSheet = false;
309     m_bParsing = false;
310     m_docChanged = false;
311     m_sheet = 0;
312     m_elemSheet = 0;
313     m_tokenizer = 0;
314
315     // ### this should be created during parsing a <!DOCTYPE>
316     // not during construction. Not sure who added that and why (Dirk)
317     m_doctype = new DocumentTypeImpl(_implementation, document,
318                                      DOMString() /* qualifiedName */,
319                                      DOMString() /* publicId */,
320                                      DOMString() /* systemId */);
321     m_doctype->ref();
322
323     m_implementation = _implementation;
324     if (m_implementation)
325         m_implementation->ref();
326     pMode = Strict;
327     hMode = XHtml;
328     m_textColor = Qt::black;
329     m_elementNames = 0;
330     m_elementNameAlloc = 0;
331     m_elementNameCount = 0;
332     m_attrNames = 0;
333     m_attrNameAlloc = 0;
334     m_attrNameCount = 0;
335     m_focusNode = 0;
336     m_hoverNode = 0;
337     m_defaultView = new AbstractViewImpl(this);
338     m_defaultView->ref();
339     m_listenerTypes = 0;
340     m_styleSheets = new StyleSheetListImpl;
341     m_styleSheets->ref();
342     m_inDocument = true;
343     m_styleSelectorDirty = false;
344     m_inStyleRecalc = false;
345     m_usesDescendantRules = false;
346     m_usesSiblingRules = false;
347
348     m_styleSelector = new CSSStyleSelector(this, m_usersheet, m_styleSheets, !inCompatMode());
349     m_windowEventListeners.setAutoDelete(true);
350     m_pendingStylesheets = 0;
351     m_ignorePendingStylesheets = false;
352
353     m_cssTarget = 0;
354     m_accessKeyDictValid = false;
355
356     resetLinkColor();
357     resetVisitedLinkColor();
358     resetActiveLinkColor();
359
360     m_processingLoadEvent = false;
361     m_startTime.restart();
362     m_overMinimumLayoutThreshold = false;
363     
364     m_jsEditor = 0;
365 }
366
367 DocumentImpl::~DocumentImpl()
368 {
369     assert(!m_render);
370 #if APPLE_CHANGES
371     assert(!m_inPageCache);
372     assert(m_savedRenderer == 0);
373 #endif
374     
375     KJS::ScriptInterpreter::forgetDOMObjectsForDocument(this);
376
377     if (changedDocuments && m_docChanged)
378         changedDocuments->remove(this);
379     delete m_tokenizer;
380     document->doc = 0;
381     delete m_sheet;
382     delete m_styleSelector;
383     delete m_docLoader;
384     if (m_elemSheet )  m_elemSheet->deref();
385     if (m_doctype)
386         m_doctype->deref();
387     if (m_implementation)
388         m_implementation->deref();
389     delete m_paintDeviceMetrics;
390
391     if (m_elementNames) {
392         for (unsigned short id = 0; id < m_elementNameCount; id++)
393             m_elementNames[id]->deref();
394         delete [] m_elementNames;
395     }
396     if (m_attrNames) {
397         for (unsigned short id = 0; id < m_attrNameCount; id++)
398             m_attrNames[id]->deref();
399         delete [] m_attrNames;
400     }
401     m_defaultView->deref();
402     m_styleSheets->deref();
403
404     if (m_focusNode)
405         m_focusNode->deref();
406     if (m_hoverNode)
407         m_hoverNode->deref();
408     
409     if (m_renderArena){
410         delete m_renderArena;
411         m_renderArena = 0;
412     }
413
414 #ifdef KHTML_XSLT
415     xmlFreeDoc((xmlDocPtr)m_transformSource);
416     if (m_transformSourceDocument)
417         m_transformSourceDocument->deref();
418 #endif
419
420 #ifndef KHTML_NO_XBL
421     delete m_bindingManager;
422 #endif
423
424 #if APPLE_CHANGES
425     if (m_accCache){
426         delete m_accCache;
427         m_accCache = 0;
428     }
429 #endif
430     
431     if (m_decoder){
432         m_decoder->deref();
433         m_decoder = 0;
434     }
435     
436     if (m_jsEditor) {
437         delete m_jsEditor;
438         m_jsEditor = 0;
439     }
440 }
441
442 void DocumentImpl::resetLinkColor()
443 {
444     m_linkColor = QColor(0, 0, 238);
445 }
446
447 void DocumentImpl::resetVisitedLinkColor()
448 {
449     m_visitedLinkColor = QColor(85, 26, 139);    
450 }
451
452 void DocumentImpl::resetActiveLinkColor()
453 {
454     m_activeLinkColor.setNamedColor(QString("red"));
455 }
456
457 DocumentTypeImpl *DocumentImpl::doctype() const
458 {
459     return m_doctype;
460 }
461
462 DOMImplementationImpl *DocumentImpl::implementation() const
463 {
464     return m_implementation;
465 }
466
467 ElementImpl *DocumentImpl::documentElement() const
468 {
469     NodeImpl *n = firstChild();
470     while (n && n->nodeType() != Node::ELEMENT_NODE)
471       n = n->nextSibling();
472     return static_cast<ElementImpl*>(n);
473 }
474
475 ElementImpl *DocumentImpl::createElement( const DOMString &name, int &exceptioncode )
476 {
477     return new XMLElementImpl( document, name.implementation() );
478 }
479
480 DocumentFragmentImpl *DocumentImpl::createDocumentFragment(  )
481 {
482     return new DocumentFragmentImpl( docPtr() );
483 }
484
485 TextImpl *DocumentImpl::createTextNode( const DOMString &data )
486 {
487     return new TextImpl( docPtr(), data);
488 }
489
490 CommentImpl *DocumentImpl::createComment ( const DOMString &data )
491 {
492     return new CommentImpl( docPtr(), data );
493 }
494
495 CDATASectionImpl *DocumentImpl::createCDATASection ( const DOMString &data )
496 {
497     return new CDATASectionImpl( docPtr(), data );
498 }
499
500 ProcessingInstructionImpl *DocumentImpl::createProcessingInstruction ( const DOMString &target, const DOMString &data )
501 {
502     return new ProcessingInstructionImpl( docPtr(),target,data);
503 }
504
505 Attr DocumentImpl::createAttribute( NodeImpl::Id id )
506 {
507     // Assume this is an HTML attribute, since createAttribute isn't namespace-aware.  There's no harm to XML
508     // documents if we're wrong.
509     return new AttrImpl(0, docPtr(), new HTMLAttributeImpl(id, DOMString("").implementation()));
510 }
511
512 EntityReferenceImpl *DocumentImpl::createEntityReference ( const DOMString &name )
513 {
514     return new EntityReferenceImpl(docPtr(), name.implementation());
515 }
516
517 EditingTextImpl *DocumentImpl::createEditingTextNode(const DOMString &text)
518 {
519     return new EditingTextImpl(docPtr(), text);
520 }
521
522 CSSStyleDeclarationImpl *DocumentImpl::createCSSStyleDeclaration()
523 {
524     return new CSSMutableStyleDeclarationImpl;
525 }
526
527 NodeImpl *DocumentImpl::importNode(NodeImpl *importedNode, bool deep, int &exceptioncode)
528 {
529         NodeImpl *result = 0;
530
531         if(importedNode->nodeType() == Node::ELEMENT_NODE)
532         {
533                 ElementImpl *tempElementImpl = createElementNS(getDocument()->namespaceURI(id()), importedNode->nodeName(), exceptioncode);
534                 if (exceptioncode)
535                     return 0;
536                 result = tempElementImpl;
537
538                 if(static_cast<ElementImpl *>(importedNode)->attributes(true) && static_cast<ElementImpl *>(importedNode)->attributes(true)->length())
539                 {
540                         NamedNodeMapImpl *attr = static_cast<ElementImpl *>(importedNode)->attributes();
541
542                         for(unsigned int i = 0; i < attr->length(); i++)
543                         {
544                                 DOMString qualifiedName = attr->item(i)->nodeName();
545                                 DOMString value = attr->item(i)->nodeValue();
546
547                                 int colonpos = qualifiedName.find(':');
548                                 DOMString localName = qualifiedName;
549                                 if(colonpos >= 0)
550                                 {
551                                         localName.remove(0, colonpos + 1);
552                                         // ### extract and set new prefix
553                                 }
554
555                                 NodeImpl::Id nodeId = getDocument()->attrId(getDocument()->namespaceURI(id()), localName.implementation(), false /* allocate */);
556                                 tempElementImpl->setAttribute(nodeId, value.implementation(), exceptioncode);
557
558                                 if(exceptioncode != 0)
559                                         break;
560                         }
561                 }
562         }
563         else if(importedNode->nodeType() == Node::TEXT_NODE)
564         {
565                 result = createTextNode(importedNode->nodeValue());
566                 deep = false;
567         }
568         else if(importedNode->nodeType() == Node::CDATA_SECTION_NODE)
569         {
570                 result = createCDATASection(importedNode->nodeValue());
571                 deep = false;
572         }
573         else if(importedNode->nodeType() == Node::ENTITY_REFERENCE_NODE)
574                 result = createEntityReference(importedNode->nodeName());
575         else if(importedNode->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
576         {
577                 result = createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue());
578                 deep = false;
579         }
580         else if(importedNode->nodeType() == Node::COMMENT_NODE)
581         {
582                 result = createComment(importedNode->nodeValue());
583                 deep = false;
584         }
585         else
586                 exceptioncode = DOMException::NOT_SUPPORTED_ERR;
587
588         if(deep)
589         {
590                 for(Node n = importedNode->firstChild(); !n.isNull(); n = n.nextSibling())
591                         result->appendChild(importNode(n.handle(), true, exceptioncode), exceptioncode);
592         }
593
594         return result;
595 }
596
597 ElementImpl *DocumentImpl::createElementNS( const DOMString &_namespaceURI, const DOMString &_qualifiedName, int &exceptioncode)
598 {
599     ElementImpl *e = 0;
600     QString qName = _qualifiedName.string();
601     int colonPos = qName.find(':',0);
602
603     if (_namespaceURI == XHTML_NAMESPACE) {
604         // User requested an element in the XHTML namespace - this means we create a HTML element
605         // (elements not in this namespace are treated as normal XML elements)
606         e = createHTMLElement(qName.mid(colonPos+1), exceptioncode);
607         if (exceptioncode)
608             return 0;
609         if (e && colonPos >= 0) {
610             e->setPrefix(qName.left(colonPos), exceptioncode);
611             if (exceptioncode) {
612                 delete e;
613                 return 0;
614             }
615         }
616     }
617     if (!e)
618         e = new XMLElementImpl( document, _qualifiedName.implementation(), _namespaceURI.implementation() );
619
620     return e;
621 }
622
623 ElementImpl *DocumentImpl::getElementById( const DOMString &elementId ) const
624 {
625     if (elementId.length() == 0) {
626         return 0;
627     }
628
629     return m_elementsById.find(elementId.string());
630 }
631
632
633 void DocumentImpl::addElementById(const DOMString &elementId, ElementImpl *element)
634 {
635     QString qId = elementId.string();
636
637     if (m_elementsById.find(qId) == NULL) {
638         m_elementsById.insert(qId, element);
639         m_accessKeyDictValid = false;
640     }
641 }
642
643 void DocumentImpl::removeElementById(const DOMString &elementId, ElementImpl *element)
644 {
645     QString qId = elementId.string();
646
647     if (m_elementsById.find(qId) == element) {
648         m_elementsById.remove(qId);
649         m_accessKeyDictValid = false;
650     }
651 }
652
653 ElementImpl *DocumentImpl::getElementByAccessKey( const DOMString &key )
654 {
655     if (key.length() == 0)
656         return 0;
657
658     QString k(key.string());
659     if (!m_accessKeyDictValid) {
660         m_elementsByAccessKey.clear();
661     
662         const NodeImpl *n;
663         for (n = this; n != 0; n = n->traverseNextNode()) {
664             if (!n->isElementNode())
665                 continue;
666             const ElementImpl *elementImpl = static_cast<const ElementImpl *>(n);
667             DOMString accessKey(elementImpl->getAttribute(ATTR_ACCESSKEY));
668             if (!accessKey.isEmpty()) {
669                 QString ak = accessKey.string().lower();
670                 if (m_elementsByAccessKey.find(ak) == NULL)
671                     m_elementsByAccessKey.insert(ak, elementImpl);
672             }
673         }
674         m_accessKeyDictValid = true;
675     }
676     return m_elementsByAccessKey.find(k);
677 }
678
679 void DocumentImpl::setTitle(DOMString _title)
680 {
681     m_title = _title;
682
683     if (!part())
684         return;
685
686 #if APPLE_CHANGES
687     KWQ(part())->setTitle(_title);
688 #else
689     QString titleStr = m_title.string();
690     for (int i = 0; i < titleStr.length(); ++i)
691         if (titleStr[i] < ' ')
692             titleStr[i] = ' ';
693     titleStr = titleStr.stripWhiteSpace();
694     titleStr.compose();
695     if ( !part()->parentPart() ) {
696         if (titleStr.isNull() || titleStr.isEmpty()) {
697             // empty title... set window caption as the URL
698             KURL url = m_url;
699             url.setRef(QString::null);
700             url.setQuery(QString::null);
701             titleStr = url.url();
702         }
703
704         emit part()->setWindowCaption( KStringHandler::csqueeze( titleStr, 128 ) );
705     }
706 #endif
707 }
708
709 DOMString DocumentImpl::nodeName() const
710 {
711     return "#document";
712 }
713
714 unsigned short DocumentImpl::nodeType() const
715 {
716     return Node::DOCUMENT_NODE;
717 }
718
719 ElementImpl *DocumentImpl::createHTMLElement( const DOMString &name, int &exceptioncode )
720 {
721     if (!isValidName(name)) {
722         exceptioncode = DOMException::INVALID_CHARACTER_ERR;
723         return 0;
724     }
725     return createHTMLElement(tagId(0, name.implementation(), false));
726 }
727
728 ElementImpl *DocumentImpl::createHTMLElement(unsigned short tagID)
729 {
730     switch (tagID)
731     {
732     case ID_HTML:
733         return new HTMLHtmlElementImpl(docPtr());
734     case ID_HEAD:
735         return new HTMLHeadElementImpl(docPtr());
736     case ID_BODY:
737         return new HTMLBodyElementImpl(docPtr());
738
739 // head elements
740     case ID_BASE:
741         return new HTMLBaseElementImpl(docPtr());
742     case ID_LINK:
743         return new HTMLLinkElementImpl(docPtr());
744     case ID_META:
745         return new HTMLMetaElementImpl(docPtr());
746     case ID_STYLE:
747         return new HTMLStyleElementImpl(docPtr());
748     case ID_TITLE:
749         return new HTMLTitleElementImpl(docPtr());
750
751 // frames
752     case ID_FRAME:
753         return new HTMLFrameElementImpl(docPtr());
754     case ID_FRAMESET:
755         return new HTMLFrameSetElementImpl(docPtr());
756     case ID_IFRAME:
757         return new HTMLIFrameElementImpl(docPtr());
758
759 // form elements
760 // ### FIXME: we need a way to set form dependency after we have made the form elements
761     case ID_FORM:
762         return new HTMLFormElementImpl(docPtr());
763     case ID_BUTTON:
764         return new HTMLButtonElementImpl(docPtr());
765     case ID_FIELDSET:
766         return new HTMLFieldSetElementImpl(docPtr());
767     case ID_INPUT:
768         return new HTMLInputElementImpl(docPtr());
769     case ID_ISINDEX:
770         return new HTMLIsIndexElementImpl(docPtr());
771     case ID_LABEL:
772         return new HTMLLabelElementImpl(docPtr());
773     case ID_LEGEND:
774         return new HTMLLegendElementImpl(docPtr());
775     case ID_OPTGROUP:
776         return new HTMLOptGroupElementImpl(docPtr());
777     case ID_OPTION:
778         return new HTMLOptionElementImpl(docPtr());
779     case ID_SELECT:
780         return new HTMLSelectElementImpl(docPtr());
781     case ID_TEXTAREA:
782         return new HTMLTextAreaElementImpl(docPtr());
783
784 // lists
785     case ID_DL:
786         return new HTMLDListElementImpl(docPtr());
787     case ID_DD:
788         return new HTMLGenericElementImpl(docPtr(), tagID);
789     case ID_DT:
790         return new HTMLGenericElementImpl(docPtr(), tagID);
791     case ID_UL:
792         return new HTMLUListElementImpl(docPtr());
793     case ID_OL:
794         return new HTMLOListElementImpl(docPtr());
795     case ID_DIR:
796         return new HTMLDirectoryElementImpl(docPtr());
797     case ID_MENU:
798         return new HTMLMenuElementImpl(docPtr());
799     case ID_LI:
800         return new HTMLLIElementImpl(docPtr());
801
802 // formatting elements (block)
803     case ID_BLOCKQUOTE:
804         return new HTMLBlockquoteElementImpl(docPtr());
805     case ID_DIV:
806         return new HTMLDivElementImpl(docPtr());
807     case ID_H1:
808     case ID_H2:
809     case ID_H3:
810     case ID_H4:
811     case ID_H5:
812     case ID_H6:
813         return new HTMLHeadingElementImpl(docPtr(), tagID);
814     case ID_HR:
815         return new HTMLHRElementImpl(docPtr());
816     case ID_P:
817         return new HTMLParagraphElementImpl(docPtr());
818     case ID_PRE:
819     case ID_XMP:
820     case ID_PLAINTEXT:
821         return new HTMLPreElementImpl(docPtr(), tagID);
822     case ID_LAYER:
823         return new HTMLLayerElementImpl(docPtr());
824
825 // font stuff
826     case ID_BASEFONT:
827         return new HTMLBaseFontElementImpl(docPtr());
828     case ID_FONT:
829         return new HTMLFontElementImpl(docPtr());
830
831 // ins/del
832     case ID_DEL:
833     case ID_INS:
834         return new HTMLGenericElementImpl(docPtr(), tagID);
835
836 // anchor
837     case ID_A:
838         return new HTMLAnchorElementImpl(docPtr());
839
840 // images
841     case ID_IMG:
842         return new HTMLImageElementImpl(docPtr());
843     case ID_MAP:
844         return new HTMLMapElementImpl(docPtr());
845     case ID_AREA:
846         return new HTMLAreaElementImpl(docPtr());
847     case ID_CANVAS:
848         return new HTMLCanvasElementImpl(docPtr());
849
850 // objects, applets and scripts
851     case ID_APPLET:
852         return new HTMLAppletElementImpl(docPtr());
853     case ID_EMBED:
854         return new HTMLEmbedElementImpl(docPtr());
855     case ID_OBJECT:
856         return new HTMLObjectElementImpl(docPtr());
857     case ID_PARAM:
858         return new HTMLParamElementImpl(docPtr());
859     case ID_SCRIPT:
860         return new HTMLScriptElementImpl(docPtr());
861
862 // tables
863     case ID_TABLE:
864         return new HTMLTableElementImpl(docPtr());
865     case ID_CAPTION:
866         return new HTMLTableCaptionElementImpl(docPtr());
867     case ID_COLGROUP:
868     case ID_COL:
869         return new HTMLTableColElementImpl(docPtr(), tagID);
870     case ID_TR:
871         return new HTMLTableRowElementImpl(docPtr());
872     case ID_TD:
873     case ID_TH:
874         return new HTMLTableCellElementImpl(docPtr(), tagID);
875     case ID_THEAD:
876     case ID_TBODY:
877     case ID_TFOOT:
878         return new HTMLTableSectionElementImpl(docPtr(), tagID, false);
879
880 // inline elements
881     case ID_BR:
882         return new HTMLBRElementImpl(docPtr());
883     case ID_Q:
884         return new HTMLGenericElementImpl(docPtr(), tagID);
885
886 // elements with no special representation in the DOM
887
888 // block:
889     case ID_ADDRESS:
890     case ID_CENTER:
891
892 // inline
893         // %fontstyle
894     case ID_TT:
895     case ID_U:
896     case ID_B:
897     case ID_I:
898     case ID_S:
899     case ID_STRIKE:
900     case ID_BIG:
901     case ID_SMALL:
902
903         // %phrase
904     case ID_EM:
905     case ID_STRONG:
906     case ID_DFN:
907     case ID_CODE:
908     case ID_SAMP:
909     case ID_KBD:
910     case ID_VAR:
911     case ID_CITE:
912     case ID_ABBR:
913     case ID_ACRONYM:
914
915         // %special
916     case ID_SUB:
917     case ID_SUP:
918     case ID_SPAN:
919     case ID_NOBR:
920     case ID_WBR:
921
922     case ID_BDO:
923     default:
924         return new HTMLGenericElementImpl(docPtr(), tagID);
925
926     case ID_MARQUEE:
927         return new HTMLMarqueeElementImpl(docPtr());
928         
929 // text
930     case ID_TEXT:
931         kdDebug( 6020 ) << "Use document->createTextNode()" << endl;
932         return 0;
933     }
934
935     return 0;
936 }
937
938 QString DocumentImpl::nextState()
939 {
940    QString state;
941    if (!m_state.isEmpty())
942    {
943       state = m_state.first();
944       m_state.remove(m_state.begin());
945    }
946    return state;
947 }
948
949 QStringList DocumentImpl::docState()
950 {
951     QStringList s;
952     for (QPtrListIterator<NodeImpl> it(m_maintainsState); it.current(); ++it)
953         s.append(it.current()->state());
954
955     return s;
956 }
957
958 KHTMLPart *DocumentImpl::part() const 
959 {
960     return m_view ? m_view->part() : 0; 
961 }
962
963 RangeImpl *DocumentImpl::createRange()
964 {
965     return new RangeImpl( docPtr() );
966 }
967
968 NodeIteratorImpl *DocumentImpl::createNodeIterator(NodeImpl *root, unsigned long whatToShow, 
969     NodeFilterImpl *filter, bool expandEntityReferences, int &exceptioncode)
970 {
971     if (!root) {
972         exceptioncode = DOMException::NOT_SUPPORTED_ERR;
973         return 0;
974     }
975     return new NodeIteratorImpl(root, whatToShow, filter, expandEntityReferences);
976 }
977
978 TreeWalkerImpl *DocumentImpl::createTreeWalker(NodeImpl *root, unsigned long whatToShow, 
979     NodeFilterImpl *filter, bool expandEntityReferences, int &exceptioncode)
980 {
981     if (!root) {
982         exceptioncode = DOMException::NOT_SUPPORTED_ERR;
983         return 0;
984     }
985     return new TreeWalkerImpl(root, whatToShow, filter, expandEntityReferences);
986 }
987
988 void DocumentImpl::setDocumentChanged(bool b)
989 {
990     if (!changedDocuments)
991         changedDocuments = s_changedDocumentsDeleter.setObject( new QPtrList<DocumentImpl>() );
992
993     if (b && !m_docChanged)
994         changedDocuments->append(this);
995     else if (!b && m_docChanged)
996         changedDocuments->remove(this);
997     m_docChanged = b;
998     
999     if (m_docChanged)
1000         m_accessKeyDictValid = false;
1001 }
1002
1003 void DocumentImpl::recalcStyle( StyleChange change )
1004 {
1005 //     qDebug("recalcStyle(%p)", this);
1006 //     QTime qt;
1007 //     qt.start();
1008     if (m_inStyleRecalc)
1009         return; // Guard against re-entrancy. -dwh
1010         
1011     m_inStyleRecalc = true;
1012     
1013     if( !m_render ) goto bail_out;
1014
1015     if ( change == Force ) {
1016         RenderStyle* oldStyle = m_render->style();
1017         if ( oldStyle ) oldStyle->ref();
1018         RenderStyle* _style = new (m_renderArena) RenderStyle();
1019         _style->ref();
1020         _style->setDisplay(BLOCK);
1021         _style->setVisuallyOrdered( visuallyOrdered );
1022         // ### make the font stuff _really_ work!!!!
1023
1024         khtml::FontDef fontDef;
1025         QFont f = KGlobalSettings::generalFont();
1026         fontDef.family = *(f.firstFamily());
1027         fontDef.italic = f.italic();
1028         fontDef.weight = f.weight();
1029 #if APPLE_CHANGES
1030         bool printing = m_paintDevice && (m_paintDevice->devType() == QInternal::Printer);
1031         fontDef.usePrinterFont = printing;
1032 #endif
1033         if (m_view) {
1034             const KHTMLSettings *settings = m_view->part()->settings();
1035 #if APPLE_CHANGES
1036             if (printing && !settings->shouldPrintBackgrounds()) {
1037                 _style->setShouldCorrectTextColor(true);
1038             }
1039 #endif
1040             QString stdfont = settings->stdFontName();
1041             if ( !stdfont.isEmpty() ) {
1042                 fontDef.family.setFamily(stdfont);
1043                 fontDef.family.appendFamily(0);
1044             }
1045             m_styleSelector->setFontSize(fontDef, m_styleSelector->fontSizeForKeyword(CSS_VAL_MEDIUM, inCompatMode()));
1046         }
1047
1048         //kdDebug() << "DocumentImpl::attach: setting to charset " << settings->charset() << endl;
1049         _style->setFontDef(fontDef);
1050         _style->htmlFont().update( paintDeviceMetrics() );
1051         if ( inCompatMode() )
1052             _style->setHtmlHacks(true); // enable html specific rendering tricks
1053
1054         StyleChange ch = diff( _style, oldStyle );
1055         if(m_render && ch != NoChange)
1056             m_render->setStyle(_style);
1057         if ( change != Force )
1058             change = ch;
1059
1060         _style->deref(m_renderArena);
1061         if (oldStyle)
1062             oldStyle->deref(m_renderArena);
1063     }
1064
1065     NodeImpl *n;
1066     for (n = _first; n; n = n->nextSibling())
1067         if ( change>= Inherit || n->hasChangedChild() || n->changed() )
1068             n->recalcStyle( change );
1069     //kdDebug( 6020 ) << "TIME: recalcStyle() dt=" << qt.elapsed() << endl;
1070
1071     if (changed() && m_view)
1072         m_view->layout();
1073
1074 bail_out:
1075     setChanged( false );
1076     setHasChangedChild( false );
1077     setDocumentChanged( false );
1078     
1079     m_inStyleRecalc = false;
1080 }
1081
1082 void DocumentImpl::updateRendering()
1083 {
1084     if (!hasChangedChild()) return;
1085
1086 //     QTime time;
1087 //     time.start();
1088 //     kdDebug() << "UPDATERENDERING: "<<endl;
1089
1090     StyleChange change = NoChange;
1091 #if 0
1092     if ( m_styleSelectorDirty ) {
1093         recalcStyleSelector();
1094         change = Force;
1095     }
1096 #endif
1097     recalcStyle( change );
1098
1099 //    kdDebug() << "UPDATERENDERING time used="<<time.elapsed()<<endl;
1100 }
1101
1102 void DocumentImpl::updateDocumentsRendering()
1103 {
1104     if (!changedDocuments)
1105         return;
1106
1107     while (DocumentImpl* doc = changedDocuments->take()) {
1108         doc->m_docChanged = false;
1109         doc->updateRendering();
1110     }
1111 }
1112
1113 void DocumentImpl::updateLayout()
1114 {
1115     // FIXME: Dave's pretty sure we can remove this because
1116     // layout calls recalcStyle as needed.
1117     updateRendering();
1118
1119     // Only do a layout if changes have occurred that make it necessary.      
1120     if (m_view && renderer() && renderer()->needsLayout())
1121         m_view->layout();
1122 }
1123
1124 // FIXME: This is a bad idea and needs to be removed eventually.
1125 // Other browsers load stylesheets before they continue parsing the web page.
1126 // Since we don't, we can run JavaScript code that needs answers before the
1127 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
1128 // lets us get reasonable answers. The long term solution to this problem is
1129 // to instead suspend JavaScript execution.
1130 void DocumentImpl::updateLayoutIgnorePendingStylesheets()
1131 {
1132     bool oldIgnore = m_ignorePendingStylesheets;
1133     
1134     if (!haveStylesheetsLoaded()) {
1135         m_ignorePendingStylesheets = true;
1136         updateStyleSelector();    
1137     }
1138
1139     updateLayout();
1140
1141     m_ignorePendingStylesheets = oldIgnore;
1142 }
1143
1144 void DocumentImpl::attach()
1145 {
1146     assert(!attached());
1147 #if APPLE_CHANGES
1148     assert(!m_inPageCache);
1149 #endif
1150
1151     if ( m_view )
1152         setPaintDevice( m_view );
1153
1154     if (!m_renderArena)
1155         m_renderArena = new RenderArena();
1156     
1157     // Create the rendering tree
1158     m_render = new (m_renderArena) RenderCanvas(this, m_view);
1159     recalcStyle( Force );
1160
1161     RenderObject* render = m_render;
1162     m_render = 0;
1163
1164     NodeBaseImpl::attach();
1165     m_render = render;
1166 }
1167
1168 void DocumentImpl::restoreRenderer(RenderObject* render)
1169 {
1170     m_render = render;
1171 }
1172
1173 void DocumentImpl::detach()
1174 {
1175     RenderObject* render = m_render;
1176
1177     // indicate destruction mode,  i.e. attached() but m_render == 0
1178     m_render = 0;
1179     
1180 #if APPLE_CHANGES
1181     if (m_inPageCache) {
1182         if ( render )
1183             getAccObjectCache()->detach(render);
1184         return;
1185     }
1186 #endif
1187
1188     // Empty out these lists as a performance optimization, since detaching
1189     // all the individual render objects will cause all the RenderImage
1190     // objects to remove themselves from the lists.
1191     m_imageLoadEventDispatchSoonList.clear();
1192     m_imageLoadEventDispatchingList.clear();
1193
1194     removeAllEventListenersFromAllNodes();
1195
1196     NodeBaseImpl::detach();
1197
1198     if ( render )
1199         render->detach();
1200
1201     if (m_paintDevice == m_view)
1202         setPaintDevice(0);
1203     m_view = 0;
1204     
1205     if (m_renderArena){
1206         delete m_renderArena;
1207         m_renderArena = 0;
1208     }
1209 }
1210
1211 void DocumentImpl::removeAllEventListenersFromAllNodes()
1212 {
1213     m_windowEventListeners.clear();
1214     removeAllDisconnectedNodeEventListeners();
1215     for (NodeImpl *n = this; n; n = n->traverseNextNode()) {
1216         n->removeAllEventListeners();
1217     }
1218 }
1219
1220 void DocumentImpl::registerDisconnectedNodeWithEventListeners(NodeImpl *node)
1221 {
1222     m_disconnectedNodesWithEventListeners.insert(node, node);
1223 }
1224
1225 void DocumentImpl::unregisterDisconnectedNodeWithEventListeners(NodeImpl *node)
1226 {
1227     m_disconnectedNodesWithEventListeners.remove(node);
1228 }
1229
1230 void DocumentImpl::removeAllDisconnectedNodeEventListeners()
1231 {
1232     for (QPtrDictIterator<NodeImpl> iter(m_disconnectedNodesWithEventListeners);
1233          iter.current();
1234          ++iter) {
1235         iter.current()->removeAllEventListeners();
1236     }
1237 }
1238
1239 #if APPLE_CHANGES
1240 KWQAccObjectCache* DocumentImpl::getAccObjectCache()
1241 {
1242     // The only document that actually has a KWQAccObjectCache is the top-level
1243     // document.  This is because we need to be able to get from any KWQAccObject
1244     // to any other KWQAccObject on the same page.  Using a single cache allows
1245     // lookups across nested webareas (i.e. multiple documents).
1246     
1247     if (m_accCache) {
1248         // return already known top-level cache
1249         if (!ownerElement())
1250             return m_accCache;
1251         
1252         // In some pages with frames, the cache is created before the sub-webarea is
1253         // inserted into the tree.  Here, we catch that case and just toss the old
1254         // cache and start over.
1255         delete m_accCache;
1256         m_accCache = 0;
1257     }
1258     
1259     // look for top-level document
1260     ElementImpl *element = ownerElement();
1261     if (element) {
1262         DocumentImpl *doc;
1263         while (element) {
1264             doc = element->getDocument();
1265             element = doc->ownerElement();
1266         }
1267         
1268         // ask the top-level document for its cache
1269         return doc->getAccObjectCache();
1270     }
1271     
1272     // this is the top-level document, so install a new cache
1273     m_accCache = new KWQAccObjectCache;
1274     return m_accCache;
1275 }
1276 #endif
1277
1278 void DocumentImpl::setVisuallyOrdered()
1279 {
1280     visuallyOrdered = true;
1281     if (m_render)
1282         m_render->style()->setVisuallyOrdered(true);
1283 }
1284
1285 void DocumentImpl::updateSelection()
1286 {
1287     if (!m_render)
1288         return;
1289     
1290     RenderCanvas *canvas = static_cast<RenderCanvas*>(m_render);
1291     Selection s = part()->selection();
1292     if (!s.isRange()) {
1293         canvas->clearSelection();
1294 #if APPLE_CHANGES
1295         if (KWQAccObjectCache::accessibilityEnabled())
1296             getAccObjectCache()->postNotificationToTopWebArea(renderer(), "AXSelectedTextChanged");
1297 #endif
1298     }
1299     else {
1300         Position startPos = VisiblePosition(s.start(), s.startAffinity(), khtml::VisiblePosition::INIT_UP).deepEquivalent();
1301         Position endPos = VisiblePosition(s.end(), s.endAffinity(), khtml::VisiblePosition::INIT_DOWN).deepEquivalent();
1302         if (startPos.isNotNull() && endPos.isNotNull()) {
1303             RenderObject *startRenderer = startPos.node()->renderer();
1304             RenderObject *endRenderer = endPos.node()->renderer();
1305             static_cast<RenderCanvas*>(m_render)->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
1306 #if APPLE_CHANGES
1307             if (KWQAccObjectCache::accessibilityEnabled()) {
1308                 getAccObjectCache()->postNotificationToTopWebArea(renderer(), "AXSelectedTextChanged");
1309             }
1310 #endif
1311         }
1312     }
1313 }
1314
1315 Tokenizer *DocumentImpl::createTokenizer()
1316 {
1317     return newXMLTokenizer(docPtr(), m_view);
1318 }
1319
1320 void DocumentImpl::setPaintDevice( QPaintDevice *dev )
1321 {
1322     if (m_paintDevice == dev) {
1323         return;
1324     }
1325     m_paintDevice = dev;
1326     delete m_paintDeviceMetrics;
1327     m_paintDeviceMetrics = dev ? new QPaintDeviceMetrics( dev ) : 0;
1328 }
1329
1330 void DocumentImpl::open(  )
1331 {
1332     if (parsing()) return;
1333
1334     implicitOpen();
1335
1336     if (part()) {
1337         part()->didExplicitOpen();
1338     }
1339
1340     // This is work that we should probably do in clear(), but we can't have it
1341     // happen when implicitOpen() is called unless we reorganize KHTMLPart code.
1342     setURL(QString());
1343     DocumentImpl *parent = parentDocument();
1344     setBaseURL(parent ? parent->baseURL() : QString());
1345 }
1346
1347 void DocumentImpl::implicitOpen()
1348 {
1349     if (m_tokenizer)
1350         close();
1351
1352     clear();
1353     m_tokenizer = createTokenizer();
1354     connect(m_tokenizer,SIGNAL(finishedParsing()),this,SIGNAL(finishedParsing()));
1355     setParsing(true);
1356
1357     if (m_view && m_view->part()->jScript()) {
1358         m_view->part()->jScript()->setSourceFile(m_url,""); //fixme
1359     }
1360 }
1361
1362 HTMLElementImpl* DocumentImpl::body()
1363 {
1364     NodeImpl *de = documentElement();
1365     if (!de)
1366         return 0;
1367     
1368     // try to prefer a FRAMESET element over BODY
1369     NodeImpl* body = 0;
1370     for (NodeImpl* i = de->firstChild(); i; i = i->nextSibling()) {
1371         if (i->id() == ID_FRAMESET)
1372             return static_cast<HTMLElementImpl*>(i);
1373         
1374         if (i->id() == ID_BODY)
1375             body = i;
1376     }
1377     return static_cast<HTMLElementImpl *>(body);
1378 }
1379
1380 void DocumentImpl::close()
1381 {
1382     if (part())
1383         part()->endIfNotLoading();
1384     implicitClose();
1385 }
1386
1387 void DocumentImpl::implicitClose()
1388 {
1389     // First fire the onload.
1390     
1391     bool wasLocationChangePending = part() && part()->isScheduledLocationChangePending();
1392     bool doload = !parsing() && m_tokenizer && !m_processingLoadEvent && !wasLocationChangePending;
1393     
1394     if (doload) {
1395         m_processingLoadEvent = true;
1396
1397         // We have to clear the tokenizer, in case someone document.write()s from the
1398         // onLoad event handler, as in Radar 3206524
1399         delete m_tokenizer;
1400         m_tokenizer = 0;
1401
1402         // Create a body element if we don't already have one.
1403         // In the case of Radar 3758785, the window.onload was set in some javascript, but never fired because there was no body.  
1404         // This behavior now matches Firefox and IE.
1405         HTMLElementImpl *body = this->body();
1406         if (!body && isHTMLDocument()) {
1407             NodeImpl *de = documentElement();
1408             if (de) {
1409                 body = new HTMLBodyElementImpl(docPtr());
1410                 int exceptionCode = 0;
1411                 de->appendChild(body, exceptionCode);
1412                 if (exceptionCode != 0)
1413                     body = 0;
1414             }
1415         }
1416
1417         if (body) {
1418             dispatchImageLoadEventsNow();
1419             body->dispatchWindowEvent(EventImpl::LOAD_EVENT, false, false);
1420
1421 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1422             if (!ownerElement())
1423                 printf("onload fired at %d\n", elapsedTime());
1424 #endif
1425         }
1426
1427         m_processingLoadEvent = false;
1428     }
1429     
1430     // Make sure both the initial layout and reflow happen after the onload
1431     // fires. This will improve onload scores, and other browsers do it.
1432     // If they wanna cheat, we can too. -dwh
1433     
1434     bool isLocationChangePending = part() && part()->isScheduledLocationChangePending();
1435     
1436     if (doload && isLocationChangePending && m_startTime.elapsed() < cLayoutScheduleThreshold) {
1437         // Just bail out. Before or during the onload we were shifted to another page.
1438         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
1439         delete m_tokenizer;
1440         m_tokenizer = 0;
1441         view()->unscheduleRelayout();
1442         return;
1443     }
1444     
1445     if (doload) {
1446         // on an explicit document.close(), the tokenizer might still be waiting on scripts,
1447         // and in that case we don't want to destroy it because that will prevent the
1448         // scripts from getting processed.
1449         // FIXME: this check may no longer be necessary, since now it should be impossible
1450         // for parsing to be false while stil waiting for scripts
1451         if (m_tokenizer && !m_tokenizer->isWaitingForScripts()) {
1452             delete m_tokenizer;
1453             m_tokenizer = 0;
1454         }
1455
1456         if (m_view)
1457             m_view->part()->checkEmitLoadEvent();
1458     }
1459
1460     // Now do our painting/layout, but only if we aren't in a subframe or if we're in a subframe
1461     // that has been sized already.  Otherwise, our view size would be incorrect, so doing any 
1462     // layout/painting now would be pointless.
1463     if (doload) {
1464         if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
1465             updateRendering();
1466             
1467             // Always do a layout after loading if needed.
1468             if (view() && renderer() && (!renderer()->firstChild() || renderer()->needsLayout()))
1469                 view()->layout();
1470         }
1471 #if APPLE_CHANGES
1472         if (renderer() && KWQAccObjectCache::accessibilityEnabled())
1473             getAccObjectCache()->postNotification(renderer(), "AXLoadComplete");
1474 #endif
1475     }
1476 }
1477
1478 void DocumentImpl::setParsing(bool b)
1479 {
1480     m_bParsing = b;
1481     if (!m_bParsing && view())
1482         view()->scheduleRelayout();
1483
1484 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1485     if (!ownerElement() && !m_bParsing)
1486         printf("Parsing finished at %d\n", elapsedTime());
1487 #endif
1488 }
1489
1490 bool DocumentImpl::shouldScheduleLayout()
1491 {
1492     // We can update layout if:
1493     // (a) we actually need a layout
1494     // (b) our stylesheets are all loaded
1495     // (c) we have a <body>
1496     return (renderer() && renderer()->needsLayout() && haveStylesheetsLoaded() &&
1497             documentElement() && documentElement()->renderer() &&
1498             (documentElement()->id() != ID_HTML || body()));
1499 }
1500
1501 int DocumentImpl::minimumLayoutDelay()
1502 {
1503     if (m_overMinimumLayoutThreshold)
1504         return 0;
1505     
1506     int elapsed = m_startTime.elapsed();
1507     m_overMinimumLayoutThreshold = elapsed > cLayoutScheduleThreshold;
1508     
1509     // We'll want to schedule the timer to fire at the minimum layout threshold.
1510     return kMax(0, cLayoutScheduleThreshold - elapsed);
1511 }
1512
1513 int DocumentImpl::elapsedTime() const
1514 {
1515     return m_startTime.elapsed();
1516 }
1517
1518 void DocumentImpl::write( const DOMString &text )
1519 {
1520     write(text.string());
1521 }
1522
1523 void DocumentImpl::write( const QString &text )
1524 {
1525 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1526     if (!ownerElement())
1527         printf("Beginning a document.write at %d\n", elapsedTime());
1528 #endif
1529     
1530     if (!m_tokenizer) {
1531         open();
1532         write(QString::fromLatin1("<html>"));
1533     }
1534     m_tokenizer->write(text, false);
1535
1536     if (m_view && m_view->part()->jScript())
1537         m_view->part()->jScript()->appendSourceFile(m_url,text);
1538     
1539 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1540     if (!ownerElement())
1541         printf("Ending a document.write at %d\n", elapsedTime());
1542 #endif    
1543 }
1544
1545 void DocumentImpl::writeln( const DOMString &text )
1546 {
1547     write(text);
1548     write(DOMString("\n"));
1549 }
1550
1551 void DocumentImpl::finishParsing()
1552 {
1553 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1554     if (!ownerElement())
1555         printf("Received all data at %d\n", elapsedTime());
1556 #endif
1557     
1558     // Let the tokenizer go through as much data as it can.  There will be three possible outcomes after
1559     // finish() is called:
1560     // (1) All remaining data is parsed, document isn't loaded yet
1561     // (2) All remaining data is parsed, document is loaded, tokenizer gets deleted
1562     // (3) Data is still remaining to be parsed.
1563     if (m_tokenizer)
1564         m_tokenizer->finish();
1565 }
1566
1567 void DocumentImpl::clear()
1568 {
1569     delete m_tokenizer;
1570     m_tokenizer = 0;
1571
1572     removeChildren();
1573     QPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
1574     for (; it.current();)
1575         m_windowEventListeners.removeRef(it.current());
1576 }
1577
1578 void DocumentImpl::setURL(const QString& url)
1579 {
1580     m_url = url;
1581     if (m_styleSelector)
1582         m_styleSelector->setEncodedURL(m_url);
1583 }
1584
1585 void DocumentImpl::setStyleSheet(const DOMString &url, const DOMString &sheet)
1586 {
1587 //    kdDebug( 6030 ) << "HTMLDocument::setStyleSheet()" << endl;
1588     m_sheet = new CSSStyleSheetImpl(this, url);
1589     m_sheet->ref();
1590     m_sheet->parseString(sheet);
1591     m_loadingSheet = false;
1592
1593     updateStyleSelector();
1594 }
1595
1596 void DocumentImpl::setUserStyleSheet( const QString& sheet )
1597 {
1598     if ( m_usersheet != sheet ) {
1599         m_usersheet = sheet;
1600         updateStyleSelector();
1601     }
1602 }
1603
1604 CSSStyleSheetImpl* DocumentImpl::elementSheet()
1605 {
1606     if (!m_elemSheet) {
1607         m_elemSheet = new CSSStyleSheetImpl(this, baseURL() );
1608         m_elemSheet->ref();
1609     }
1610     return m_elemSheet;
1611 }
1612
1613 void DocumentImpl::determineParseMode( const QString &/*str*/ )
1614 {
1615     // For XML documents use strict parse mode.  HTML docs will override this method to
1616     // determine their parse mode.
1617     pMode = Strict;
1618     hMode = XHtml;
1619     kdDebug(6020) << " using strict parseMode" << endl;
1620 }
1621
1622 // Please see if there`s a possibility to merge that code
1623 // with the next function and getElementByID().
1624 NodeImpl *DocumentImpl::findElement( Id id )
1625 {
1626     QPtrStack<NodeImpl> nodeStack;
1627     NodeImpl *current = _first;
1628
1629     while(1)
1630     {
1631         if(!current)
1632         {
1633             if(nodeStack.isEmpty()) break;
1634             current = nodeStack.pop();
1635             current = current->nextSibling();
1636         }
1637         else
1638         {
1639             if(current->id() == id)
1640                 return current;
1641
1642             NodeImpl *child = current->firstChild();
1643             if(child)
1644             {
1645                 nodeStack.push(current);
1646                 current = child;
1647             }
1648             else
1649             {
1650                 current = current->nextSibling();
1651             }
1652         }
1653     }
1654
1655     return 0;
1656 }
1657
1658 NodeImpl *DocumentImpl::nextFocusNode(NodeImpl *fromNode)
1659 {
1660     unsigned short fromTabIndex;
1661
1662     if (!fromNode) {
1663         // No starting node supplied; begin with the top of the document
1664         NodeImpl *n;
1665
1666         int lowestTabIndex = 65535;
1667         for (n = this; n != 0; n = n->traverseNextNode()) {
1668             if (n->isKeyboardFocusable()) {
1669                 if ((n->tabIndex() > 0) && (n->tabIndex() < lowestTabIndex))
1670                     lowestTabIndex = n->tabIndex();
1671             }
1672         }
1673
1674         if (lowestTabIndex == 65535)
1675             lowestTabIndex = 0;
1676
1677         // Go to the first node in the document that has the desired tab index
1678         for (n = this; n != 0; n = n->traverseNextNode()) {
1679             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestTabIndex))
1680                 return n;
1681         }
1682
1683         return 0;
1684     }
1685     else {
1686         fromTabIndex = fromNode->tabIndex();
1687     }
1688
1689     if (fromTabIndex == 0) {
1690         // Just need to find the next selectable node after fromNode (in document order) that doesn't have a tab index
1691         NodeImpl *n = fromNode->traverseNextNode();
1692         while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1693             n = n->traverseNextNode();
1694         return n;
1695     }
1696     else {
1697         // Find the lowest tab index out of all the nodes except fromNode, that is greater than or equal to fromNode's
1698         // tab index. For nodes with the same tab index as fromNode, we are only interested in those that come after
1699         // fromNode in document order.
1700         // If we don't find a suitable tab index, the next focus node will be one with a tab index of 0.
1701         unsigned short lowestSuitableTabIndex = 65535;
1702         NodeImpl *n;
1703
1704         bool reachedFromNode = false;
1705         for (n = this; n != 0; n = n->traverseNextNode()) {
1706             if (n->isKeyboardFocusable() &&
1707                 ((reachedFromNode && (n->tabIndex() >= fromTabIndex)) ||
1708                  (!reachedFromNode && (n->tabIndex() > fromTabIndex))) &&
1709                 (n->tabIndex() < lowestSuitableTabIndex) &&
1710                 (n != fromNode)) {
1711
1712                 // We found a selectable node with a tab index at least as high as fromNode's. Keep searching though,
1713                 // as there may be another node which has a lower tab index but is still suitable for use.
1714                 lowestSuitableTabIndex = n->tabIndex();
1715             }
1716
1717             if (n == fromNode)
1718                 reachedFromNode = true;
1719         }
1720
1721         if (lowestSuitableTabIndex == 65535) {
1722             // No next node with a tab index -> just take first node with tab index of 0
1723             NodeImpl *n = this;
1724             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1725                 n = n->traverseNextNode();
1726             return n;
1727         }
1728
1729         // Search forwards from fromNode
1730         for (n = fromNode->traverseNextNode(); n != 0; n = n->traverseNextNode()) {
1731             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1732                 return n;
1733         }
1734
1735         // The next node isn't after fromNode, start from the beginning of the document
1736         for (n = this; n != fromNode; n = n->traverseNextNode()) {
1737             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1738                 return n;
1739         }
1740
1741         assert(false); // should never get here
1742         return 0;
1743     }
1744 }
1745
1746 NodeImpl *DocumentImpl::previousFocusNode(NodeImpl *fromNode)
1747 {
1748     NodeImpl *lastNode = this;
1749     while (lastNode->lastChild())
1750         lastNode = lastNode->lastChild();
1751
1752     if (!fromNode) {
1753         // No starting node supplied; begin with the very last node in the document
1754         NodeImpl *n;
1755
1756         int highestTabIndex = 0;
1757         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1758             if (n->isKeyboardFocusable()) {
1759                 if (n->tabIndex() == 0)
1760                     return n;
1761                 else if (n->tabIndex() > highestTabIndex)
1762                     highestTabIndex = n->tabIndex();
1763             }
1764         }
1765
1766         // No node with a tab index of 0; just go to the last node with the highest tab index
1767         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1768             if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1769                 return n;
1770         }
1771
1772         return 0;
1773     }
1774     else {
1775         unsigned short fromTabIndex = fromNode->tabIndex();
1776
1777         if (fromTabIndex == 0) {
1778             // Find the previous selectable node before fromNode (in document order) that doesn't have a tab index
1779             NodeImpl *n = fromNode->traversePreviousNode();
1780             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1781                 n = n->traversePreviousNode();
1782             if (n)
1783                 return n;
1784
1785             // No previous nodes with a 0 tab index, go to the last node in the document that has the highest tab index
1786             int highestTabIndex = 0;
1787             for (n = this; n != 0; n = n->traverseNextNode()) {
1788                 if (n->isKeyboardFocusable() && (n->tabIndex() > highestTabIndex))
1789                     highestTabIndex = n->tabIndex();
1790             }
1791
1792             if (highestTabIndex == 0)
1793                 return 0;
1794
1795             for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1796                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1797                     return n;
1798             }
1799
1800             assert(false); // should never get here
1801             return 0;
1802         }
1803         else {
1804             // Find the lowest tab index out of all the nodes except fromNode, that is less than or equal to fromNode's
1805             // tab index. For nodes with the same tab index as fromNode, we are only interested in those before
1806             // fromNode.
1807             // If we don't find a suitable tab index, then there will be no previous focus node.
1808             unsigned short highestSuitableTabIndex = 0;
1809             NodeImpl *n;
1810
1811             bool reachedFromNode = false;
1812             for (n = this; n != 0; n = n->traverseNextNode()) {
1813                 if (n->isKeyboardFocusable() &&
1814                     ((!reachedFromNode && (n->tabIndex() <= fromTabIndex)) ||
1815                      (reachedFromNode && (n->tabIndex() < fromTabIndex)))  &&
1816                     (n->tabIndex() > highestSuitableTabIndex) &&
1817                     (n != fromNode)) {
1818
1819                     // We found a selectable node with a tab index no higher than fromNode's. Keep searching though, as
1820                     // there may be another node which has a higher tab index but is still suitable for use.
1821                     highestSuitableTabIndex = n->tabIndex();
1822                 }
1823
1824                 if (n == fromNode)
1825                     reachedFromNode = true;
1826             }
1827
1828             if (highestSuitableTabIndex == 0) {
1829                 // No previous node with a tab index. Since the order specified by HTML is nodes with tab index > 0
1830                 // first, this means that there is no previous node.
1831                 return 0;
1832             }
1833
1834             // Search backwards from fromNode
1835             for (n = fromNode->traversePreviousNode(); n != 0; n = n->traversePreviousNode()) {
1836                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1837                     return n;
1838             }
1839             // The previous node isn't before fromNode, start from the end of the document
1840             for (n = lastNode; n != fromNode; n = n->traversePreviousNode()) {
1841                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1842                     return n;
1843             }
1844
1845             assert(false); // should never get here
1846             return 0;
1847         }
1848     }
1849 }
1850
1851 int DocumentImpl::nodeAbsIndex(NodeImpl *node)
1852 {
1853     assert(node->getDocument() == this);
1854
1855     int absIndex = 0;
1856     for (NodeImpl *n = node; n && n != this; n = n->traversePreviousNode())
1857         absIndex++;
1858     return absIndex;
1859 }
1860
1861 NodeImpl *DocumentImpl::nodeWithAbsIndex(int absIndex)
1862 {
1863     NodeImpl *n = this;
1864     for (int i = 0; n && (i < absIndex); i++) {
1865         n = n->traverseNextNode();
1866     }
1867     return n;
1868 }
1869
1870 void DocumentImpl::processHttpEquiv(const DOMString &equiv, const DOMString &content)
1871 {
1872     assert(!equiv.isNull() && !content.isNull());
1873
1874     KHTMLPart *part = getDocument()->part();
1875
1876     if (strcasecmp(equiv, "default-style") == 0) {
1877         // The preferred style set has been overridden as per section 
1878         // 14.3.2 of the HTML4.0 specification.  We need to update the
1879         // sheet used variable and then update our style selector. 
1880         // For more info, see the test at:
1881         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
1882         // -dwh
1883         part->d->m_sheetUsed = content.string();
1884         m_preferredStylesheetSet = content;
1885         updateStyleSelector();
1886     }
1887     else if(strcasecmp(equiv, "refresh") == 0 && part->metaRefreshEnabled())
1888     {
1889         // get delay and url
1890         QString str = content.string().stripWhiteSpace();
1891         int pos = str.find(QRegExp("[;,]"));
1892         if ( pos == -1 )
1893             pos = str.find(QRegExp("[ \t]"));
1894
1895         if (pos == -1) // There can be no url (David)
1896         {
1897             bool ok = false;
1898             int delay = 0;
1899             delay = str.toInt(&ok);
1900 #if APPLE_CHANGES
1901             // We want a new history item if the refresh timeout > 1 second
1902             if(ok && part) part->scheduleRedirection(delay, part->url().url(), delay <= 1);
1903 #else
1904             if(ok && part) part->scheduleRedirection(delay, part->url().url() );
1905 #endif
1906         } else {
1907             double delay = 0;
1908             bool ok = false;
1909             delay = str.left(pos).stripWhiteSpace().toDouble(&ok);
1910
1911             pos++;
1912             while(pos < (int)str.length() && str[pos].isSpace()) pos++;
1913             str = str.mid(pos);
1914             if(str.find("url", 0,  false ) == 0)  str = str.mid(3);
1915             str = str.stripWhiteSpace();
1916             if ( str.length() && str[0] == '=' ) str = str.mid( 1 ).stripWhiteSpace();
1917             str = parseURL( DOMString(str) ).string();
1918             if ( ok && part )
1919 #if APPLE_CHANGES
1920                 // We want a new history item if the refresh timeout > 1 second
1921                 part->scheduleRedirection(delay, getDocument()->completeURL( str ), delay <= 1);
1922 #else
1923                 part->scheduleRedirection(delay, getDocument()->completeURL( str ));
1924 #endif
1925         }
1926     }
1927     else if(strcasecmp(equiv, "expires") == 0)
1928     {
1929         QString str = content.string().stripWhiteSpace();
1930         time_t expire_date = str.toLong();
1931         if (m_docLoader)
1932             m_docLoader->setExpireDate(expire_date);
1933     }
1934     else if(strcasecmp(equiv, "pragma") == 0 || strcasecmp(equiv, "cache-control") == 0 && part)
1935     {
1936         QString str = content.string().lower().stripWhiteSpace();
1937         KURL url = part->url();
1938         if ((str == "no-cache") && url.protocol().startsWith("http"))
1939         {
1940            KIO::http_update_cache(url, true, 0);
1941         }
1942     }
1943     else if( (strcasecmp(equiv, "set-cookie") == 0))
1944     {
1945         // ### make setCookie work on XML documents too; e.g. in case of <html:meta .....>
1946         HTMLDocumentImpl *d = static_cast<HTMLDocumentImpl *>(this);
1947         d->setCookie(content);
1948     }
1949 }
1950
1951 bool DocumentImpl::prepareMouseEvent( bool readonly, int _x, int _y, MouseEvent *ev )
1952 {
1953     if ( m_render ) {
1954         assert(m_render->isCanvas());
1955         RenderObject::NodeInfo renderInfo(readonly, ev->type == MousePress);
1956         bool isInside = m_render->layer()->hitTest(renderInfo, _x, _y);
1957         ev->innerNode = renderInfo.innerNode();
1958
1959         if (renderInfo.URLElement()) {
1960             assert(renderInfo.URLElement()->isElementNode());
1961             ElementImpl* e =  static_cast<ElementImpl*>(renderInfo.URLElement());
1962             DOMString href = khtml::parseURL(e->getAttribute(ATTR_HREF));
1963             DOMString target = e->getAttribute(ATTR_TARGET);
1964
1965             if (!target.isNull() && !href.isNull()) {
1966                 ev->target = target;
1967                 ev->url = href;
1968             }
1969             else
1970                 ev->url = href;
1971 //            qDebug("url: *%s*", ev->url.string().latin1());
1972         }
1973
1974         if (!readonly)
1975             updateRendering();
1976
1977         return isInside;
1978     }
1979
1980
1981     return false;
1982 }
1983
1984 // DOM Section 1.1.1
1985 bool DocumentImpl::childAllowed( NodeImpl *newChild )
1986 {
1987     // Documents may contain a maximum of one Element child
1988     if (newChild->nodeType() == Node::ELEMENT_NODE) {
1989         NodeImpl *c;
1990         for (c = firstChild(); c; c = c->nextSibling()) {
1991             if (c->nodeType() == Node::ELEMENT_NODE)
1992                 return false;
1993         }
1994     }
1995
1996     // Documents may contain a maximum of one DocumentType child
1997     if (newChild->nodeType() == Node::DOCUMENT_TYPE_NODE) {
1998         NodeImpl *c;
1999         for (c = firstChild(); c; c = c->nextSibling()) {
2000             if (c->nodeType() == Node::DOCUMENT_TYPE_NODE)
2001                 return false;
2002         }
2003     }
2004
2005     return childTypeAllowed(newChild->nodeType());
2006 }
2007
2008 bool DocumentImpl::childTypeAllowed( unsigned short type )
2009 {
2010     switch (type) {
2011         case Node::ELEMENT_NODE:
2012         case Node::PROCESSING_INSTRUCTION_NODE:
2013         case Node::COMMENT_NODE:
2014         case Node::DOCUMENT_TYPE_NODE:
2015             return true;
2016         default:
2017             return false;
2018     }
2019 }
2020
2021 NodeImpl *DocumentImpl::cloneNode ( bool /*deep*/ )
2022 {
2023     // Spec says cloning Document nodes is "implementation dependent"
2024     // so we do not support it...
2025     return 0;
2026 }
2027
2028 NodeImpl::Id DocumentImpl::attrId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly)
2029 {
2030     // Each document maintains a mapping of attrname -> id for every attr name
2031     // encountered in the document.
2032     // For attrnames without a prefix (no qualified element name) and without matching
2033     // namespace, the value defined in misc/htmlattrs.h is used.
2034     NodeImpl::Id id = 0;
2035
2036     // First see if it's a HTML attribute name
2037     QConstString n(_name->s, _name->l);
2038     if (!_namespaceURI || !strcasecmp(_namespaceURI, XHTML_NAMESPACE)) {
2039         // we're in HTML namespace if we know the tag.
2040         // xhtml is lower case - case sensitive, easy to implement
2041         if ( htmlMode() == XHtml && (id = getAttrID(n.string().ascii(), _name->l)) )
2042             return id;
2043         // compatibility: upper case - case insensitive
2044         if ( htmlMode() != XHtml && (id = getAttrID(n.string().lower().ascii(), _name->l )) )
2045             return id;
2046
2047         // ok, the fast path didn't work out, we need the full check
2048     }
2049
2050     // now lets find out the namespace
2051     Q_UINT16 ns = noNamespace;
2052     if (_namespaceURI) {
2053         DOMString nsU(_namespaceURI);
2054         int nsID = XmlNamespaceTable::getNamespaceID(nsU, readonly);
2055         if (nsID != -1)
2056             ns = (Q_UINT16)nsID;
2057     }
2058     
2059     // Look in the m_attrNames array for the name
2060     // ### yeah, this is lame. use a dictionary / map instead
2061     DOMString nme(n.string());
2062     // compatibility mode has to store upper case
2063     if (htmlMode() != XHtml) nme = nme.upper();
2064     for (id = 0; id < m_attrNameCount; id++)
2065         if (DOMString(m_attrNames[id]) == nme)
2066             return makeId(ns, ATTR_LAST_ATTR+id);
2067
2068     // unknown
2069     if (readonly) return 0;
2070
2071     // Name not found in m_attrNames, so let's add it
2072     // ### yeah, this is lame. use a dictionary / map instead
2073     if (m_attrNameCount+1 > m_attrNameAlloc) {
2074         m_attrNameAlloc += 100;
2075         DOMStringImpl **newNames = new DOMStringImpl* [m_attrNameAlloc];
2076         if (m_attrNames) {
2077             unsigned short i;
2078             for (i = 0; i < m_attrNameCount; i++)
2079                 newNames[i] = m_attrNames[i];
2080             delete [] m_attrNames;
2081         }
2082         m_attrNames = newNames;
2083     }
2084
2085     id = m_attrNameCount++;
2086     m_attrNames[id] = nme.implementation();
2087     m_attrNames[id]->ref();
2088
2089     return makeId(ns, ATTR_LAST_ATTR+id);
2090 }
2091
2092 DOMString DocumentImpl::attrName(NodeImpl::Id _id) const
2093 {
2094     DOMString result;
2095     if (localNamePart(_id) >= ATTR_LAST_ATTR)
2096         result = m_attrNames[localNamePart(_id)-ATTR_LAST_ATTR];
2097     else
2098         result = getAttrName(_id);
2099
2100     // Attribute names are always lowercase in the DOM for both
2101     // HTML and XHTML.
2102     if (getDocument()->isHTMLDocument() ||
2103         getDocument()->htmlMode() == DocumentImpl::XHtml)
2104         return result.lower();
2105
2106     return result;
2107 }
2108
2109 NodeImpl::Id DocumentImpl::tagId(DOMStringImpl* _namespaceURI, DOMStringImpl *_name, bool readonly)
2110 {
2111     if (!_name) return 0;
2112     // Each document maintains a mapping of tag name -> id for every tag name encountered
2113     // in the document.
2114     NodeImpl::Id id = 0;
2115
2116     // First see if it's a HTML element name
2117     QConstString n(_name->s, _name->l);
2118     if (!_namespaceURI || !strcasecmp(_namespaceURI, XHTML_NAMESPACE)) {
2119         // we're in HTML namespace if we know the tag.
2120         // xhtml is lower case - case sensitive, easy to implement
2121         if ( htmlMode() == XHtml && (id = getTagID(n.string().ascii(), _name->l)) )
2122             return id;
2123         // compatibility: upper case - case insensitive
2124         if ( htmlMode() != XHtml && (id = getTagID(n.string().lower().ascii(), _name->l )) )
2125             return id;
2126
2127         // ok, the fast path didn't work out, we need the full check
2128     }
2129
2130     // now lets find out the namespace
2131     Q_UINT16 ns = noNamespace;
2132     if (_namespaceURI) {
2133         DOMString nsU(_namespaceURI);
2134         int nsID = XmlNamespaceTable::getNamespaceID(nsU, readonly);
2135         if (nsID != -1)
2136             ns = (Q_UINT16)nsID;
2137     }
2138
2139     // Look in the m_elementNames array for the name
2140     // ### yeah, this is lame. use a dictionary / map instead
2141     DOMString nme(n.string());
2142     // compatibility mode has to store upper case
2143     if (htmlMode() != XHtml) nme = nme.upper();
2144     for (id = 0; id < m_elementNameCount; id++)
2145         if (DOMString(m_elementNames[id]) == nme)
2146             return makeId(ns, ID_LAST_TAG + 1 + id);
2147
2148     // unknown
2149     if (readonly) return 0;
2150
2151     // Name not found in m_elementNames, so let's add it
2152     if (m_elementNameCount+1 > m_elementNameAlloc) {
2153         m_elementNameAlloc += 100;
2154         DOMStringImpl **newNames = new DOMStringImpl* [m_elementNameAlloc];
2155         // ### yeah, this is lame. use a dictionary / map instead
2156         if (m_elementNames) {
2157             unsigned short i;
2158             for (i = 0; i < m_elementNameCount; i++)
2159                 newNames[i] = m_elementNames[i];
2160             delete [] m_elementNames;
2161         }
2162         m_elementNames = newNames;
2163     }
2164
2165     id = m_elementNameCount++;
2166     m_elementNames[id] = nme.implementation();
2167     m_elementNames[id]->ref();
2168
2169     return makeId(ns, ID_LAST_TAG + 1 + id);
2170 }
2171
2172 DOMString DocumentImpl::tagName(NodeImpl::Id _id) const
2173 {
2174     if (localNamePart(_id) > ID_LAST_TAG)
2175         return m_elementNames[localNamePart(_id) - (ID_LAST_TAG + 1)];
2176     else {
2177         // ### put them in a cache
2178         if (getDocument()->htmlMode() == DocumentImpl::XHtml)
2179             return getTagName(_id).lower();
2180         else
2181             return getTagName(_id);
2182     }
2183 }
2184
2185
2186 DOMStringImpl* DocumentImpl::namespaceURI(NodeImpl::Id _id) const
2187 {
2188     if (_id <= ID_LAST_TAG)
2189         return htmlMode() == XHtml ? XmlNamespaceTable::getNamespaceURI(xhtmlNamespace).implementation() : 0;
2190
2191     unsigned short ns = _id >> 16;
2192
2193     if (!ns) return 0;
2194
2195     return XmlNamespaceTable::getNamespaceURI(ns).implementation();
2196 }
2197
2198 StyleSheetListImpl* DocumentImpl::styleSheets()
2199 {
2200     return m_styleSheets;
2201 }
2202
2203 DOMString 
2204 DocumentImpl::preferredStylesheetSet()
2205 {
2206   return m_preferredStylesheetSet;
2207 }
2208
2209 DOMString 
2210 DocumentImpl::selectedStylesheetSet()
2211 {
2212   return view() ? view()->part()->d->m_sheetUsed : DOMString();
2213 }
2214
2215 void 
2216 DocumentImpl::setSelectedStylesheetSet(const DOMString& aString)
2217 {
2218   if (view()) {
2219     view()->part()->d->m_sheetUsed = aString.string();
2220     updateStyleSelector();
2221     if (renderer())
2222       renderer()->repaint();
2223   }
2224 }
2225
2226 // This method is called whenever a top-level stylesheet has finished loading.
2227 void DocumentImpl::stylesheetLoaded()
2228 {
2229   // Make sure we knew this sheet was pending, and that our count isn't out of sync.
2230   assert(m_pendingStylesheets > 0);
2231
2232   m_pendingStylesheets--;
2233   
2234 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2235   if (!ownerElement())
2236       printf("Stylesheet loaded at time %d. %d stylesheets still remain.\n", elapsedTime(), m_pendingStylesheets);
2237 #endif
2238
2239   updateStyleSelector();    
2240 }
2241
2242 void DocumentImpl::updateStyleSelector()
2243 {
2244     // Don't bother updating, since we haven't loaded all our style info yet.
2245     if (!haveStylesheetsLoaded())
2246         return;
2247
2248 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2249     if (!ownerElement())
2250         printf("Beginning update of style selector at time %d.\n", elapsedTime());
2251 #endif
2252
2253     recalcStyleSelector();
2254     recalcStyle(Force);
2255 #if 0
2256
2257     m_styleSelectorDirty = true;
2258 #endif
2259
2260 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2261     if (!ownerElement())
2262         printf("Finished update of style selector at time %d\n", elapsedTime());
2263 #endif
2264
2265     if (renderer()) {
2266         renderer()->setNeedsLayoutAndMinMaxRecalc();
2267         if (view())
2268             view()->scheduleRelayout();
2269     }
2270 }
2271
2272
2273 QStringList DocumentImpl::availableStyleSheets() const
2274 {
2275     return m_availableSheets;
2276 }
2277
2278 void DocumentImpl::recalcStyleSelector()
2279 {
2280     if ( !m_render || !attached() ) return;
2281
2282     QPtrList<StyleSheetImpl> oldStyleSheets = m_styleSheets->styleSheets;
2283     m_styleSheets->styleSheets.clear();
2284     m_availableSheets.clear();
2285     NodeImpl *n;
2286     for (n = this; n; n = n->traverseNextNode()) {
2287         StyleSheetImpl *sheet = 0;
2288
2289         if (n->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
2290         {
2291             // Processing instruction (XML documents only)
2292             ProcessingInstructionImpl* pi = static_cast<ProcessingInstructionImpl*>(n);
2293             sheet = pi->sheet();
2294 #ifdef KHTML_XSLT
2295             if (pi->isXSL()) {
2296                 applyXSLTransform(pi);
2297                 return;
2298             }
2299 #endif
2300             if (!sheet && !pi->localHref().isEmpty())
2301             {
2302                 // Processing instruction with reference to an element in this document - e.g.
2303                 // <?xml-stylesheet href="#mystyle">, with the element
2304                 // <foo id="mystyle">heading { color: red; }</foo> at some location in
2305                 // the document
2306                 ElementImpl* elem = getElementById(pi->localHref());
2307                 if (elem) {
2308                     DOMString sheetText("");
2309                     NodeImpl *c;
2310                     for (c = elem->firstChild(); c; c = c->nextSibling()) {
2311                         if (c->nodeType() == Node::TEXT_NODE || c->nodeType() == Node::CDATA_SECTION_NODE)
2312                             sheetText += c->nodeValue();
2313                     }
2314
2315                     CSSStyleSheetImpl *cssSheet = new CSSStyleSheetImpl(this);
2316                     cssSheet->parseString(sheetText);
2317                     pi->setStyleSheet(cssSheet);
2318                     sheet = cssSheet;
2319                 }
2320             }
2321
2322         }
2323         else if (n->isHTMLElement() && (n->id() == ID_LINK || n->id() == ID_STYLE)) {
2324             ElementImpl *e = static_cast<ElementImpl *>(n);
2325             QString title = e->getAttribute( ATTR_TITLE ).string();
2326             bool enabledViaScript = false;
2327             if (n->id() == ID_LINK) {
2328                 // <LINK> element
2329                 HTMLLinkElementImpl* l = static_cast<HTMLLinkElementImpl*>(n);
2330                 if (l->isLoading() || l->isDisabled())
2331                     continue;
2332                 if (!l->sheet())
2333                     title = QString::null;
2334                 enabledViaScript = l->isEnabledViaScript();
2335             }
2336
2337             // Get the current preferred styleset.  This is the
2338             // set of sheets that will be enabled.
2339             if ( n->id() == ID_LINK )
2340                 sheet = static_cast<HTMLLinkElementImpl*>(n)->sheet();
2341             else
2342                 // <STYLE> element
2343                 sheet = static_cast<HTMLStyleElementImpl*>(n)->sheet();
2344
2345             // Check to see if this sheet belongs to a styleset
2346             // (thus making it PREFERRED or ALTERNATE rather than
2347             // PERSISTENT).
2348             if (!enabledViaScript && !title.isEmpty()) {
2349                 // Yes, we have a title.
2350                 if (m_preferredStylesheetSet.isEmpty()) {
2351                     // No preferred set has been established.  If
2352                     // we are NOT an alternate sheet, then establish
2353                     // us as the preferred set.  Otherwise, just ignore
2354                     // this sheet.
2355                     QString rel = e->getAttribute( ATTR_REL ).string();
2356                     if (n->id() == ID_STYLE || !rel.contains("alternate"))
2357                         m_preferredStylesheetSet = view()->part()->d->m_sheetUsed = title;
2358                 }
2359                       
2360                 if (!m_availableSheets.contains( title ) )
2361                     m_availableSheets.append( title );
2362                 
2363                 if (title != m_preferredStylesheetSet)
2364                     sheet = 0;
2365             }
2366         }
2367
2368         if (sheet) {
2369             sheet->ref();
2370             m_styleSheets->styleSheets.append(sheet);
2371         }
2372     
2373         // For HTML documents, stylesheets are not allowed within/after the <BODY> tag. So we
2374         // can stop searching here.
2375         if (isHTMLDocument() && n->id() == ID_BODY)
2376             break;
2377     }
2378
2379     // De-reference all the stylesheets in the old list
2380     QPtrListIterator<StyleSheetImpl> it(oldStyleSheets);
2381     for (; it.current(); ++it)
2382         it.current()->deref();
2383
2384     // Create a new style selector
2385     delete m_styleSelector;
2386     QString usersheet = m_usersheet;
2387     if ( m_view && m_view->mediaType() == "print" )
2388         usersheet += m_printSheet;
2389     m_styleSelector = new CSSStyleSelector(this, usersheet, m_styleSheets, !inCompatMode());
2390     m_styleSelector->setEncodedURL(m_url);
2391     m_styleSelectorDirty = false;
2392 }
2393
2394 void DocumentImpl::setHoverNode(NodeImpl* newHoverNode)
2395 {
2396     if (m_hoverNode != newHoverNode) {
2397         if (m_hoverNode)
2398             m_hoverNode->deref();
2399         m_hoverNode = newHoverNode;
2400         if (m_hoverNode)
2401             m_hoverNode->ref();
2402     }    
2403 }
2404
2405 #if APPLE_CHANGES
2406
2407 bool DocumentImpl::relinquishesEditingFocus(NodeImpl *node)
2408 {
2409     assert(node);
2410     assert(node->isContentEditable());
2411
2412     NodeImpl *rootImpl = node->rootEditableElement();
2413     if (!part() || !rootImpl)
2414         return false;
2415
2416     Node root(rootImpl);
2417     Range range(root, 0, root, rootImpl->childNodeCount());
2418     return part()->shouldEndEditing(range);
2419 }
2420
2421 bool DocumentImpl::acceptsEditingFocus(NodeImpl *node)
2422 {
2423     assert(node);
2424     assert(node->isContentEditable());
2425
2426     NodeImpl *rootImpl = node->rootEditableElement();
2427     if (!part() || !rootImpl)
2428         return false;
2429
2430     Node root(rootImpl);
2431     Range range(root, 0, root, rootImpl->childNodeCount());
2432     return part()->shouldBeginEditing(range);
2433 }
2434
2435 const QValueList<DashboardRegionValue> & DocumentImpl::dashboardRegions() const
2436 {
2437     return m_dashboardRegions;
2438 }
2439
2440 void DocumentImpl::setDashboardRegions (const QValueList<DashboardRegionValue>& regions)
2441 {
2442     m_dashboardRegions = regions;
2443     setDashboardRegionsDirty (false);
2444 }
2445
2446 #endif
2447
2448 bool DocumentImpl::setFocusNode(NodeImpl *newFocusNode)
2449 {    
2450     // Make sure newFocusNode is actually in this document
2451     if (newFocusNode && (newFocusNode->getDocument() != this))
2452         return true;
2453
2454     if (m_focusNode == newFocusNode)
2455         return true;
2456
2457 #if APPLE_CHANGES
2458     if (m_focusNode && m_focusNode->isContentEditable() && !relinquishesEditingFocus(m_focusNode))
2459         return false;
2460 #endif     
2461        
2462     bool focusChangeBlocked = false;
2463     NodeImpl *oldFocusNode = m_focusNode;
2464     m_focusNode = 0;
2465
2466     // Remove focus from the existing focus node (if any)
2467     if (oldFocusNode) {
2468         // This goes hand in hand with the Qt focus setting below.
2469         if (!newFocusNode && getDocument()->view()) {
2470             getDocument()->view()->setFocus();
2471         }
2472
2473         if (oldFocusNode->active())
2474             oldFocusNode->setActive(false);
2475
2476         oldFocusNode->setFocus(false);
2477         oldFocusNode->dispatchHTMLEvent(EventImpl::BLUR_EVENT, false, false);
2478         if (m_focusNode != 0) {
2479             // handler shifted focus
2480             focusChangeBlocked = true;
2481             newFocusNode = 0;
2482         }
2483         oldFocusNode->dispatchUIEvent(EventImpl::DOMFOCUSOUT_EVENT);
2484         if (m_focusNode != 0) {
2485             // handler shifted focus
2486             focusChangeBlocked = true;
2487             newFocusNode = 0;
2488         }
2489         if ((oldFocusNode == this) && oldFocusNode->hasOneRef()) {
2490             oldFocusNode->deref(); // deletes this
2491             return true;
2492         }
2493         else {
2494             oldFocusNode->deref();
2495         }
2496     }
2497
2498     // Clear the selection when changing the focus node to null or to a node that is not 
2499     // contained by the current selection.
2500     if (part()) {
2501         NodeImpl *startContainer = part()->selection().start().node();
2502         if (!newFocusNode || (startContainer && startContainer != newFocusNode && !startContainer->isAncestor(newFocusNode)))
2503             part()->clearSelection();
2504     }
2505
2506     if (newFocusNode) {
2507 #if APPLE_CHANGES            
2508         if (newFocusNode->isContentEditable() && !acceptsEditingFocus(newFocusNode)) {
2509             // delegate blocks focus change
2510             focusChangeBlocked = true;
2511             goto SetFocusNodeDone;
2512         }
2513 #endif
2514         // Set focus on the new node
2515         m_focusNode = newFocusNode;
2516         m_focusNode->ref();
2517         m_focusNode->dispatchHTMLEvent(EventImpl::FOCUS_EVENT, false, false);
2518         if (m_focusNode != newFocusNode) {
2519             // handler shifted focus
2520             focusChangeBlocked = true;
2521             goto SetFocusNodeDone;
2522         }
2523         m_focusNode->dispatchUIEvent(EventImpl::DOMFOCUSIN_EVENT);
2524         if (m_focusNode != newFocusNode) { 
2525             // handler shifted focus
2526             focusChangeBlocked = true;
2527             goto SetFocusNodeDone;
2528         }
2529         m_focusNode->setFocus();
2530         // eww, I suck. set the qt focus correctly
2531         // ### find a better place in the code for this
2532         if (getDocument()->view()) {
2533             if (!m_focusNode->renderer() || !m_focusNode->renderer()->isWidget())
2534                 getDocument()->view()->setFocus();
2535             else if (static_cast<RenderWidget*>(m_focusNode->renderer())->widget()) {
2536                 // Make sure a widget has the right size before giving it focus.
2537                 // Otherwise, we are testing edge cases of the QWidget code.
2538                 // Specifically, in WebCore this does not work well for text fields.
2539                 getDocument()->updateLayout();
2540                 static_cast<RenderWidget*>(m_focusNode->renderer())->widget()->setFocus();
2541             }
2542         }
2543    }
2544
2545 #if APPLE_CHANGES
2546     if (!focusChangeBlocked && m_focusNode && KWQAccObjectCache::accessibilityEnabled())
2547         getAccObjectCache()->handleFocusedUIElementChanged();
2548 #endif
2549
2550 SetFocusNodeDone:
2551     updateRendering();
2552     return !focusChangeBlocked;
2553 }
2554
2555 void DocumentImpl::setCSSTarget(NodeImpl* n)
2556 {
2557     if (m_cssTarget)
2558         m_cssTarget->setChanged();
2559     m_cssTarget = n;
2560     if (n)
2561         n->setChanged();
2562 }
2563
2564 NodeImpl* DocumentImpl::getCSSTarget()
2565 {
2566     return m_cssTarget;
2567 }
2568
2569 void DocumentImpl::attachNodeIterator(NodeIteratorImpl *ni)
2570 {
2571     m_nodeIterators.append(ni);
2572 }
2573
2574 void DocumentImpl::detachNodeIterator(NodeIteratorImpl *ni)
2575 {
2576     m_nodeIterators.remove(ni);
2577 }
2578
2579 void DocumentImpl::notifyBeforeNodeRemoval(NodeImpl *n)
2580 {
2581     QPtrListIterator<NodeIteratorImpl> it(m_nodeIterators);
2582     for (; it.current(); ++it)
2583         it.current()->notifyBeforeNodeRemoval(n);
2584 }
2585
2586 AbstractViewImpl *DocumentImpl::defaultView() const
2587 {
2588     return m_defaultView;
2589 }
2590
2591 EventImpl *DocumentImpl::createEvent(const DOMString &eventType, int &exceptioncode)
2592 {
2593     if (eventType == "UIEvents")
2594         return new UIEventImpl();
2595     else if (eventType == "MouseEvents")
2596         return new MouseEventImpl();
2597     else if (eventType == "MutationEvents")
2598         return new MutationEventImpl();
2599     else if (eventType == "KeyboardEvents")
2600         return new KeyboardEventImpl();
2601     else if (eventType == "HTMLEvents")
2602         return new EventImpl();
2603     else {
2604         exceptioncode = DOMException::NOT_SUPPORTED_ERR;
2605         return 0;
2606     }
2607 }
2608
2609 CSSStyleDeclarationImpl *DocumentImpl::getOverrideStyle(ElementImpl */*elt*/, DOMStringImpl */*pseudoElt*/)
2610 {
2611     return 0; // ###
2612 }
2613
2614 void DocumentImpl::defaultEventHandler(EventImpl *evt)
2615 {
2616     // if any html event listeners are registered on the window, then dispatch them here
2617     QPtrList<RegisteredEventListener> listenersCopy = m_windowEventListeners;
2618     QPtrListIterator<RegisteredEventListener> it(listenersCopy);
2619     Event ev(evt);
2620     for (; it.current(); ++it) {
2621         if (it.current()->id == evt->id()) {
2622             it.current()->listener->handleEvent(ev, true);
2623         }
2624     }
2625
2626     // handle accesskey
2627     if (evt->id()==EventImpl::KEYDOWN_EVENT) {
2628         KeyboardEventImpl *kevt = static_cast<KeyboardEventImpl *>(evt);
2629         if (kevt->ctrlKey()) {
2630             QString key = kevt->qKeyEvent()->unmodifiedText().lower();
2631             ElementImpl *elem = getElementByAccessKey(key);
2632             if (elem) {
2633                 elem->accessKeyAction();
2634                 evt->setDefaultHandled();
2635             }
2636         }
2637     }
2638 }
2639
2640 void DocumentImpl::setHTMLWindowEventListener(int id, EventListener *listener)
2641 {
2642     // If we already have it we don't want removeWindowEventListener to delete it
2643     if (listener)
2644         listener->ref();
2645     removeHTMLWindowEventListener(id);
2646     if (listener) {
2647         addWindowEventListener(id, listener, false);
2648         listener->deref();
2649     }
2650 }
2651
2652 EventListener *DocumentImpl::getHTMLWindowEventListener(int id)
2653 {
2654     QPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2655     for (; it.current(); ++it) {
2656         if (it.current()->id == id &&
2657             it.current()->listener->eventListenerType() == "_khtml_HTMLEventListener") {
2658             return it.current()->listener;
2659         }
2660     }
2661
2662     return 0;
2663 }
2664
2665 void DocumentImpl::removeHTMLWindowEventListener(int id)
2666 {
2667     QPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2668     for (; it.current(); ++it) {
2669         if (it.current()->id == id &&
2670             it.current()->listener->eventListenerType() == "_khtml_HTMLEventListener") {
2671             m_windowEventListeners.removeRef(it.current());
2672             return;
2673         }
2674     }
2675 }
2676
2677 void DocumentImpl::addWindowEventListener(int id, EventListener *listener, const bool useCapture)
2678 {
2679     listener->ref();
2680
2681     // remove existing identical listener set with identical arguments - the DOM2
2682     // spec says that "duplicate instances are discarded" in this case.
2683     removeWindowEventListener(id,listener,useCapture);
2684
2685     RegisteredEventListener *rl = new RegisteredEventListener(static_cast<EventImpl::EventId>(id), listener, useCapture);
2686     m_windowEventListeners.append(rl);
2687
2688     listener->deref();
2689 }
2690
2691 void DocumentImpl::removeWindowEventListener(int id, EventListener *listener, bool useCapture)
2692 {
2693     RegisteredEventListener rl(static_cast<EventImpl::EventId>(id),listener,useCapture);
2694
2695     QPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2696     for (; it.current(); ++it)
2697         if (*(it.current()) == rl) {
2698             m_windowEventListeners.removeRef(it.current());
2699             return;
2700         }
2701 }
2702
2703 bool DocumentImpl::hasWindowEventListener(int id)
2704 {
2705     QPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2706     for (; it.current(); ++it) {
2707         if (it.current()->id == id) {
2708             return true;
2709         }
2710     }
2711
2712     return false;
2713 }
2714
2715 EventListener *DocumentImpl::createHTMLEventListener(QString code)
2716 {
2717     if (part()) {
2718         return part()->createHTMLEventListener(code);
2719     } else {
2720         return NULL;
2721     }
2722 }
2723
2724 void DocumentImpl::dispatchImageLoadEventSoon(HTMLImageLoader *image)
2725 {
2726     m_imageLoadEventDispatchSoonList.append(image);
2727     if (!m_imageLoadEventTimer) {
2728         m_imageLoadEventTimer = startTimer(0);
2729     }
2730 }
2731
2732 void DocumentImpl::removeImage(HTMLImageLoader* image)
2733 {
2734     // Remove instances of this image from both lists.
2735     // Use loops because we allow multiple instances to get into the lists.
2736     while (m_imageLoadEventDispatchSoonList.removeRef(image)) { }
2737     while (m_imageLoadEventDispatchingList.removeRef(image)) { }
2738     if (m_imageLoadEventDispatchSoonList.isEmpty() && m_imageLoadEventTimer) {
2739         killTimer(m_imageLoadEventTimer);
2740         m_imageLoadEventTimer = 0;
2741     }
2742 }
2743
2744 void DocumentImpl::dispatchImageLoadEventsNow()
2745 {
2746     // need to avoid re-entering this function; if new dispatches are
2747     // scheduled before the parent finishes processing the list, they
2748     // will set a timer and eventually be processed
2749     if (!m_imageLoadEventDispatchingList.isEmpty()) {
2750         return;
2751     }
2752
2753     if (m_imageLoadEventTimer) {
2754         killTimer(m_imageLoadEventTimer);
2755         m_imageLoadEventTimer = 0;
2756     }
2757     
2758     m_imageLoadEventDispatchingList = m_imageLoadEventDispatchSoonList;
2759     m_imageLoadEventDispatchSoonList.clear();
2760     for (QPtrListIterator<HTMLImageLoader> it(m_imageLoadEventDispatchingList); it.current(); ) {
2761         HTMLImageLoader* image = it.current();
2762         // Must advance iterator *before* dispatching call.
2763         // Otherwise, it might be advanced automatically if dispatching the call had a side effect
2764         // of destroying the current HTMLImageLoader, and then we would advance past the *next* item,
2765         // missing one altogether.
2766         ++it;
2767         image->dispatchLoadEvent();
2768     }
2769     m_imageLoadEventDispatchingList.clear();
2770 }
2771
2772 void DocumentImpl::timerEvent(QTimerEvent *)
2773 {
2774     dispatchImageLoadEventsNow();
2775 }
2776
2777 ElementImpl *DocumentImpl::ownerElement()
2778 {
2779     KHTMLView *childView = view();
2780     if (!childView)
2781         return 0;
2782     KHTMLPart *childPart = childView->part();
2783     if (!childPart)
2784         return 0;
2785     KHTMLPart *parent = childPart->parentPart();
2786     if (!parent)
2787         return 0;
2788     ChildFrame *childFrame = parent->childFrame(childPart);
2789     if (!childFrame)
2790         return 0;
2791     RenderPart *renderPart = childFrame->m_frame;
2792     if (!renderPart)
2793         return 0;
2794     return static_cast<ElementImpl *>(renderPart->element());
2795 }
2796
2797 DOMString DocumentImpl::domain() const
2798 {
2799     if ( m_domain.isEmpty() ) // not set yet (we set it on demand to save time and space)
2800         m_domain = KURL(URL()).host(); // Initially set to the host
2801     return m_domain;
2802 }
2803
2804 void DocumentImpl::setDomain(const DOMString &newDomain, bool force /*=false*/)
2805 {
2806     if ( force ) {
2807         m_domain = newDomain;
2808         return;
2809     }
2810     if ( m_domain.isEmpty() ) // not set yet (we set it on demand to save time and space)
2811         m_domain = KURL(URL()).host(); // Initially set to the host
2812
2813     // Both NS and IE specify that changing the domain is only allowed when
2814     // the new domain is a suffix of the old domain.
2815     int oldLength = m_domain.length();
2816     int newLength = newDomain.length();
2817     if ( newLength < oldLength ) // e.g. newDomain=kde.org (7) and m_domain=www.kde.org (11)
2818     {
2819         DOMString test = m_domain.copy();
2820         if ( test[oldLength - newLength - 1] == '.' ) // Check that it's a subdomain, not e.g. "de.org"
2821         {
2822             test.remove( 0, oldLength - newLength ); // now test is "kde.org" from m_domain
2823             if ( test == newDomain )                 // and we check that it's the same thing as newDomain
2824                 m_domain = newDomain;
2825         }
2826     }
2827 }
2828
2829 bool DocumentImpl::isValidName(const DOMString &name)
2830 {
2831     static const char validFirstCharacter[] = "ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz";
2832     static const char validSubsequentCharacter[] = "ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz0123456789-_:.";
2833     const unsigned length = name.length();
2834     if (length == 0)
2835         return false;
2836     const QChar * const characters = name.unicode();
2837     const char fc = characters[0];
2838     if (!fc)
2839         return false;
2840     if (strchr(validFirstCharacter, fc) == 0)
2841         return false;
2842     for (unsigned i = 1; i < length; ++i) {
2843         const char sc = characters[i];
2844         if (!sc)
2845             return false;
2846         if (strchr(validSubsequentCharacter, sc) == 0)
2847             return false;
2848     }
2849     return true;
2850 }
2851
2852 void DocumentImpl::addImageMap(HTMLMapElementImpl *imageMap)
2853 {
2854     // Add the image map, unless there's already another with that name.
2855     // "First map wins" is the rule other browsers seem to implement.
2856     QString name = imageMap->getName().string();
2857     if (!m_imageMapsByName.contains(name))
2858         m_imageMapsByName.insert(name, imageMap);
2859 }
2860
2861 void DocumentImpl::removeImageMap(HTMLMapElementImpl *imageMap)
2862 {
2863     // Remove the image map by name.
2864     // But don't remove some other image map that just happens to have the same name.
2865     QString name = imageMap->getName().string();
2866     QMapIterator<QString, HTMLMapElementImpl *> it = m_imageMapsByName.find(name);
2867     if (it != m_imageMapsByName.end() && *it == imageMap)
2868         m_imageMapsByName.remove(it);
2869 }
2870
2871 HTMLMapElementImpl *DocumentImpl::getImageMap(const DOMString &URL) const
2872 {
2873     if (URL.isNull()) {
2874         return 0;
2875     }
2876
2877     QString s = URL.string();
2878     int hashPos = s.find('#');
2879     if (hashPos >= 0)
2880         s = s.mid(hashPos + 1);
2881
2882     QMapConstIterator<QString, HTMLMapElementImpl *> it = m_imageMapsByName.find(s);
2883     if (it == m_imageMapsByName.end())
2884         return 0;
2885     return *it;
2886 }
2887
2888 #if APPLE_CHANGES
2889
2890 void DocumentImpl::setDecoder(Decoder *decoder)
2891 {
2892     decoder->ref();
2893     if (m_decoder) {
2894         m_decoder->deref();
2895     }
2896     m_decoder = decoder;
2897 }
2898
2899 QString DocumentImpl::completeURL(const QString &URL)
2900 {
2901     return KURL(baseURL(), URL, m_decoder ? m_decoder->codec() : 0).url();
2902 }
2903
2904 bool DocumentImpl::inPageCache()
2905 {
2906     return m_inPageCache;
2907 }
2908
2909 void DocumentImpl::setInPageCache(bool flag)
2910 {
2911     if (m_inPageCache == flag)
2912         return;
2913
2914     m_inPageCache = flag;
2915     if (flag) {
2916         assert(m_savedRenderer == 0);
2917         m_savedRenderer = m_render;
2918         if (m_view) {
2919             m_view->resetScrollBars();
2920         }
2921     } else {
2922         assert(m_render == 0 || m_render == m_savedRenderer);
2923         m_render = m_savedRenderer;
2924         m_savedRenderer = 0;
2925     }
2926 }
2927
2928 void DocumentImpl::passwordFieldAdded()
2929 {
2930     m_passwordFields++;
2931 }
2932
2933 void DocumentImpl::passwordFieldRemoved()
2934 {
2935     assert(m_passwordFields > 0);
2936     m_passwordFields--;
2937 }
2938
2939 bool DocumentImpl::hasPasswordField() const
2940 {
2941     return m_passwordFields > 0;
2942 }
2943
2944 void DocumentImpl::secureFormAdded()
2945 {
2946     m_secureForms++;
2947 }
2948
2949 void DocumentImpl::secureFormRemoved()
2950 {
2951     assert(m_secureForms > 0);
2952     m_secureForms--;
2953 }
2954
2955 bool DocumentImpl::hasSecureForm() const
2956 {
2957     return m_secureForms > 0;
2958 }
2959
2960 void DocumentImpl::setShouldCreateRenderers(bool f)
2961 {
2962     m_createRenderers = f;
2963 }
2964
2965 bool DocumentImpl::shouldCreateRenderers()
2966 {
2967     return m_createRenderers;
2968 }
2969
2970 DOMString DocumentImpl::toString() const
2971 {
2972     DOMString result;
2973
2974     for (NodeImpl *child = firstChild(); child != NULL; child = child->nextSibling()) {
2975         result += child->toString();
2976     }
2977
2978     return result;
2979 }
2980
2981 #endif // APPLE_CHANGES
2982
2983 // ----------------------------------------------------------------------------
2984 // Support for Javascript execCommand, and related methods
2985
2986 JSEditor *DocumentImpl::jsEditor()
2987 {
2988     if (!m_jsEditor)
2989         m_jsEditor = new JSEditor(this);
2990     return m_jsEditor;
2991 }
2992
2993 bool DocumentImpl::execCommand(const DOMString &command, bool userInterface, const DOMString &value)
2994 {
2995     return jsEditor()->execCommand(command, userInterface, value);
2996 }
2997
2998 bool DocumentImpl::queryCommandEnabled(const DOMString &command)
2999 {
3000     return jsEditor()->queryCommandEnabled(command);
3001 }
3002
3003 bool DocumentImpl::queryCommandIndeterm(const DOMString &command)
3004 {
3005     return jsEditor()->queryCommandIndeterm(command);
3006 }
3007
3008 bool DocumentImpl::queryCommandState(const DOMString &command)
3009 {
3010     return jsEditor()->queryCommandState(command);
3011 }
3012
3013 bool DocumentImpl::queryCommandSupported(const DOMString &command)
3014 {
3015     return jsEditor()->queryCommandSupported(command);
3016 }
3017
3018 DOMString DocumentImpl::queryCommandValue(const DOMString &command)
3019 {
3020     return jsEditor()->queryCommandValue(command);
3021 }
3022
3023 // ----------------------------------------------------------------------------
3024
3025 void DocumentImpl::addMarker(Range range, DocumentMarker::MarkerType type)
3026 {
3027     // Use a TextIterator to visit the potentially multiple nodes the range covers.
3028     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
3029         Range textPiece = markedText.range();
3030         DocumentMarker marker = {type, textPiece.startOffset(), textPiece.endOffset()};
3031         addMarker(textPiece.startContainer().handle(), marker);
3032     }
3033 }
3034
3035 void DocumentImpl::removeMarker(Range range, DocumentMarker::MarkerType type)
3036 {
3037     // Use a TextIterator to visit the potentially multiple nodes the range covers.
3038     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
3039         Range textPiece = markedText.range();
3040         DocumentMarker marker = {type, textPiece.startOffset(), textPiece.endOffset()};
3041         removeMarker(textPiece.startContainer().handle(), marker);
3042     }
3043 }
3044
3045 // FIXME:  We don't deal with markers of more than one type yet
3046
3047 // Markers are stored in order sorted by their location.  They do not overlap each other, as currently
3048 // required by the drawing code in render_text.cpp.
3049
3050 void DocumentImpl::addMarker(NodeImpl *node, DocumentMarker newMarker) 
3051 {
3052     assert(newMarker.endOffset >= newMarker.startOffset);
3053     if (newMarker.endOffset == newMarker.startOffset) {
3054         return;     // zero length markers are a NOP
3055     }
3056     
3057     QValueList <DocumentMarker> *markers = m_markers.find(node);
3058     if (!markers) {
3059         markers = new QValueList <DocumentMarker>();
3060         markers->append(newMarker);
3061         m_markers.insert(node, markers);
3062     } else {
3063         QValueListIterator<DocumentMarker> it;
3064         for (it = markers->begin(); it != markers->end(); ) {
3065             DocumentMarker marker = *it;
3066             
3067             if (newMarker.endOffset < marker.startOffset+1) {
3068                 // This is the first marker that is completely after newMarker, and disjoint from it.
3069                 // We found our insertion point.\10
3070                 break;
3071             } else if (newMarker.startOffset > marker.endOffset) {
3072                 // maker is before newMarker, and disjoint from it.  Keep scanning.
3073                 it++;
3074             } else if (newMarker == marker) {
3075                 // already have this one, NOP
3076                 return;
3077             } else {
3078                 // marker and newMarker intersect or touch - merge them into newMarker
3079                 newMarker.startOffset = kMin(newMarker.startOffset, marker.startOffset);
3080                 newMarker.endOffset = kMax(newMarker.endOffset, marker.endOffset);
3081                 // remove old one, we'll add newMarker later
3082                 it = markers->remove(it);
3083                 // it points to the next marker to consider
3084             }
3085         }
3086         // at this point it points to the node before which we want to insert
3087         markers->insert(it, newMarker);
3088     }
3089     
3090     // repaint the affected node
3091     if (node->renderer())
3092         node->renderer()->repaint();
3093 }
3094
3095 void DocumentImpl::removeMarker(NodeImpl *node, DocumentMarker target)
3096 {
3097     assert(target.endOffset >= target.startOffset);
3098     if (target.endOffset == target.startOffset) {
3099         return;     // zero length markers are a NOP
3100     }
3101
3102     QValueList <DocumentMarker> *markers = m_markers.find(node);
3103     if (!markers) {
3104         return;
3105     }
3106     
3107     bool docDirty = false;
3108     QValueListIterator<DocumentMarker> it;
3109     for (it = markers->begin(); it != markers->end(); ) {
3110         DocumentMarker marker = *it;
3111
3112         if (target.endOffset <= marker.startOffset) {
3113             // This is the first marker that is completely after target.  All done.
3114             break;
3115         } else if (target.startOffset >= marker.endOffset) {
3116             // marker is before target.  Keep scanning.
3117             it++;
3118         } else {
3119             // at this point we know that marker and target intersect in some way
3120             docDirty = true;
3121
3122             // pitch the old marker
3123             it = markers->remove(it);
3124             // it now points to the next node
3125             
3126             // add either of the resulting slices that are left after removing target
3127             if (target.startOffset > marker.startOffset) {
3128                 DocumentMarker newLeft = marker;
3129                 newLeft.endOffset = target.startOffset;
3130                 markers->insert(it, newLeft);
3131             }
3132             if (marker.endOffset > target.endOffset) {
3133                 DocumentMarker newRight = marker;
3134                 newRight.startOffset = target.endOffset;
3135                 markers->insert(it, newRight);
3136             }
3137         }
3138     }
3139
3140     // repaint the affected node
3141     if (docDirty && node->renderer())
3142         node->renderer()->repaint();
3143 }
3144
3145 QValueList<DocumentMarker> DocumentImpl::markersForNode(NodeImpl *node)
3146 {
3147     QValueList <DocumentMarker> *markers = m_markers.find(node);
3148     if (markers) {
3149         return *markers;
3150     } else {
3151         return QValueList <DocumentMarker> ();
3152     }
3153 }
3154
3155 void DocumentImpl::removeAllMarkers(NodeImpl *node, ulong startOffset, long length)
3156 {
3157     // FIXME - yet another cheat that relies on us only having one marker type
3158     DocumentMarker marker = {DocumentMarker::Spelling, startOffset, startOffset+length};
3159     removeMarker(node, marker);
3160 }
3161
3162 void DocumentImpl::removeAllMarkers(NodeImpl *node)
3163 {
3164     QValueList <DocumentMarker> *markers = m_markers.find(node);
3165     if (markers)
3166         markers->clear();
3167 }
3168
3169 void DocumentImpl::removeAllMarkers()
3170 {
3171     m_markers.clear();
3172 }
3173
3174 void DocumentImpl::shiftMarkers(NodeImpl *node, ulong startOffset, long delta)
3175 {
3176     if (m_markers.isEmpty())
3177         return;
3178
3179     QValueList <DocumentMarker> *markers = m_markers.find(node);
3180     if (!markers)
3181         return;
3182
3183     bool docDirty = false;
3184     QValueListIterator<DocumentMarker> it;
3185     for (it = markers->begin(); it != markers->end(); ++it) {
3186         DocumentMarker &marker = *it;
3187         if (marker.startOffset >= startOffset) {
3188             assert((int)marker.startOffset + delta >= 0);
3189             marker.startOffset += delta;
3190             marker.endOffset += delta;
3191             docDirty = true;
3192         }
3193     }
3194     
3195     // repaint the affected node
3196     if (docDirty && node->renderer())
3197         node->renderer()->repaint();
3198 }
3199
3200 #ifdef KHTML_XSLT
3201 void DocumentImpl::applyXSLTransform(ProcessingInstructionImpl* pi)
3202 {
3203     // Ref ourselves to keep from being destroyed.
3204     XSLTProcessorImpl processor(static_cast<XSLStyleSheetImpl*>(pi->sheet()), this);
3205     processor.transformDocument(this);
3206
3207     // FIXME: If the transform failed we should probably report an error (like Mozilla does) in this
3208     // case.
3209 }
3210
3211 void DocumentImpl::setTransformSourceDocument(DocumentImpl* doc)
3212
3213     if (m_transformSourceDocument)
3214         m_transformSourceDocument->deref(); 
3215     m_transformSourceDocument = doc;
3216     if (doc)
3217         doc->ref();
3218 }
3219
3220 #endif
3221
3222 void DocumentImpl::setDesignMode(InheritedBool value)
3223 {
3224     m_designMode = value;
3225 }
3226
3227 DocumentImpl::InheritedBool DocumentImpl::getDesignMode() const
3228 {
3229     return m_designMode;
3230 }
3231
3232 bool DocumentImpl::inDesignMode() const
3233 {
3234     for (const DocumentImpl* d = this; d; d = d->parentDocument()) {
3235         if (d->m_designMode != inherit)
3236             return d->m_designMode;      
3237     }
3238     return false;
3239 }
3240
3241 DocumentImpl *DocumentImpl::parentDocument() const
3242 {
3243     KHTMLPart *childPart = part();
3244     if (!childPart)
3245         return 0;
3246     KHTMLPart *parent = childPart->parentPart();
3247     if (!parent)
3248         return 0;
3249     return parent->xmlDocImpl();
3250 }
3251
3252 DocumentImpl *DocumentImpl::topDocument() const
3253 {
3254     DocumentImpl *doc = const_cast<DocumentImpl *>(this);
3255     ElementImpl *element;
3256     while ((element = doc->ownerElement()) != 0) {
3257         doc = element->getDocument();
3258         element = doc ? doc->ownerElement() : 0;
3259     }
3260     
3261     return doc;
3262 }
3263
3264 // ----------------------------------------------------------------------------
3265
3266 DocumentFragmentImpl::DocumentFragmentImpl(DocumentPtr *doc) : NodeBaseImpl(doc)
3267 {
3268 }
3269
3270 DOMString DocumentFragmentImpl::nodeName() const
3271 {
3272   return "#document-fragment";
3273 }
3274
3275 unsigned short DocumentFragmentImpl::nodeType() const
3276 {
3277     return Node::DOCUMENT_FRAGMENT_NODE;
3278 }
3279
3280 // DOM Section 1.1.1
3281 bool DocumentFragmentImpl::childTypeAllowed( unsigned short type )
3282 {
3283     switch (type) {
3284         case Node::ELEMENT_NODE:
3285         case Node::PROCESSING_INSTRUCTION_NODE:
3286         case Node::COMMENT_NODE:
3287         case Node::TEXT_NODE:
3288         case Node::CDATA_SECTION_NODE:
3289         case Node::ENTITY_REFERENCE_NODE:
3290             return true;
3291         default:
3292             return false;
3293     }
3294 }
3295
3296 DOMString DocumentFragmentImpl::toString() const
3297 {
3298     DOMString result;
3299
3300     for (NodeImpl *child = firstChild(); child != NULL; child = child->nextSibling()) {
3301         result += child->toString();
3302     }
3303
3304     return result;
3305 }
3306
3307
3308 NodeImpl *DocumentFragmentImpl::cloneNode ( bool deep )
3309 {
3310     DocumentFragmentImpl *clone = new DocumentFragmentImpl( docPtr() );
3311     if (deep)
3312         cloneChildNodes(clone);
3313     return clone;
3314 }
3315
3316
3317 // ----------------------------------------------------------------------------
3318
3319 DocumentTypeImpl::DocumentTypeImpl(DOMImplementationImpl *implementation, DocumentPtr *doc,
3320                                    const DOMString &qualifiedName, const DOMString &publicId,
3321                                    const DOMString &systemId)
3322     : NodeImpl(doc), m_implementation(implementation),
3323       m_qualifiedName(qualifiedName), m_publicId(publicId), m_systemId(systemId)
3324 {
3325     if (m_implementation)
3326         m_implementation->ref();
3327
3328     m_entities = 0;
3329     m_notations = 0;
3330
3331     // if doc is 0, it is not attached to a document and / or
3332     // therefore does not provide entities or notations. (DOM Level 3)
3333 }
3334
3335 DocumentTypeImpl::~DocumentTypeImpl()
3336 {
3337     if (m_implementation)
3338         m_implementation->deref();
3339     if (m_entities)
3340         m_entities->deref();
3341     if (m_notations)
3342         m_notations->deref();
3343 }
3344
3345 void DocumentTypeImpl::copyFrom(const DocumentTypeImpl& other)
3346 {
3347     m_qualifiedName = other.m_qualifiedName;
3348     m_publicId = other.m_publicId;
3349     m_systemId = other.m_systemId;
3350     m_subset = other.m_subset;
3351 }
3352
3353 DOMString DocumentTypeImpl::toString() const
3354 {
3355     DOMString result;
3356     if (m_qualifiedName.isEmpty()) {
3357         return "";
3358     } else {
3359         result = "<!DOCTYPE ";
3360         result += m_qualifiedName;
3361     }
3362     if (!m_publicId.isEmpty()) {
3363         result += " PUBLIC \"";
3364         result += m_publicId;
3365         result += "\" \"";
3366         result += m_systemId;
3367         result += "\"";
3368     } else if (!m_systemId.isEmpty()) {
3369         result += " SYSTEM \"";
3370         result += m_systemId;
3371         result += "\"";
3372     }
3373     if (!m_subset.isEmpty()) {
3374         result += " [";
3375         result += m_subset;
3376         result += "]";
3377     }
3378     result += ">";
3379     return result;
3380 }
3381
3382 DOMString DocumentTypeImpl::nodeName() const
3383 {
3384     return name();
3385 }
3386
3387 unsigned short DocumentTypeImpl::nodeType() const
3388 {
3389     return Node::DOCUMENT_TYPE_NODE;
3390 }
3391
3392 // DOM Section 1.1.1
3393 bool DocumentTypeImpl::childTypeAllowed( unsigned short /*type*/ )
3394 {
3395     return false;
3396 }
3397
3398 NodeImpl *DocumentTypeImpl::cloneNode ( bool /*deep*/ )
3399 {
3400     // Spec says cloning Document nodes is "implementation dependent"
3401     // so we do not support it...
3402     return 0;
3403 }
3404
3405 #include "dom_docimpl.moc"