Reviewed by Anders.
[WebKit-https.git] / WebCore / dom / Document.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, 2005, 2006 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 "config.h"
26 #include "Document.h"
27
28 #include "AccessibilityObjectCache.h"
29 #include "CDATASection.h"
30 #include "CSSStyleSheet.h"
31 #include "CSSValueKeywords.h"
32 #include "Comment.h"
33 #include "DOMImplementation.h"
34 #include "Decoder.h"
35 #include "DocLoader.h"
36 #include "DocumentFragment.h"
37 #include "DocumentType.h"
38 #include "EditingText.h"
39 #include "EntityReference.h"
40 #include "Event.h"
41 #include "EventListener.h"
42 #include "EventNames.h"
43 #include "ExceptionCode.h"
44 #include "Frame.h"
45 #include "FrameTree.h"
46 #include "HTMLBodyElement.h"
47 #include "HTMLDocument.h"
48 #include "HTMLElementFactory.h"
49 #include "HTMLImageLoader.h"
50 #include "HTMLInputElement.h"
51 #include "HTMLLinkElement.h"
52 #include "HTMLMapElement.h"
53 #include "HTMLNameCollection.h"
54 #include "HTMLNames.h"
55 #include "HTMLStyleElement.h"
56 #include "JSEditor.h"
57 #include "KeyboardEvent.h"
58 #include "Logging.h"
59 #include "MouseEvent.h"
60 #include "MouseEventWithHitTestResults.h"
61 #include "MutationEvent.h"
62 #include "NameNodeList.h"
63 #include "NodeFilter.h"
64 #include "NodeIterator.h"
65 #include "PlatformKeyboardEvent.h"
66 #include "ProcessingInstruction.h"
67 #include "RegisteredEventListener.h"
68 #include "RegularExpression.h"
69 #include "RenderArena.h"
70 #include "RenderView.h"
71 #include "RenderWidget.h"
72 #include "SegmentedString.h"
73 #include "SelectionController.h"
74 #include "StringHash.h"
75 #include "StyleSheetList.h"
76 #include "SystemTime.h"
77 #include "TextIterator.h"
78 #include "TreeWalker.h"
79 #include "UIEvent.h"
80 #include "csshelper.h"
81 #include "cssstyleselector.h"
82 #include "kjs_binding.h"
83 #include "kjs_proxy.h"
84 #include "xml_tokenizer.h"
85 #include "xmlhttprequest.h"
86
87 #if XPATH_SUPPORT
88 #include "XPathEvaluator.h"
89 #include "XPathExpression.h"
90 #include "XPathNSResolver.h"
91 #include "XPathResult.h"
92 #endif
93
94 #ifdef KHTML_XSLT
95 #include "XSLTProcessor.h"
96 #endif
97
98 #ifndef KHTML_NO_XBL
99 #include "xbl_binding_manager.h"
100 using XBL::XBLBindingManager;
101 #endif
102
103 #if SVG_SUPPORT
104 #include "SVGDocumentExtensions.h"
105 #include "SVGElementFactory.h"
106 #include "SVGZoomEvent.h"
107 #include "SVGStyleElement.h"
108 #include "KSVGTimeScheduler.h"
109 #endif
110
111 using namespace std;
112
113 namespace WebCore {
114
115 using namespace EventNames;
116 using namespace HTMLNames;
117
118 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
119
120 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
121 // FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high
122 // for dual G5s. :)
123 const int cLayoutScheduleThreshold = 250;
124
125 // Use 1 to represent the document's default form.
126 HTMLFormElement* const defaultForm = (HTMLFormElement*) 1;
127
128 // Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's
129 static const unsigned PHI = 0x9e3779b9U;
130
131 // DOM Level 2 says (letters added):
132 //
133 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
134 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
135 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
136 // d) Characters which have a font or compatibility decomposition (i.e. those with a "compatibility formatting tag" in field 5 of the database -- marked by field 5 beginning with a "<") are not allowed.
137 // e) The following characters are treated as name-start characters rather than name characters, because the property file classifies them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.
138 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
139 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
140 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
141 // i) Characters ':' and '_' are allowed as name-start characters.
142 // j) Characters '-' and '.' are allowed as name characters.
143 //
144 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
145
146 static inline bool isValidNameStart(UChar32 c)
147 {
148     // rule (e) above
149     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
150         return true;
151
152     // rule (i) above
153     if (c == ':' || c == '_')
154         return true;
155
156     // rules (a) and (f) above
157     const uint32_t nameStartMask = U_GC_LL_MASK | U_GC_LU_MASK | U_GC_LO_MASK | U_GC_LT_MASK | U_GC_NL_MASK;
158     if (!(U_GET_GC_MASK(c) & nameStartMask))
159         return false;
160
161     // rule (c) above
162     if (c >= 0xF900 && c < 0xFFFE)
163         return false;
164
165     // rule (d) above
166     UDecompositionType decompType = static_cast<UDecompositionType>(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
167     if (decompType == U_DT_FONT || decompType == U_DT_COMPAT)
168         return false;
169
170     return true;
171 }
172
173 static inline bool isValidNamePart(UChar32 c)
174 {
175     // rules (a), (e), and (i) above
176     if (isValidNameStart(c))
177         return true;
178
179     // rules (g) and (h) above
180     if (c == 0x00B7 || c == 0x0387)
181         return true;
182
183     // rule (j) above
184     if (c == '-' || c == '.')
185         return true;
186
187     // rules (b) and (f) above
188     const uint32_t otherNamePartMask = U_GC_MC_MASK | U_GC_ME_MASK | U_GC_MN_MASK | U_GC_LM_MASK | U_GC_ND_MASK;
189     if (!(U_GET_GC_MASK(c) & otherNamePartMask))
190         return false;
191
192     // rule (c) above
193     if (c >= 0xF900 && c < 0xFFFE)
194         return false;
195
196     // rule (d) above
197     UDecompositionType decompType = static_cast<UDecompositionType>(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
198     if (decompType == U_DT_FONT || decompType == U_DT_COMPAT)
199         return false;
200
201     return true;
202 }
203
204 DeprecatedPtrList<Document> * Document::changedDocuments = 0;
205
206 // FrameView might be 0
207 Document::Document(DOMImplementation* impl, FrameView *v)
208     : ContainerNode(0)
209     , m_implementation(impl)
210     , m_domtree_version(0)
211     , m_styleSheets(new StyleSheetList)
212     , m_title("")
213     , m_titleSetExplicitly(false)
214     , m_imageLoadEventTimer(this, &Document::imageLoadEventTimerFired)
215 #if !KHTML_NO_XBL
216     , m_bindingManager(new XBLBindingManager(this))
217 #endif
218 #ifdef KHTML_XSLT
219     , m_transformSource(0)
220 #endif
221     , m_savedRenderer(0)
222     , m_passwordFields(0)
223     , m_secureForms(0)
224     , m_designMode(inherit)
225     , m_selfOnlyRefCount(0)
226 #if SVG_SUPPORT
227     , m_svgExtensions(0)
228 #endif
229 #if __APPLE__
230     , m_hasDashboardRegions(false)
231     , m_dashboardRegionsDirty(false)
232 #endif
233     , m_accessKeyMapValid(false)
234     , m_createRenderers(true)
235     , m_inPageCache(false)
236 {
237     m_document.resetSkippingRef(this);
238
239     m_printing = false;
240
241     m_view = v;
242     m_renderArena = 0;
243
244     m_accCache = 0;
245     
246     m_docLoader = new DocLoader(v ? v->frame() : 0, this);
247
248     visuallyOrdered = false;
249     m_loadingSheet = false;
250     m_bParsing = false;
251     m_docChanged = false;
252     m_tokenizer = 0;
253
254     pMode = Strict;
255     hMode = XHtml;
256     m_textColor = Color::black;
257     m_listenerTypes = 0;
258     m_inDocument = true;
259     m_styleSelectorDirty = false;
260     m_inStyleRecalc = false;
261     m_closeAfterStyleRecalc = false;
262     m_usesDescendantRules = false;
263     m_usesSiblingRules = false;
264
265     m_styleSelector = new CSSStyleSelector(this, m_usersheet, m_styleSheets.get(), !inCompatMode());
266     m_windowEventListeners.setAutoDelete(true);
267     m_pendingStylesheets = 0;
268     m_ignorePendingStylesheets = false;
269
270     m_cssTarget = 0;
271
272     resetLinkColor();
273     resetVisitedLinkColor();
274     resetActiveLinkColor();
275
276     m_processingLoadEvent = false;
277     m_startTime = currentTime();
278     m_overMinimumLayoutThreshold = false;
279     
280     m_jsEditor = 0;
281
282     static int docID = 0;
283     m_docID = docID++;
284 }
285
286 void Document::removedLastRef()
287 {
288     if (m_selfOnlyRefCount) {
289         // if removing a child removes the last self-only ref, we don't
290         // want the document to be destructed until after
291         // removeAllChildren returns, so we guard ourselves with an
292         // extra self-only ref
293
294         DocPtr<Document> guard(this);
295
296         // we must make sure not to be retaining any of our children through
297         // these extra pointers or we will create a reference cycle
298         m_docType = 0;
299         m_focusNode = 0;
300         m_hoverNode = 0;
301         m_activeNode = 0;
302         m_titleElement = 0;
303
304         removeAllChildren();
305
306         m_markers.clear();
307
308         delete m_tokenizer;
309         m_tokenizer = 0;
310     } else
311         delete this;
312 }
313
314 Document::~Document()
315 {
316     assert(!renderer());
317     assert(!m_inPageCache);
318     assert(m_savedRenderer == 0);
319
320 #if SVG_SUPPORT
321     delete m_svgExtensions;
322 #endif
323
324     XMLHttpRequest::detachRequests(this);
325     KJS::ScriptInterpreter::forgetAllDOMNodesForDocument(this);
326
327     if (m_docChanged && changedDocuments)
328         changedDocuments->remove(this);
329     delete m_tokenizer;
330     m_document.resetSkippingRef(0);
331     delete m_styleSelector;
332     delete m_docLoader;
333     
334     if (m_renderArena) {
335         delete m_renderArena;
336         m_renderArena = 0;
337     }
338
339 #ifdef KHTML_XSLT
340     xmlFreeDoc((xmlDocPtr)m_transformSource);
341 #endif
342
343 #ifndef KHTML_NO_XBL
344     delete m_bindingManager;
345 #endif
346
347     deleteAllValues(m_markers);
348
349     if (m_accCache) {
350         delete m_accCache;
351         m_accCache = 0;
352     }
353     m_decoder = 0;
354     
355     if (m_jsEditor) {
356         delete m_jsEditor;
357         m_jsEditor = 0;
358     }
359     
360     deleteAllValues(m_selectedRadioButtons);
361 }
362
363 void Document::resetLinkColor()
364 {
365     m_linkColor = Color(0, 0, 238);
366 }
367
368 void Document::resetVisitedLinkColor()
369 {
370     m_visitedLinkColor = Color(85, 26, 139);    
371 }
372
373 void Document::resetActiveLinkColor()
374 {
375     m_activeLinkColor.setNamedColor("red");
376 }
377
378 void Document::setDocType(PassRefPtr<DocumentType> docType)
379 {
380     m_docType = docType;
381 }
382
383 DocumentType *Document::doctype() const
384 {
385     return m_docType.get();
386 }
387
388 DOMImplementation* Document::implementation() const
389 {
390     return m_implementation.get();
391 }
392
393 Element* Document::documentElement() const
394 {
395     Node* n = firstChild();
396     while (n && !n->isElementNode())
397       n = n->nextSibling();
398     return static_cast<Element*>(n);
399 }
400
401 PassRefPtr<Element> Document::createElement(const String &name, ExceptionCode& ec)
402 {
403     return createElementNS(nullAtom, name, ec);
404 }
405
406 PassRefPtr<DocumentFragment> Document::createDocumentFragment()
407 {
408     return new DocumentFragment(document());
409 }
410
411 PassRefPtr<Text> Document::createTextNode(const String &data)
412 {
413     return new Text(this, data);
414 }
415
416 PassRefPtr<Comment> Document::createComment (const String &data)
417 {
418     return new Comment(this, data);
419 }
420
421 PassRefPtr<CDATASection> Document::createCDATASection(const String &data, ExceptionCode& ec)
422 {
423     if (isHTMLDocument()) {
424         ec = NOT_SUPPORTED_ERR;
425         return 0;
426     }
427     return new CDATASection(this, data);
428 }
429
430 PassRefPtr<ProcessingInstruction> Document::createProcessingInstruction(const String &target, const String &data, ExceptionCode& ec)
431 {
432     if (!isValidName(target)) {
433         ec = INVALID_CHARACTER_ERR;
434         return 0;
435     }
436     if (isHTMLDocument()) {
437         ec = NOT_SUPPORTED_ERR;
438         return 0;
439     }
440     return new ProcessingInstruction(this, target, data);
441 }
442
443 PassRefPtr<EntityReference> Document::createEntityReference(const String &name, ExceptionCode& ec)
444 {
445     if (!isValidName(name)) {
446         ec = INVALID_CHARACTER_ERR;
447         return 0;
448     }
449     if (isHTMLDocument()) {
450         ec = NOT_SUPPORTED_ERR;
451         return 0;
452     }
453     return new EntityReference(this, name.impl());
454 }
455
456 PassRefPtr<EditingText> Document::createEditingTextNode(const String &text)
457 {
458     return new EditingText(this, text);
459 }
460
461 PassRefPtr<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
462 {
463     return new CSSMutableStyleDeclaration;
464 }
465
466 PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCode& ec)
467 {
468     ec = 0;
469     
470     if (!importedNode) {
471         ec = NOT_SUPPORTED_ERR;
472         return 0;
473     }
474
475     switch (importedNode->nodeType()) {
476         case TEXT_NODE:
477             return createTextNode(importedNode->nodeValue());
478         case CDATA_SECTION_NODE:
479             return createCDATASection(importedNode->nodeValue(), ec);
480         case ENTITY_REFERENCE_NODE:
481             return createEntityReference(importedNode->nodeName(), ec);
482         case PROCESSING_INSTRUCTION_NODE:
483             return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), ec);
484         case COMMENT_NODE:
485             return createComment(importedNode->nodeValue());
486         case ELEMENT_NODE: {
487             Element *oldElement = static_cast<Element *>(importedNode);
488             RefPtr<Element> newElement = createElementNS(oldElement->namespaceURI(), oldElement->tagQName().toString(), ec);
489                         
490             if (ec != 0)
491                 return 0;
492
493             NamedAttrMap* attrs = oldElement->attributes(true);
494             if (attrs) {
495                 unsigned length = attrs->length();
496                 for (unsigned i = 0; i < length; i++) {
497                     Attribute* attr = attrs->attributeItem(i);
498                     newElement->setAttribute(attr->name(), attr->value().impl(), ec);
499                     if (ec != 0)
500                         return 0;
501                 }
502             }
503
504             newElement->copyNonAttributeProperties(oldElement);
505
506             if (deep) {
507                 for (Node* oldChild = oldElement->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
508                     RefPtr<Node> newChild = importNode(oldChild, true, ec);
509                     if (ec != 0)
510                         return 0;
511                     newElement->appendChild(newChild.release(), ec);
512                     if (ec != 0)
513                         return 0;
514                 }
515             }
516
517             return newElement.release();
518         }
519         case ATTRIBUTE_NODE:
520         case ENTITY_NODE:
521         case DOCUMENT_NODE:
522         case DOCUMENT_TYPE_NODE:
523         case DOCUMENT_FRAGMENT_NODE:
524         case NOTATION_NODE:
525         case XPATH_NAMESPACE_NODE:
526             break;
527     }
528
529     ec = NOT_SUPPORTED_ERR;
530     return 0;
531 }
532
533
534 PassRefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
535 {
536     if (!source) {
537         ec = NOT_SUPPORTED_ERR;
538         return 0;
539     }
540     
541     switch (source->nodeType()) {
542         case ENTITY_NODE:
543         case NOTATION_NODE:
544         case DOCUMENT_NODE:
545         case DOCUMENT_TYPE_NODE:
546         case XPATH_NAMESPACE_NODE:
547             ec = NOT_SUPPORTED_ERR;
548             return 0;            
549         case ATTRIBUTE_NODE: {                   
550             Attr* attr = static_cast<Attr*>(source.get());
551             if (attr->ownerElement())
552                 attr->ownerElement()->removeAttributeNode(attr, ec);
553             attr->m_specified = true;
554             break;
555         }       
556         default:
557             if (source->parentNode())
558                 source->parentNode()->removeChild(source.get(), ec);
559     }
560                 
561     for (Node* node = source.get(); node; node = node->traverseNextNode(source.get())) {
562         KJS::ScriptInterpreter::updateDOMNodeDocument(node, node->document(), this);
563         node->setDocument(this);
564     }
565
566     return source;
567 }
568
569 PassRefPtr<Element> Document::createElementNS(const String &_namespaceURI, const String &qualifiedName, ExceptionCode& ec)
570 {
571     // FIXME: We'd like a faster code path that skips this check for calls from inside the engine where the name is known to be valid.
572     String prefix, localName;
573     if (!parseQualifiedName(qualifiedName, prefix, localName)) {
574         ec = INVALID_CHARACTER_ERR;
575         return 0;
576     }
577
578     RefPtr<Element> e;
579     QualifiedName qName = QualifiedName(AtomicString(prefix), AtomicString(localName), AtomicString(_namespaceURI));
580     
581     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
582     if (_namespaceURI == xhtmlNamespaceURI) {
583         e = HTMLElementFactory::createHTMLElement(qName.localName(), this, 0, false);
584         if (e && !prefix.isNull()) {
585             e->setPrefix(qName.prefix(), ec);
586             if (ec)
587                 return 0;
588         }
589     }
590 #if SVG_SUPPORT
591     else if (_namespaceURI == WebCore::SVGNames::svgNamespaceURI)
592         e = WebCore::SVGElementFactory::createSVGElement(qName, this, false);
593 #endif
594     
595     if (!e)
596         e = new Element(qName, document());
597     
598     return e.release();
599 }
600
601 Element *Document::getElementById(const AtomicString& elementId) const
602 {
603     if (elementId.length() == 0)
604         return 0;
605
606     Element *element = m_elementsById.get(elementId.impl());
607     if (element)
608         return element;
609         
610     if (m_duplicateIds.contains(elementId.impl())) {
611         for (Node *n = traverseNextNode(); n != 0; n = n->traverseNextNode()) {
612             if (n->isElementNode()) {
613                 element = static_cast<Element*>(n);
614                 if (element->hasID() && element->getAttribute(idAttr) == elementId) {
615                     m_duplicateIds.remove(elementId.impl());
616                     m_elementsById.set(elementId.impl(), element);
617                     return element;
618                 }
619             }
620         }
621     }
622     return 0;
623 }
624
625 String Document::readyState() const
626 {
627     if (Frame* f = frame()) {
628         if (f->isComplete()) 
629             return "complete";
630         if (parsing()) 
631             return "loading";
632       return "loaded";
633       // FIXME: What does "interactive" mean?
634       // FIXME: Missing support for "uninitialized".
635     }
636     return String();
637 }
638
639 String Document::inputEncoding() const
640 {
641     if (Decoder* d = decoder())
642         return d->encodingName();
643     return String();
644 }
645
646 String Document::defaultCharset() const
647 {
648     if (Frame* f = frame())
649         return f->settings()->encoding();
650     return String();
651 }
652
653 void Document::setCharset(const String& charset)
654 {
655     if (!decoder())
656         return;
657     decoder()->setEncodingName(charset.deprecatedString().ascii(), Decoder::UserChosenEncoding);
658 }
659
660 Element* Document::elementFromPoint(int x, int y) const
661 {
662     if (!renderer())
663         return 0;
664
665     RenderObject::NodeInfo nodeInfo(true, true);
666     renderer()->layer()->hitTest(nodeInfo, IntPoint(x, y)); 
667
668     Node* n = nodeInfo.innerNode();
669     while (n && !n->isElementNode())
670         n = n->parentNode();
671     if (n)
672         n = n->shadowAncestorNode();
673     return static_cast<Element*>(n);
674 }
675
676 void Document::addElementById(const AtomicString& elementId, Element* element)
677 {
678     if (!m_elementsById.contains(elementId.impl()))
679         m_elementsById.set(elementId.impl(), element);
680     else
681         m_duplicateIds.add(elementId.impl());
682 }
683
684 void Document::removeElementById(const AtomicString& elementId, Element* element)
685 {
686     if (m_elementsById.get(elementId.impl()) == element)
687         m_elementsById.remove(elementId.impl());
688     else
689         m_duplicateIds.remove(elementId.impl());
690 }
691
692 Element* Document::getElementByAccessKey(const String& key) const
693 {
694     if (key.isEmpty())
695         return 0;
696     if (!m_accessKeyMapValid) {
697         for (Node* n = firstChild(); n; n = n->traverseNextNode()) {
698             if (!n->isElementNode())
699                 continue;
700             Element* element = static_cast<Element*>(n);
701             const AtomicString& accessKey = element->getAttribute(accesskeyAttr);
702             if (!accessKey.isEmpty())
703                 m_elementsByAccessKey.set(accessKey.impl(), element);
704         }
705         m_accessKeyMapValid = true;
706     }
707     return m_elementsByAccessKey.get(key.impl());
708 }
709
710 void Document::updateTitle()
711 {
712     if (Frame* f = frame())
713         f->setTitle(m_title);
714 }
715
716 void Document::setTitle(const String& title, Node* titleElement)
717 {
718     if (!titleElement) {
719         // Title set by JavaScript -- overrides any title elements.
720         m_titleSetExplicitly = true;
721         m_titleElement = 0;
722     } else if (titleElement != m_titleElement) {
723         if (m_titleElement)
724             // Only allow the first title element to change the title -- others have no effect.
725             return;
726         m_titleElement = titleElement;
727     }
728
729     if (m_title == title)
730         return;
731
732     m_title = title;
733     updateTitle();
734 }
735
736 void Document::removeTitle(Node* titleElement)
737 {
738     if (m_titleElement != titleElement)
739         return;
740
741     // FIXME: Ideally we might want this to search for the first remaining title element, and use it.
742     m_titleElement = 0;
743
744     if (!m_title.isEmpty()) {
745         m_title = "";
746         updateTitle();
747     }
748 }
749
750 String Document::nodeName() const
751 {
752     return "#document";
753 }
754
755 Node::NodeType Document::nodeType() const
756 {
757     return DOCUMENT_NODE;
758 }
759
760 Frame* Document::frame() const 
761 {
762     return m_view ? m_view->frame() : 0; 
763 }
764
765 PassRefPtr<Range> Document::createRange()
766 {
767     return new Range(this);
768 }
769
770 PassRefPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, 
771     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
772 {
773     if (!root) {
774         ec = NOT_SUPPORTED_ERR;
775         return 0;
776     }
777     return new NodeIterator(root, whatToShow, filter, expandEntityReferences);
778 }
779
780 PassRefPtr<TreeWalker> Document::createTreeWalker(Node *root, unsigned whatToShow, 
781     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
782 {
783     if (!root) {
784         ec = NOT_SUPPORTED_ERR;
785         return 0;
786     }
787     return new TreeWalker(root, whatToShow, filter, expandEntityReferences);
788 }
789
790 void Document::setDocumentChanged(bool b)
791 {
792     if (b) {
793         if (!m_docChanged) {
794             if (!changedDocuments)
795                 changedDocuments = new DeprecatedPtrList<Document>;
796             changedDocuments->append(this);
797         }
798         if (m_accessKeyMapValid) {
799             m_accessKeyMapValid = false;
800             m_elementsByAccessKey.clear();
801         }
802     } else {
803         if (m_docChanged && changedDocuments)
804             changedDocuments->remove(this);
805     }
806
807     m_docChanged = b;
808 }
809
810 void Document::recalcStyle(StyleChange change)
811 {
812     if (m_inStyleRecalc)
813         return; // Guard against re-entrancy. -dwh
814         
815     m_inStyleRecalc = true;
816     
817     ASSERT(!renderer() || renderArena());
818     if (!renderer() || !renderArena())
819         goto bail_out;
820
821     if (change == Force) {
822         RenderStyle* oldStyle = renderer()->style();
823         if (oldStyle)
824             oldStyle->ref();
825         RenderStyle* _style = new (m_renderArena) RenderStyle();
826         _style->ref();
827         _style->setDisplay(BLOCK);
828         _style->setVisuallyOrdered(visuallyOrdered);
829         // ### make the font stuff _really_ work!!!!
830
831         FontDescription fontDescription;
832         fontDescription.setUsePrinterFont(printing());
833         if (m_view) {
834             const KHTMLSettings *settings = m_view->frame()->settings();
835             if (printing() && !settings->shouldPrintBackgrounds())
836                 _style->setForceBackgroundsToWhite(true);
837             const AtomicString& stdfont = settings->stdFontName();
838             if (!stdfont.isEmpty()) {
839                 fontDescription.firstFamily().setFamily(stdfont);
840                 fontDescription.firstFamily().appendFamily(0);
841             }
842             m_styleSelector->setFontSize(fontDescription, m_styleSelector->fontSizeForKeyword(CSS_VAL_MEDIUM, inCompatMode()));
843         }
844
845         _style->setFontDescription(fontDescription);
846         _style->font().update();
847         if (inCompatMode())
848             _style->setHtmlHacks(true); // enable html specific rendering tricks
849
850         StyleChange ch = diff(_style, oldStyle);
851         if (renderer() && ch != NoChange)
852             renderer()->setStyle(_style);
853         if (change != Force)
854             change = ch;
855
856         _style->deref(m_renderArena);
857         if (oldStyle)
858             oldStyle->deref(m_renderArena);
859     }
860
861     for (Node* n = fastFirstChild(); n; n = n->nextSibling())
862         if (change >= Inherit || n->hasChangedChild() || n->changed())
863             n->recalcStyle(change);
864
865     if (changed() && m_view)
866         m_view->layout();
867
868 bail_out:
869     setChanged(false);
870     setHasChangedChild(false);
871     setDocumentChanged(false);
872     
873     m_inStyleRecalc = false;
874     
875     // If we wanted to emit the implicitClose() during recalcStyle, do so now that we're finished.
876     if (m_closeAfterStyleRecalc) {
877         m_closeAfterStyleRecalc = false;
878         implicitClose();
879     }
880 }
881
882 void Document::updateRendering()
883 {
884     if (hasChangedChild())
885         recalcStyle(NoChange);
886 }
887
888 void Document::updateDocumentsRendering()
889 {
890     if (!changedDocuments)
891         return;
892
893     while (Document* doc = changedDocuments->take()) {
894         doc->m_docChanged = false;
895         doc->updateRendering();
896     }
897 }
898
899 void Document::updateLayout()
900 {
901     // FIXME: Dave Hyatt's pretty sure we can remove this because layout calls recalcStyle as needed.
902     updateRendering();
903
904     // Only do a layout if changes have occurred that make it necessary.      
905     if (m_view && renderer() && (m_view->layoutPending() || renderer()->needsLayout()))
906         m_view->layout();
907 }
908
909 // FIXME: This is a bad idea and needs to be removed eventually.
910 // Other browsers load stylesheets before they continue parsing the web page.
911 // Since we don't, we can run JavaScript code that needs answers before the
912 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
913 // lets us get reasonable answers. The long term solution to this problem is
914 // to instead suspend JavaScript execution.
915 void Document::updateLayoutIgnorePendingStylesheets()
916 {
917     bool oldIgnore = m_ignorePendingStylesheets;
918     
919     if (!haveStylesheetsLoaded()) {
920         m_ignorePendingStylesheets = true;
921         updateStyleSelector();    
922     }
923
924     updateLayout();
925
926     m_ignorePendingStylesheets = oldIgnore;
927 }
928
929 void Document::attach()
930 {
931     assert(!attached());
932     assert(!m_inPageCache);
933
934     if (!m_renderArena)
935         m_renderArena = new RenderArena();
936     
937     // Create the rendering tree
938     setRenderer(new (m_renderArena) RenderView(this, m_view));
939
940     recalcStyle(Force);
941
942     RenderObject* render = renderer();
943     setRenderer(0);
944
945     ContainerNode::attach();
946
947     setRenderer(render);
948 }
949
950 void Document::detach()
951 {
952     RenderObject* render = renderer();
953
954     // indicate destruction mode,  i.e. attached() but renderer == 0
955     setRenderer(0);
956     
957     if (m_inPageCache) {
958         if (render)
959             getAccObjectCache()->remove(render);
960         return;
961     }
962
963     // Empty out these lists as a performance optimization, since detaching
964     // all the individual render objects will cause all the RenderImage
965     // objects to remove themselves from the lists.
966     m_imageLoadEventDispatchSoonList.clear();
967     m_imageLoadEventDispatchingList.clear();
968     
969     m_hoverNode = 0;
970     m_focusNode = 0;
971     m_activeNode = 0;
972
973     ContainerNode::detach();
974
975     if (render)
976         render->destroy();
977
978     m_view = 0;
979     
980     if (m_renderArena) {
981         delete m_renderArena;
982         m_renderArena = 0;
983     }
984 }
985
986 void Document::removeAllEventListenersFromAllNodes()
987 {
988     m_windowEventListeners.clear();
989     removeAllDisconnectedNodeEventListeners();
990     for (Node *n = this; n; n = n->traverseNextNode()) {
991         if (!n->isEventTargetNode())
992             continue;
993         EventTargetNodeCast(n)->removeAllEventListeners();
994     }
995 }
996
997 void Document::registerDisconnectedNodeWithEventListeners(Node* node)
998 {
999     m_disconnectedNodesWithEventListeners.add(node);
1000 }
1001
1002 void Document::unregisterDisconnectedNodeWithEventListeners(Node* node)
1003 {
1004     m_disconnectedNodesWithEventListeners.remove(node);
1005 }
1006
1007 void Document::removeAllDisconnectedNodeEventListeners()
1008 {
1009     HashSet<Node*>::iterator end = m_disconnectedNodesWithEventListeners.end();
1010     for (HashSet<Node*>::iterator i = m_disconnectedNodesWithEventListeners.begin(); i != end; ++i)
1011         EventTargetNodeCast(*i)->removeAllEventListeners();
1012     m_disconnectedNodesWithEventListeners.clear();
1013 }
1014
1015 AccessibilityObjectCache* Document::getAccObjectCache() const
1016 {
1017     // The only document that actually has a AccessibilityObjectCache is the top-level
1018     // document.  This is because we need to be able to get from any WebCoreAXObject
1019     // to any other WebCoreAXObject on the same page.  Using a single cache allows
1020     // lookups across nested webareas (i.e. multiple documents).
1021     
1022     if (m_accCache) {
1023         // return already known top-level cache
1024         if (!ownerElement())
1025             return m_accCache;
1026         
1027         // In some pages with frames, the cache is created before the sub-webarea is
1028         // inserted into the tree.  Here, we catch that case and just toss the old
1029         // cache and start over.
1030         delete m_accCache;
1031         m_accCache = 0;
1032     }
1033
1034     // ask the top-level document for its cache
1035     Document* doc = topDocument();
1036     if (doc != this)
1037         return doc->getAccObjectCache();
1038     
1039     // this is the top-level document, so install a new cache
1040     m_accCache = new AccessibilityObjectCache;
1041     return m_accCache;
1042 }
1043
1044 void Document::setVisuallyOrdered()
1045 {
1046     visuallyOrdered = true;
1047     if (renderer())
1048         renderer()->style()->setVisuallyOrdered(true);
1049 }
1050
1051 void Document::updateSelection()
1052 {
1053     if (!renderer())
1054         return;
1055     
1056     RenderView *canvas = static_cast<RenderView*>(renderer());
1057     SelectionController s = frame()->selection();
1058     if (s.isNone())
1059         return;
1060         
1061     if (!s.isRange())
1062         canvas->clearSelection();
1063     else {
1064         // Use the rightmost candidate for the start of the selection, and the leftmost candidate for the end of the selection.
1065         // Example: foo <a>bar</a>.  Imagine that a line wrap occurs after 'foo', and that 'bar' is selected.   If we pass [foo, 3]
1066         // as the start of the selection, the selection painting code will think that content on the line containing 'foo' is selected
1067         // and will fill the gap before 'bar'.
1068         Position startPos = s.selection().visibleStart().deepEquivalent();
1069         if (startPos.downstream().inRenderedContent())
1070             startPos = startPos.downstream();
1071         Position endPos = s.selection().visibleEnd().deepEquivalent();
1072         if (endPos.upstream().inRenderedContent())
1073             endPos = endPos.upstream();
1074             
1075         if (startPos.isNotNull() && endPos.isNotNull()) {
1076             RenderObject *startRenderer = startPos.node()->renderer();
1077             RenderObject *endRenderer = endPos.node()->renderer();
1078             static_cast<RenderView*>(renderer())->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
1079         }
1080     }
1081     
1082 #if __APPLE__
1083     // FIXME: We shouldn't post this AX notification here since updateSelection() is called far to often: every time Safari gains
1084     // or loses focus, and once for every low level change to the selection during an editing operation.
1085     // FIXME: We no longer blow away the selection before starting an editing operation, so the isNotNull checks below are no 
1086     // longer a correct way to check for user-level selection changes.
1087     if (AccessibilityObjectCache::accessibilityEnabled() && s.start().isNotNull() && s.end().isNotNull()) {
1088         getAccObjectCache()->postNotificationToTopWebArea(renderer(), "AXSelectedTextChanged");
1089     }
1090 #endif
1091 }
1092
1093 Tokenizer *Document::createTokenizer()
1094 {
1095     return newXMLTokenizer(this, m_view);
1096 }
1097
1098 void Document::open()
1099 {
1100     if ((frame() && frame()->isLoadingMainResource()) || (tokenizer() && tokenizer()->executingScript()))
1101         return;
1102
1103     implicitOpen();
1104
1105     if (frame())
1106         frame()->didExplicitOpen();
1107
1108     // This is work that we should probably do in clear(), but we can't have it
1109     // happen when implicitOpen() is called unless we reorganize Frame code.
1110     setURL(DeprecatedString());
1111     if (Document *parent = parentDocument())
1112         setBaseURL(parent->baseURL());
1113 }
1114
1115 void Document::cancelParsing()
1116 {
1117     if (m_tokenizer) {
1118         // We have to clear the tokenizer to avoid possibly triggering
1119         // the onload handler when closing as a side effect of a cancel-style
1120         // change, such as opening a new document or closing the window while
1121         // still parsing
1122         delete m_tokenizer;
1123         m_tokenizer = 0;
1124         close();
1125     }
1126 }
1127
1128 void Document::implicitOpen()
1129 {
1130     cancelParsing();
1131
1132     clear();
1133     m_tokenizer = createTokenizer();
1134     setParsing(true);
1135 }
1136
1137 HTMLElement* Document::body()
1138 {
1139     Node *de = documentElement();
1140     if (!de)
1141         return 0;
1142     
1143     // try to prefer a FRAMESET element over BODY
1144     Node* body = 0;
1145     for (Node* i = de->firstChild(); i; i = i->nextSibling()) {
1146         if (i->hasTagName(framesetTag))
1147             return static_cast<HTMLElement*>(i);
1148         
1149         if (i->hasTagName(bodyTag))
1150             body = i;
1151     }
1152     return static_cast<HTMLElement *>(body);
1153 }
1154
1155 void Document::close()
1156 {
1157     if (frame())
1158         frame()->endIfNotLoading();
1159     implicitClose();
1160 }
1161
1162 void Document::implicitClose()
1163 {
1164     // If we're in the middle of recalcStyle, we need to defer the close until the style information is accurate and all elements are re-attached.
1165     if (m_inStyleRecalc) {
1166         m_closeAfterStyleRecalc = true;
1167         return;
1168     }
1169
1170     bool wasLocationChangePending = frame() && frame()->isScheduledLocationChangePending();
1171     bool doload = !parsing() && m_tokenizer && !m_processingLoadEvent && !wasLocationChangePending;
1172     
1173     if (!doload)
1174         return;
1175
1176     m_processingLoadEvent = true;
1177
1178     // We have to clear the tokenizer, in case someone document.write()s from the
1179     // onLoad event handler, as in Radar 3206524.
1180     delete m_tokenizer;
1181     m_tokenizer = 0;
1182
1183     // Create a body element if we don't already have one.
1184     // In the case of Radar 3758785, the window.onload was set in some javascript, but never fired because there was no body.  
1185     // This behavior now matches Firefox and IE.
1186     HTMLElement *body = this->body();
1187     if (!body && isHTMLDocument()) {
1188         Node *de = documentElement();
1189         if (de) {
1190             body = new HTMLBodyElement(this);
1191             ExceptionCode ec = 0;
1192             de->appendChild(body, ec);
1193             if (ec != 0)
1194                 body = 0;
1195         }
1196     }
1197     
1198     dispatchImageLoadEventsNow();
1199     this->dispatchWindowEvent(loadEvent, false, false);
1200     if (Frame *p = frame())
1201         p->handledOnloadEvents();
1202 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1203     if (!ownerElement())
1204         printf("onload fired at %d\n", elapsedTime());
1205 #endif
1206
1207     m_processingLoadEvent = false;
1208
1209     // Make sure both the initial layout and reflow happen after the onload
1210     // fires. This will improve onload scores, and other browsers do it.
1211     // If they wanna cheat, we can too. -dwh
1212
1213     if (frame() && frame()->isScheduledLocationChangePending() && elapsedTime() < cLayoutScheduleThreshold) {
1214         // Just bail out. Before or during the onload we were shifted to another page.
1215         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
1216         view()->unscheduleRelayout();
1217         return;
1218     }
1219
1220     if (frame())
1221         frame()->checkEmitLoadEvent();
1222
1223     // Now do our painting/layout, but only if we aren't in a subframe or if we're in a subframe
1224     // that has been sized already.  Otherwise, our view size would be incorrect, so doing any 
1225     // layout/painting now would be pointless.
1226     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
1227         updateRendering();
1228         
1229         // Always do a layout after loading if needed.
1230         if (view() && renderer() && (!renderer()->firstChild() || renderer()->needsLayout()))
1231             view()->layout();
1232     }
1233 #if __APPLE__
1234     if (renderer() && AccessibilityObjectCache::accessibilityEnabled())
1235         getAccObjectCache()->postNotification(renderer(), "AXLoadComplete");
1236 #endif
1237
1238 #if SVG_SUPPORT
1239     // FIXME: Officially, time 0 is when the outermost <svg> receives its
1240     // SVGLoad event, but we don't implement those yet.  This is close enough
1241     // for now.  In some cases we should have fired earlier.
1242     if (svgExtensions())
1243         accessSVGExtensions()->startAnimations();
1244 #endif
1245 }
1246
1247 void Document::setParsing(bool b)
1248 {
1249     m_bParsing = b;
1250     if (!m_bParsing && view())
1251         view()->scheduleRelayout();
1252
1253 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1254     if (!ownerElement() && !m_bParsing)
1255         printf("Parsing finished at %d\n", elapsedTime());
1256 #endif
1257 }
1258
1259 bool Document::shouldScheduleLayout()
1260 {
1261     // We can update layout if:
1262     // (a) we actually need a layout
1263     // (b) our stylesheets are all loaded
1264     // (c) we have a <body>
1265     return (renderer() && renderer()->needsLayout() && haveStylesheetsLoaded() &&
1266             documentElement() && documentElement()->renderer() &&
1267             (!documentElement()->hasTagName(htmlTag) || body()));
1268 }
1269
1270 int Document::minimumLayoutDelay()
1271 {
1272     if (m_overMinimumLayoutThreshold)
1273         return 0;
1274     
1275     int elapsed = elapsedTime();
1276     m_overMinimumLayoutThreshold = elapsed > cLayoutScheduleThreshold;
1277     
1278     // We'll want to schedule the timer to fire at the minimum layout threshold.
1279     return max(0, cLayoutScheduleThreshold - elapsed);
1280 }
1281
1282 int Document::elapsedTime() const
1283 {
1284     return static_cast<int>((currentTime() - m_startTime) * 1000);
1285 }
1286
1287 void Document::write(const String &text)
1288 {
1289     write(text.deprecatedString());
1290 }
1291
1292 void Document::write(const DeprecatedString &text)
1293 {
1294 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1295     if (!ownerElement())
1296         printf("Beginning a document.write at %d\n", elapsedTime());
1297 #endif
1298     
1299     if (!m_tokenizer) {
1300         open();
1301         assert(m_tokenizer);
1302         if (!m_tokenizer)
1303             return;
1304         write(DeprecatedString("<html>"));
1305     }
1306     m_tokenizer->write(text, false);
1307     
1308 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1309     if (!ownerElement())
1310         printf("Ending a document.write at %d\n", elapsedTime());
1311 #endif    
1312 }
1313
1314 void Document::writeln(const String &text)
1315 {
1316     write(text);
1317     write(String("\n"));
1318 }
1319
1320 void Document::finishParsing()
1321 {
1322 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1323     if (!ownerElement())
1324         printf("Received all data at %d\n", elapsedTime());
1325 #endif
1326     
1327     // Let the tokenizer go through as much data as it can.  There will be three possible outcomes after
1328     // finish() is called:
1329     // (1) All remaining data is parsed, document isn't loaded yet
1330     // (2) All remaining data is parsed, document is loaded, tokenizer gets deleted
1331     // (3) Data is still remaining to be parsed.
1332     if (m_tokenizer)
1333         m_tokenizer->finish();
1334 }
1335
1336 void Document::clear()
1337 {
1338     delete m_tokenizer;
1339     m_tokenizer = 0;
1340
1341     removeChildren();
1342     DeprecatedPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
1343     for (; it.current();)
1344         m_windowEventListeners.removeRef(it.current());
1345 }
1346
1347 void Document::setURL(const DeprecatedString& url)
1348 {
1349     m_url = url;
1350     if (m_styleSelector)
1351         m_styleSelector->setEncodedURL(m_url);
1352 }
1353
1354 void Document::setStyleSheet(const String &url, const String &sheet)
1355 {
1356     m_sheet = new CSSStyleSheet(this, url);
1357     m_sheet->parseString(sheet);
1358     m_loadingSheet = false;
1359
1360     updateStyleSelector();
1361 }
1362
1363 void Document::setUserStyleSheet(const String& sheet)
1364 {
1365     if (m_usersheet != sheet) {
1366         m_usersheet = sheet;
1367         updateStyleSelector();
1368     }
1369 }
1370
1371 CSSStyleSheet* Document::elementSheet()
1372 {
1373     if (!m_elemSheet)
1374         m_elemSheet = new CSSStyleSheet(this, baseURL());
1375     return m_elemSheet.get();
1376 }
1377
1378 void Document::determineParseMode(const DeprecatedString &/*str*/)
1379 {
1380     // For XML documents use strict parse mode.  HTML docs will override this method to
1381     // determine their parse mode.
1382     pMode = Strict;
1383     hMode = XHtml;
1384 }
1385
1386 Node *Document::nextFocusNode(Node *fromNode)
1387 {
1388     unsigned short fromTabIndex;
1389
1390     if (!fromNode) {
1391         // No starting node supplied; begin with the top of the document
1392         Node *n;
1393
1394         int lowestTabIndex = 65535;
1395         for (n = this; n != 0; n = n->traverseNextNode()) {
1396             if (n->isKeyboardFocusable()) {
1397                 if ((n->tabIndex() > 0) && (n->tabIndex() < lowestTabIndex))
1398                     lowestTabIndex = n->tabIndex();
1399             }
1400         }
1401
1402         if (lowestTabIndex == 65535)
1403             lowestTabIndex = 0;
1404
1405         // Go to the first node in the document that has the desired tab index
1406         for (n = this; n != 0; n = n->traverseNextNode()) {
1407             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestTabIndex))
1408                 return n;
1409         }
1410
1411         return 0;
1412     }
1413     else {
1414         fromTabIndex = fromNode->tabIndex();
1415     }
1416
1417     if (fromTabIndex == 0) {
1418         // Just need to find the next selectable node after fromNode (in document order) that doesn't have a tab index
1419         Node *n = fromNode->traverseNextNode();
1420         while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1421             n = n->traverseNextNode();
1422         return n;
1423     }
1424     else {
1425         // Find the lowest tab index out of all the nodes except fromNode, that is greater than or equal to fromNode's
1426         // tab index. For nodes with the same tab index as fromNode, we are only interested in those that come after
1427         // fromNode in document order.
1428         // If we don't find a suitable tab index, the next focus node will be one with a tab index of 0.
1429         unsigned short lowestSuitableTabIndex = 65535;
1430         Node *n;
1431
1432         bool reachedFromNode = false;
1433         for (n = this; n != 0; n = n->traverseNextNode()) {
1434             if (n->isKeyboardFocusable() &&
1435                 ((reachedFromNode && (n->tabIndex() >= fromTabIndex)) ||
1436                  (!reachedFromNode && (n->tabIndex() > fromTabIndex))) &&
1437                 (n->tabIndex() < lowestSuitableTabIndex) &&
1438                 (n != fromNode)) {
1439
1440                 // We found a selectable node with a tab index at least as high as fromNode's. Keep searching though,
1441                 // as there may be another node which has a lower tab index but is still suitable for use.
1442                 lowestSuitableTabIndex = n->tabIndex();
1443             }
1444
1445             if (n == fromNode)
1446                 reachedFromNode = true;
1447         }
1448
1449         if (lowestSuitableTabIndex == 65535) {
1450             // No next node with a tab index -> just take first node with tab index of 0
1451             Node *n = this;
1452             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1453                 n = n->traverseNextNode();
1454             return n;
1455         }
1456
1457         // Search forwards from fromNode
1458         for (n = fromNode->traverseNextNode(); n != 0; n = n->traverseNextNode()) {
1459             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1460                 return n;
1461         }
1462
1463         // The next node isn't after fromNode, start from the beginning of the document
1464         for (n = this; n != fromNode; n = n->traverseNextNode()) {
1465             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1466                 return n;
1467         }
1468
1469         assert(false); // should never get here
1470         return 0;
1471     }
1472 }
1473
1474 Node *Document::previousFocusNode(Node *fromNode)
1475 {
1476     Node *lastNode = this;
1477     while (lastNode->lastChild())
1478         lastNode = lastNode->lastChild();
1479
1480     if (!fromNode) {
1481         // No starting node supplied; begin with the very last node in the document
1482         Node *n;
1483
1484         int highestTabIndex = 0;
1485         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1486             if (n->isKeyboardFocusable()) {
1487                 if (n->tabIndex() == 0)
1488                     return n;
1489                 else if (n->tabIndex() > highestTabIndex)
1490                     highestTabIndex = n->tabIndex();
1491             }
1492         }
1493
1494         // No node with a tab index of 0; just go to the last node with the highest tab index
1495         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1496             if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1497                 return n;
1498         }
1499
1500         return 0;
1501     }
1502     else {
1503         unsigned short fromTabIndex = fromNode->tabIndex();
1504
1505         if (fromTabIndex == 0) {
1506             // Find the previous selectable node before fromNode (in document order) that doesn't have a tab index
1507             Node *n = fromNode->traversePreviousNode();
1508             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1509                 n = n->traversePreviousNode();
1510             if (n)
1511                 return n;
1512
1513             // No previous nodes with a 0 tab index, go to the last node in the document that has the highest tab index
1514             int highestTabIndex = 0;
1515             for (n = this; n != 0; n = n->traverseNextNode()) {
1516                 if (n->isKeyboardFocusable() && (n->tabIndex() > highestTabIndex))
1517                     highestTabIndex = n->tabIndex();
1518             }
1519
1520             if (highestTabIndex == 0)
1521                 return 0;
1522
1523             for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1524                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1525                     return n;
1526             }
1527
1528             assert(false); // should never get here
1529             return 0;
1530         }
1531         else {
1532             // Find the lowest tab index out of all the nodes except fromNode, that is less than or equal to fromNode's
1533             // tab index. For nodes with the same tab index as fromNode, we are only interested in those before
1534             // fromNode.
1535             // If we don't find a suitable tab index, then there will be no previous focus node.
1536             unsigned short highestSuitableTabIndex = 0;
1537             Node *n;
1538
1539             bool reachedFromNode = false;
1540             for (n = this; n != 0; n = n->traverseNextNode()) {
1541                 if (n->isKeyboardFocusable() &&
1542                     ((!reachedFromNode && (n->tabIndex() <= fromTabIndex)) ||
1543                      (reachedFromNode && (n->tabIndex() < fromTabIndex)))  &&
1544                     (n->tabIndex() > highestSuitableTabIndex) &&
1545                     (n != fromNode)) {
1546
1547                     // We found a selectable node with a tab index no higher than fromNode's. Keep searching though, as
1548                     // there may be another node which has a higher tab index but is still suitable for use.
1549                     highestSuitableTabIndex = n->tabIndex();
1550                 }
1551
1552                 if (n == fromNode)
1553                     reachedFromNode = true;
1554             }
1555
1556             if (highestSuitableTabIndex == 0) {
1557                 // No previous node with a tab index. Since the order specified by HTML is nodes with tab index > 0
1558                 // first, this means that there is no previous node.
1559                 return 0;
1560             }
1561
1562             // Search backwards from fromNode
1563             for (n = fromNode->traversePreviousNode(); n != 0; n = n->traversePreviousNode()) {
1564                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1565                     return n;
1566             }
1567             // The previous node isn't before fromNode, start from the end of the document
1568             for (n = lastNode; n != fromNode; n = n->traversePreviousNode()) {
1569                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1570                     return n;
1571             }
1572
1573             assert(false); // should never get here
1574             return 0;
1575         }
1576     }
1577 }
1578
1579 int Document::nodeAbsIndex(Node *node)
1580 {
1581     assert(node->document() == this);
1582
1583     int absIndex = 0;
1584     for (Node *n = node; n && n != this; n = n->traversePreviousNode())
1585         absIndex++;
1586     return absIndex;
1587 }
1588
1589 Node *Document::nodeWithAbsIndex(int absIndex)
1590 {
1591     Node *n = this;
1592     for (int i = 0; n && (i < absIndex); i++) {
1593         n = n->traverseNextNode();
1594     }
1595     return n;
1596 }
1597
1598 void Document::processHttpEquiv(const String &equiv, const String &content)
1599 {
1600     assert(!equiv.isNull() && !content.isNull());
1601
1602     Frame *frame = this->frame();
1603
1604     if (equalIgnoringCase(equiv, "default-style")) {
1605         // The preferred style set has been overridden as per section 
1606         // 14.3.2 of the HTML4.0 specification.  We need to update the
1607         // sheet used variable and then update our style selector. 
1608         // For more info, see the test at:
1609         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
1610         // -dwh
1611         m_selectedStylesheetSet = content;
1612         m_preferredStylesheetSet = content;
1613         updateStyleSelector();
1614     } else if (equalIgnoringCase(equiv, "refresh")) {
1615         // get delay and url
1616         DeprecatedString str = content.deprecatedString().stripWhiteSpace();
1617         int pos = str.find(RegularExpression("[;,]"));
1618         if (pos == -1)
1619             pos = str.find(RegularExpression("[ \t]"));
1620
1621         if (pos == -1) // There can be no url (David)
1622         {
1623             bool ok = false;
1624             int delay = 0;
1625             delay = str.toInt(&ok);
1626             // We want a new history item if the refresh timeout > 1 second
1627             if (ok && frame)
1628                 frame->scheduleRedirection(delay, frame->url().url(), delay <= 1);
1629         } else {
1630             double delay = 0;
1631             bool ok = false;
1632             delay = str.left(pos).stripWhiteSpace().toDouble(&ok);
1633
1634             pos++;
1635             while(pos < (int)str.length() && str[pos].isSpace()) pos++;
1636             str = str.mid(pos);
1637             if (str.find("url", 0,  false) == 0)
1638                 str = str.mid(3);
1639             str = str.stripWhiteSpace();
1640             if (str.length() && str[0] == '=')
1641                 str = str.mid(1).stripWhiteSpace();
1642             str = parseURL(String(str)).deprecatedString();
1643             if (ok && frame)
1644                 // We want a new history item if the refresh timeout > 1 second
1645                 frame->scheduleRedirection(delay, completeURL(str), delay <= 1);
1646         }
1647     } else if (equalIgnoringCase(equiv, "expires")) {
1648         DeprecatedString str = content.deprecatedString().stripWhiteSpace();
1649         time_t expire_date = str.toInt();
1650         if (m_docLoader)
1651             m_docLoader->setExpireDate(expire_date);
1652     } else if ((equalIgnoringCase(equiv, "pragma") || equalIgnoringCase(equiv, "cache-control")) && frame) {
1653         DeprecatedString str = content.deprecatedString().lower().stripWhiteSpace();
1654         KURL url = frame->url();
1655     } else if (equalIgnoringCase(equiv, "set-cookie")) {
1656         // ### FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
1657         if (isHTMLDocument())
1658             static_cast<HTMLDocument *>(this)->setCookie(content);
1659     }
1660 }
1661
1662 MouseEventWithHitTestResults Document::prepareMouseEvent(bool readonly, bool active, bool mouseMove,
1663                                                          const IntPoint& point, const PlatformMouseEvent& event)
1664 {
1665     if (!renderer())
1666         return MouseEventWithHitTestResults(event, 0, false);
1667
1668     assert(renderer()->isRenderView());
1669     RenderObject::NodeInfo renderInfo(readonly, active, mouseMove);
1670     renderer()->layer()->hitTest(renderInfo, point);
1671
1672     if (!readonly)
1673         updateRendering();
1674
1675     bool isOverLink = renderInfo.URLElement() && !renderInfo.URLElement()->getAttribute(hrefAttr).isNull();
1676     return MouseEventWithHitTestResults(event, renderInfo.innerNode(), isOverLink);
1677 }
1678
1679 // DOM Section 1.1.1
1680 bool Document::childTypeAllowed(NodeType type)
1681 {
1682     switch (type) {
1683         case ATTRIBUTE_NODE:
1684         case CDATA_SECTION_NODE:
1685         case DOCUMENT_FRAGMENT_NODE:
1686         case DOCUMENT_NODE:
1687         case ENTITY_NODE:
1688         case ENTITY_REFERENCE_NODE:
1689         case NOTATION_NODE:
1690         case TEXT_NODE:
1691         case XPATH_NAMESPACE_NODE:
1692             return false;
1693         case COMMENT_NODE:
1694         case PROCESSING_INSTRUCTION_NODE:
1695             return true;
1696         case DOCUMENT_TYPE_NODE:
1697         case ELEMENT_NODE:
1698             // Documents may contain no more than one of each of these.
1699             // (One Element and one DocumentType.)
1700             for (Node* c = firstChild(); c; c = c->nextSibling())
1701                 if (c->nodeType() == type)
1702                     return false;
1703             return true;
1704     }
1705     return false;
1706 }
1707
1708 PassRefPtr<Node> Document::cloneNode(bool /*deep*/)
1709 {
1710     // Spec says cloning Document nodes is "implementation dependent"
1711     // so we do not support it...
1712     return 0;
1713 }
1714
1715 StyleSheetList* Document::styleSheets()
1716 {
1717     return m_styleSheets.get();
1718 }
1719
1720 String Document::preferredStylesheetSet() const
1721 {
1722   return m_preferredStylesheetSet;
1723 }
1724
1725 String Document::selectedStylesheetSet() const
1726 {
1727   return m_selectedStylesheetSet;
1728 }
1729
1730 void Document::setSelectedStylesheetSet(const String& aString)
1731 {
1732   m_selectedStylesheetSet = aString;
1733   updateStyleSelector();
1734   if (renderer())
1735     renderer()->repaint();
1736 }
1737
1738 // This method is called whenever a top-level stylesheet has finished loading.
1739 void Document::stylesheetLoaded()
1740 {
1741   // Make sure we knew this sheet was pending, and that our count isn't out of sync.
1742   assert(m_pendingStylesheets > 0);
1743
1744   m_pendingStylesheets--;
1745   
1746 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1747   if (!ownerElement())
1748       printf("Stylesheet loaded at time %d. %d stylesheets still remain.\n", elapsedTime(), m_pendingStylesheets);
1749 #endif
1750
1751   updateStyleSelector();    
1752 }
1753
1754 void Document::updateStyleSelector()
1755 {
1756     // Don't bother updating, since we haven't loaded all our style info yet.
1757     if (!haveStylesheetsLoaded())
1758         return;
1759
1760 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1761     if (!ownerElement())
1762         printf("Beginning update of style selector at time %d.\n", elapsedTime());
1763 #endif
1764
1765     recalcStyleSelector();
1766     recalcStyle(Force);
1767
1768 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1769     if (!ownerElement())
1770         printf("Finished update of style selector at time %d\n", elapsedTime());
1771 #endif
1772
1773     if (renderer()) {
1774         renderer()->setNeedsLayoutAndMinMaxRecalc();
1775         if (view())
1776             view()->scheduleRelayout();
1777     }
1778 }
1779
1780
1781 DeprecatedStringList Document::availableStyleSheets() const
1782 {
1783     return m_availableSheets;
1784 }
1785
1786 void Document::recalcStyleSelector()
1787 {
1788     if (!renderer() || !attached())
1789         return;
1790
1791     DeprecatedPtrList<StyleSheet> oldStyleSheets = m_styleSheets->styleSheets;
1792     m_styleSheets->styleSheets.clear();
1793     m_availableSheets.clear();
1794     Node *n;
1795     for (n = this; n; n = n->traverseNextNode()) {
1796         StyleSheet *sheet = 0;
1797
1798         if (n->nodeType() == PROCESSING_INSTRUCTION_NODE)
1799         {
1800             // Processing instruction (XML documents only)
1801             ProcessingInstruction* pi = static_cast<ProcessingInstruction*>(n);
1802             sheet = pi->sheet();
1803 #ifdef KHTML_XSLT
1804             // Don't apply XSL transforms to already transformed documents -- <rdar://problem/4132806>
1805             if (pi->isXSL() && !transformSourceDocument()) {
1806                 // Don't apply XSL transforms until loading is finished.
1807                 if (!parsing())
1808                     applyXSLTransform(pi);
1809                 return;
1810             }
1811 #endif
1812             if (!sheet && !pi->localHref().isEmpty())
1813             {
1814                 // Processing instruction with reference to an element in this document - e.g.
1815                 // <?xml-stylesheet href="#mystyle">, with the element
1816                 // <foo id="mystyle">heading { color: red; }</foo> at some location in
1817                 // the document
1818                 Element* elem = getElementById(pi->localHref().impl());
1819                 if (elem) {
1820                     String sheetText("");
1821                     Node *c;
1822                     for (c = elem->firstChild(); c; c = c->nextSibling()) {
1823                         if (c->nodeType() == TEXT_NODE || c->nodeType() == CDATA_SECTION_NODE)
1824                             sheetText += c->nodeValue();
1825                     }
1826
1827                     CSSStyleSheet *cssSheet = new CSSStyleSheet(this);
1828                     cssSheet->parseString(sheetText);
1829                     pi->setStyleSheet(cssSheet);
1830                     sheet = cssSheet;
1831                 }
1832             }
1833
1834         }
1835         else if (n->isHTMLElement() && (n->hasTagName(linkTag) || n->hasTagName(styleTag))) {
1836             HTMLElement *e = static_cast<HTMLElement *>(n);
1837             DeprecatedString title = e->getAttribute(titleAttr).deprecatedString();
1838             bool enabledViaScript = false;
1839             if (e->hasLocalName(linkTag)) {
1840                 // <LINK> element
1841                 HTMLLinkElement* l = static_cast<HTMLLinkElement*>(n);
1842                 if (l->isLoading() || l->isDisabled())
1843                     continue;
1844                 if (!l->sheet())
1845                     title = DeprecatedString::null;
1846                 enabledViaScript = l->isEnabledViaScript();
1847             }
1848
1849             // Get the current preferred styleset.  This is the
1850             // set of sheets that will be enabled.
1851             if (e->hasLocalName(linkTag))
1852                 sheet = static_cast<HTMLLinkElement*>(n)->sheet();
1853             else
1854                 // <STYLE> element
1855                 sheet = static_cast<HTMLStyleElement*>(n)->sheet();
1856
1857             // Check to see if this sheet belongs to a styleset
1858             // (thus making it PREFERRED or ALTERNATE rather than
1859             // PERSISTENT).
1860             if (!enabledViaScript && !title.isEmpty()) {
1861                 // Yes, we have a title.
1862                 if (m_preferredStylesheetSet.isEmpty()) {
1863                     // No preferred set has been established.  If
1864                     // we are NOT an alternate sheet, then establish
1865                     // us as the preferred set.  Otherwise, just ignore
1866                     // this sheet.
1867                     DeprecatedString rel = e->getAttribute(relAttr).deprecatedString();
1868                     if (e->hasLocalName(styleTag) || !rel.contains("alternate"))
1869                         m_preferredStylesheetSet = m_selectedStylesheetSet = title;
1870                 }
1871                       
1872                 if (!m_availableSheets.contains(title))
1873                     m_availableSheets.append(title);
1874                 
1875                 if (title != m_preferredStylesheetSet)
1876                     sheet = 0;
1877             }
1878         }
1879 #if SVG_SUPPORT
1880         else if (n->isSVGElement() && n->hasTagName(WebCore::SVGNames::styleTag)) {
1881             DeprecatedString title;
1882             // <STYLE> element
1883             WebCore::SVGStyleElement *s = static_cast<WebCore::SVGStyleElement*>(n);
1884             if (!s->isLoading()) {
1885                 sheet = s->sheet();
1886                 if(sheet)
1887                     title = s->getAttribute(WebCore::SVGNames::titleAttr).deprecatedString();
1888             }
1889
1890             if (!title.isEmpty() && m_preferredStylesheetSet.isEmpty())
1891                 m_preferredStylesheetSet = m_selectedStylesheetSet = title;
1892
1893             if (!title.isEmpty()) {
1894                 if (title != m_preferredStylesheetSet)
1895                     sheet = 0; // don't use it
1896
1897                 title = title.replace('&', "&&");
1898
1899                 if (!m_availableSheets.contains(title))
1900                     m_availableSheets.append(title);
1901             }
1902        }
1903 #endif
1904
1905         if (sheet) {
1906             sheet->ref();
1907             m_styleSheets->styleSheets.append(sheet);
1908         }
1909     
1910         // For HTML documents, stylesheets are not allowed within/after the <BODY> tag. So we
1911         // can stop searching here.
1912         if (isHTMLDocument() && n->hasTagName(bodyTag))
1913             break;
1914     }
1915
1916     // De-reference all the stylesheets in the old list
1917     DeprecatedPtrListIterator<StyleSheet> it(oldStyleSheets);
1918     for (; it.current(); ++it)
1919         it.current()->deref();
1920
1921     // Create a new style selector
1922     delete m_styleSelector;
1923     String usersheet = m_usersheet;
1924     if (m_view && m_view->mediaType() == "print")
1925         usersheet += m_printSheet;
1926     m_styleSelector = new CSSStyleSelector(this, usersheet, m_styleSheets.get(), !inCompatMode());
1927     m_styleSelector->setEncodedURL(m_url);
1928     m_styleSelectorDirty = false;
1929 }
1930
1931 void Document::setHoverNode(PassRefPtr<Node> newHoverNode)
1932 {
1933     m_hoverNode = newHoverNode;
1934 }
1935
1936 void Document::setActiveNode(PassRefPtr<Node> newActiveNode)
1937 {
1938     m_activeNode = newActiveNode;
1939 }
1940
1941 void Document::hoveredNodeDetached(Node* node)
1942 {
1943     if (!m_hoverNode || (node != m_hoverNode && (!m_hoverNode->isTextNode() || node != m_hoverNode->parent())))
1944         return;
1945
1946     m_hoverNode = node->parent();
1947     while (m_hoverNode && !m_hoverNode->renderer())
1948         m_hoverNode = m_hoverNode->parent();
1949     if (view())
1950         view()->scheduleHoverStateUpdate();
1951 }
1952
1953 void Document::activeChainNodeDetached(Node* node)
1954 {
1955     if (!m_activeNode || (node != m_activeNode && (!m_activeNode->isTextNode() || node != m_activeNode->parent())))
1956         return;
1957
1958     m_activeNode = node->parent();
1959     while (m_activeNode && !m_activeNode->renderer())
1960         m_activeNode = m_activeNode->parent();
1961 }
1962
1963 bool Document::relinquishesEditingFocus(Node *node)
1964 {
1965     assert(node);
1966     assert(node->isContentEditable());
1967
1968     Node *root = node->rootEditableElement();
1969     if (!frame() || !root)
1970         return false;
1971
1972     return frame()->shouldEndEditing(rangeOfContents(root).get());
1973 }
1974
1975 bool Document::acceptsEditingFocus(Node *node)
1976 {
1977     assert(node);
1978     assert(node->isContentEditable());
1979
1980     Node *root = node->rootEditableElement();
1981     if (!frame() || !root)
1982         return false;
1983
1984     return frame()->shouldBeginEditing(rangeOfContents(root).get());
1985 }
1986
1987 void Document::didBeginEditing()
1988 {
1989     if (!frame())
1990         return;
1991     
1992     frame()->didBeginEditing();
1993 }
1994
1995 void Document::didEndEditing()
1996 {
1997     if (!frame())
1998         return;
1999     
2000     frame()->didEndEditing();
2001 }
2002
2003 #if __APPLE__
2004 const DeprecatedValueList<DashboardRegionValue> & Document::dashboardRegions() const
2005 {
2006     return m_dashboardRegions;
2007 }
2008
2009 void Document::setDashboardRegions (const DeprecatedValueList<DashboardRegionValue>& regions)
2010 {
2011     m_dashboardRegions = regions;
2012     setDashboardRegionsDirty (false);
2013 }
2014 #endif
2015
2016 static Widget *widgetForNode(Node *focusNode)
2017 {
2018     if (!focusNode)
2019         return 0;
2020     RenderObject *renderer = focusNode->renderer();
2021     if (!renderer || !renderer->isWidget())
2022         return 0;
2023     return static_cast<RenderWidget*>(renderer)->widget();
2024 }
2025
2026 bool Document::setFocusNode(PassRefPtr<Node> newFocusNode)
2027 {    
2028     // Make sure newFocusNode is actually in this document
2029     if (newFocusNode && (newFocusNode->document() != this))
2030         return true;
2031
2032     if (m_focusNode == newFocusNode)
2033         return true;
2034
2035     if (m_focusNode && m_focusNode.get() == m_focusNode->rootEditableElement() && !relinquishesEditingFocus(m_focusNode.get()))
2036         return false;
2037         
2038     bool focusChangeBlocked = false;
2039     RefPtr<Node> oldFocusNode = m_focusNode;
2040     m_focusNode = 0;
2041     clearSelectionIfNeeded(newFocusNode.get());
2042
2043     // Remove focus from the existing focus node (if any)
2044     if (oldFocusNode && !oldFocusNode->m_inDetach) { 
2045         if (oldFocusNode->active())
2046             oldFocusNode->setActive(false);
2047
2048         oldFocusNode->setFocus(false);
2049                 
2050         // Dispatch a change event for text fields or textareas that have been edited
2051         RenderObject *r = static_cast<RenderObject*>(oldFocusNode.get()->renderer());
2052         if (r && (r->isTextArea() || r->isTextField()) && r->isEdited()) {
2053             EventTargetNodeCast(oldFocusNode.get())->dispatchHTMLEvent(changeEvent, true, false);
2054             if ((r = static_cast<RenderObject*>(oldFocusNode.get()->renderer())))
2055                 r->setEdited(false);
2056         }
2057
2058         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
2059         EventTargetNodeCast(oldFocusNode.get())->dispatchBlurEvent();
2060
2061         if (m_focusNode) {
2062             // handler shifted focus
2063             focusChangeBlocked = true;
2064             newFocusNode = 0;
2065         }
2066         clearSelectionIfNeeded(newFocusNode.get());
2067         EventTargetNodeCast(oldFocusNode.get())->dispatchUIEvent(DOMFocusOutEvent);
2068         if (m_focusNode) {
2069             // handler shifted focus
2070             focusChangeBlocked = true;
2071             newFocusNode = 0;
2072         }
2073         clearSelectionIfNeeded(newFocusNode.get());
2074         if ((oldFocusNode.get() == this) && oldFocusNode->hasOneRef())
2075             return true;
2076             
2077         if (oldFocusNode.get() == oldFocusNode->rootEditableElement())
2078             didEndEditing();
2079     }
2080
2081     if (newFocusNode) {
2082         if (newFocusNode == newFocusNode->rootEditableElement() && !acceptsEditingFocus(newFocusNode.get())) {
2083             // delegate blocks focus change
2084             focusChangeBlocked = true;
2085             goto SetFocusNodeDone;
2086         }
2087         // Set focus on the new node
2088         m_focusNode = newFocusNode.get();
2089
2090         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
2091         EventTargetNodeCast(m_focusNode.get())->dispatchFocusEvent();
2092
2093         if (m_focusNode != newFocusNode) {
2094             // handler shifted focus
2095             focusChangeBlocked = true;
2096             goto SetFocusNodeDone;
2097         }
2098         EventTargetNodeCast(m_focusNode.get())->dispatchUIEvent(DOMFocusInEvent);
2099         if (m_focusNode != newFocusNode) { 
2100             // handler shifted focus
2101             focusChangeBlocked = true;
2102             goto SetFocusNodeDone;
2103         }
2104         m_focusNode->setFocus();
2105         
2106         if (m_focusNode.get() == m_focusNode->rootEditableElement())
2107             didBeginEditing();
2108         
2109         // eww, I suck. set the qt focus correctly
2110         // ### find a better place in the code for this
2111         if (view()) {
2112             Widget *focusWidget = widgetForNode(m_focusNode.get());
2113             if (focusWidget) {
2114                 // Make sure a widget has the right size before giving it focus.
2115                 // Otherwise, we are testing edge cases of the Widget code.
2116                 // Specifically, in WebCore this does not work well for text fields.
2117                 updateLayout();
2118                 // Re-get the widget in case updating the layout changed things.
2119                 focusWidget = widgetForNode(m_focusNode.get());
2120             }
2121             if (focusWidget)
2122                 focusWidget->setFocus();
2123             else
2124                 view()->setFocus();
2125         }
2126    }
2127
2128 #if __APPLE__
2129     if (!focusChangeBlocked && m_focusNode && AccessibilityObjectCache::accessibilityEnabled())
2130         getAccObjectCache()->handleFocusedUIElementChanged();
2131 #endif
2132
2133 SetFocusNodeDone:
2134     updateRendering();
2135     return !focusChangeBlocked;
2136 }
2137
2138 void Document::clearSelectionIfNeeded(Node *newFocusNode)
2139 {
2140     if (!frame())
2141         return;
2142
2143     // Clear the selection when changing the focus node to null or to a node that is not 
2144     // contained by the current selection.
2145     Node *startContainer = frame()->selection().start().node();
2146     if (!newFocusNode || (startContainer && startContainer != newFocusNode && !(startContainer->isAncestor(newFocusNode)) && startContainer->shadowAncestorNode() != newFocusNode))
2147         // FIXME: 6498 Should just be able to call m_frame->selection().clear()
2148         frame()->setSelection(SelectionController());
2149 }
2150
2151 void Document::setCSSTarget(Node* n)
2152 {
2153     if (m_cssTarget)
2154         m_cssTarget->setChanged();
2155     m_cssTarget = n;
2156     if (n)
2157         n->setChanged();
2158 }
2159
2160 Node* Document::getCSSTarget() const
2161 {
2162     return m_cssTarget;
2163 }
2164
2165 void Document::attachNodeIterator(NodeIterator *ni)
2166 {
2167     m_nodeIterators.append(ni);
2168 }
2169
2170 void Document::detachNodeIterator(NodeIterator *ni)
2171 {
2172     m_nodeIterators.remove(ni);
2173 }
2174
2175 void Document::notifyBeforeNodeRemoval(Node *n)
2176 {
2177     if (Frame* f = frame()) {
2178         f->selection().nodeWillBeRemoved(n);
2179         f->dragCaret().nodeWillBeRemoved(n);
2180     }
2181     DeprecatedPtrListIterator<NodeIterator> it(m_nodeIterators);
2182     for (; it.current(); ++it)
2183         it.current()->notifyBeforeNodeRemoval(n);
2184 }
2185
2186 DOMWindow* Document::defaultView() const
2187 {
2188     if (!frame())
2189         return 0;
2190     
2191     return frame()->domWindow();
2192 }
2193
2194 PassRefPtr<Event> Document::createEvent(const String &eventType, ExceptionCode& ec)
2195 {
2196     if (eventType == "UIEvents" || eventType == "UIEvent")
2197         return new UIEvent();
2198     if (eventType == "MouseEvents" || eventType == "MouseEvent")
2199         return new MouseEvent();
2200     if (eventType == "MutationEvents" || eventType == "MutationEvent")
2201         return new MutationEvent();
2202     if (eventType == "KeyboardEvents" || eventType == "KeyboardEvent")
2203         return new KeyboardEvent();
2204     if (eventType == "HTMLEvents" || eventType == "Event" || eventType == "Events")
2205         return new Event();
2206 #if SVG_SUPPORT
2207     if (eventType == "SVGEvents")
2208         return new Event();
2209     if (eventType == "SVGZoomEvents")
2210         return new WebCore::SVGZoomEvent();
2211 #endif
2212     ec = NOT_SUPPORTED_ERR;
2213     return 0;
2214 }
2215
2216 CSSStyleDeclaration *Document::getOverrideStyle(Element */*elt*/, const String &/*pseudoElt*/)
2217 {
2218     return 0; // ###
2219 }
2220
2221 void Document::handleWindowEvent(Event *evt, bool useCapture)
2222 {
2223     if (m_windowEventListeners.isEmpty())
2224         return;
2225         
2226     // if any html event listeners are registered on the window, then dispatch them here
2227     DeprecatedPtrList<RegisteredEventListener> listenersCopy = m_windowEventListeners;
2228     DeprecatedPtrListIterator<RegisteredEventListener> it(listenersCopy);
2229     for (; it.current(); ++it)
2230         if (it.current()->eventType() == evt->type() && it.current()->useCapture() == useCapture)
2231             it.current()->listener()->handleEvent(evt, true);
2232 }
2233
2234
2235 void Document::defaultEventHandler(Event *evt)
2236 {
2237     // handle accesskey
2238     if (evt->type() == keydownEvent) {
2239         KeyboardEvent* kevt = static_cast<KeyboardEvent *>(evt);
2240         if (kevt->ctrlKey()) {
2241             const PlatformKeyboardEvent* ev = kevt->keyEvent();
2242             String key = (ev ? ev->unmodifiedText() : kevt->keyIdentifier()).lower();
2243             Element* elem = getElementByAccessKey(key);
2244             if (elem) {
2245                 elem->accessKeyAction(false);
2246                 evt->setDefaultHandled();
2247             }
2248         }
2249     }
2250 }
2251
2252 void Document::setHTMLWindowEventListener(const AtomicString &eventType, PassRefPtr<EventListener> listener)
2253 {
2254     // If we already have it we don't want removeWindowEventListener to delete it
2255     removeHTMLWindowEventListener(eventType);
2256     if (listener)
2257         addWindowEventListener(eventType, listener, false);
2258 }
2259
2260 EventListener *Document::getHTMLWindowEventListener(const AtomicString &eventType)
2261 {
2262     DeprecatedPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2263     for (; it.current(); ++it)
2264         if (it.current()->eventType() == eventType && it.current()->listener()->isHTMLEventListener())
2265             return it.current()->listener();
2266     return 0;
2267 }
2268
2269 void Document::removeHTMLWindowEventListener(const AtomicString &eventType)
2270 {
2271     DeprecatedPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2272     for (; it.current(); ++it)
2273         if (it.current()->eventType() == eventType && it.current()->listener()->isHTMLEventListener()) {
2274             m_windowEventListeners.removeRef(it.current());
2275             return;
2276         }
2277 }
2278
2279 void Document::addWindowEventListener(const AtomicString &eventType, PassRefPtr<EventListener> listener, bool useCapture)
2280 {
2281     // Remove existing identical listener set with identical arguments.
2282     // The DOM 2 spec says that "duplicate instances are discarded" in this case.
2283     removeWindowEventListener(eventType, listener.get(), useCapture);
2284     m_windowEventListeners.append(new RegisteredEventListener(eventType, listener, useCapture));
2285 }
2286
2287 void Document::removeWindowEventListener(const AtomicString &eventType, EventListener *listener, bool useCapture)
2288 {
2289     RegisteredEventListener rl(eventType, listener, useCapture);
2290     DeprecatedPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2291     for (; it.current(); ++it)
2292         if (*(it.current()) == rl) {
2293             m_windowEventListeners.removeRef(it.current());
2294             return;
2295         }
2296 }
2297
2298 bool Document::hasWindowEventListener(const AtomicString &eventType)
2299 {
2300     DeprecatedPtrListIterator<RegisteredEventListener> it(m_windowEventListeners);
2301     for (; it.current(); ++it) {
2302         if (it.current()->eventType() == eventType) {
2303             return true;
2304         }
2305     }
2306
2307     return false;
2308 }
2309
2310 PassRefPtr<EventListener> Document::createHTMLEventListener(const String& functionName, const String& code, Node *node)
2311 {
2312     if (Frame* frm = frame())
2313         if (KJSProxy* proxy = frm->jScript())
2314             return proxy->createHTMLEventHandler(functionName, code, node);
2315     return 0;
2316 }
2317
2318 void Document::setHTMLWindowEventListener(const AtomicString& eventType, Attribute* attr)
2319 {
2320     setHTMLWindowEventListener(eventType,
2321         createHTMLEventListener(attr->localName().domString(), attr->value(), 0));
2322 }
2323
2324 void Document::dispatchImageLoadEventSoon(HTMLImageLoader *image)
2325 {
2326     m_imageLoadEventDispatchSoonList.append(image);
2327     if (!m_imageLoadEventTimer.isActive())
2328         m_imageLoadEventTimer.startOneShot(0);
2329 }
2330
2331 void Document::removeImage(HTMLImageLoader* image)
2332 {
2333     // Remove instances of this image from both lists.
2334     // Use loops because we allow multiple instances to get into the lists.
2335     while (m_imageLoadEventDispatchSoonList.removeRef(image)) { }
2336     while (m_imageLoadEventDispatchingList.removeRef(image)) { }
2337     if (m_imageLoadEventDispatchSoonList.isEmpty())
2338         m_imageLoadEventTimer.stop();
2339 }
2340
2341 void Document::dispatchImageLoadEventsNow()
2342 {
2343     // need to avoid re-entering this function; if new dispatches are
2344     // scheduled before the parent finishes processing the list, they
2345     // will set a timer and eventually be processed
2346     if (!m_imageLoadEventDispatchingList.isEmpty()) {
2347         return;
2348     }
2349
2350     m_imageLoadEventTimer.stop();
2351     
2352     m_imageLoadEventDispatchingList = m_imageLoadEventDispatchSoonList;
2353     m_imageLoadEventDispatchSoonList.clear();
2354     for (DeprecatedPtrListIterator<HTMLImageLoader> it(m_imageLoadEventDispatchingList); it.current();) {
2355         HTMLImageLoader* image = it.current();
2356         // Must advance iterator *before* dispatching call.
2357         // Otherwise, it might be advanced automatically if dispatching the call had a side effect
2358         // of destroying the current HTMLImageLoader, and then we would advance past the *next* item,
2359         // missing one altogether.
2360         ++it;
2361         image->dispatchLoadEvent();
2362     }
2363     m_imageLoadEventDispatchingList.clear();
2364 }
2365
2366 void Document::imageLoadEventTimerFired(Timer<Document>*)
2367 {
2368     dispatchImageLoadEventsNow();
2369 }
2370
2371 Element *Document::ownerElement() const
2372 {
2373     if (!frame())
2374         return 0;
2375     return frame()->ownerElement();
2376 }
2377
2378 String Document::referrer() const
2379 {
2380     if (frame())
2381         return frame()->incomingReferrer();
2382     
2383     return String();
2384 }
2385
2386 String Document::domain() const
2387 {
2388     if (m_domain.isEmpty()) // not set yet (we set it on demand to save time and space)
2389         m_domain = KURL(URL()).host(); // Initially set to the host
2390     return m_domain;
2391 }
2392
2393 void Document::setDomain(const String &newDomain, bool force /*=false*/)
2394 {
2395     if (force) {
2396         m_domain = newDomain;
2397         return;
2398     }
2399     if (m_domain.isEmpty()) // not set yet (we set it on demand to save time and space)
2400         m_domain = KURL(URL()).host(); // Initially set to the host
2401
2402     // Both NS and IE specify that changing the domain is only allowed when
2403     // the new domain is a suffix of the old domain.
2404     int oldLength = m_domain.length();
2405     int newLength = newDomain.length();
2406     if (newLength < oldLength) // e.g. newDomain=kde.org (7) and m_domain=www.kde.org (11)
2407     {
2408         String test = m_domain.copy();
2409         if (test[oldLength - newLength - 1] == '.') // Check that it's a subdomain, not e.g. "de.org"
2410         {
2411             test.remove(0, oldLength - newLength); // now test is "kde.org" from m_domain
2412             if (test == newDomain)                 // and we check that it's the same thing as newDomain
2413                 m_domain = newDomain;
2414         }
2415     }
2416 }
2417
2418 bool Document::isValidName(const String &name)
2419 {
2420     const UChar* s = reinterpret_cast<const UChar*>(name.characters());
2421     unsigned length = name.length();
2422
2423     if (length == 0)
2424         return false;
2425
2426     unsigned i = 0;
2427
2428     UChar32 c;
2429     U16_NEXT(s, i, length, c)
2430     if (!isValidNameStart(c))
2431         return false;
2432
2433     while (i < length) {
2434         U16_NEXT(s, i, length, c)
2435         if (!isValidNamePart(c))
2436             return false;
2437     }
2438
2439     return true;
2440 }
2441
2442 bool Document::parseQualifiedName(const String &qualifiedName, String &prefix, String &localName)
2443 {
2444     unsigned length = qualifiedName.length();
2445
2446     if (length == 0)
2447         return false;
2448
2449     bool nameStart = true;
2450     bool sawColon = false;
2451     int colonPos = 0;
2452
2453     const UChar* s = reinterpret_cast<const UChar*>(qualifiedName.characters());
2454     for (unsigned i = 0; i < length;) {
2455         UChar32 c;
2456         U16_NEXT(s, i, length, c)
2457         if (c == ':') {
2458             if (sawColon)
2459                 return false; // multiple colons: not allowed
2460             nameStart = true;
2461             sawColon = true;
2462             colonPos = i - 1;
2463         } else if (nameStart) {
2464             if (!isValidNameStart(c))
2465                 return false;
2466             nameStart = false;
2467         } else {
2468             if (!isValidNamePart(c))
2469                 return false;
2470         }
2471     }
2472
2473     if (!sawColon) {
2474         prefix = String();
2475         localName = qualifiedName.copy();
2476     } else {
2477         prefix = qualifiedName.substring(0, colonPos);
2478         localName = qualifiedName.substring(colonPos + 1, length - (colonPos + 1));
2479     }
2480
2481     return true;
2482 }
2483
2484 void Document::addImageMap(HTMLMapElement* imageMap)
2485 {
2486     // Add the image map, unless there's already another with that name.
2487     // "First map wins" is the rule other browsers seem to implement.
2488     m_imageMapsByName.add(imageMap->getName().impl(), imageMap);
2489 }
2490
2491 void Document::removeImageMap(HTMLMapElement* imageMap)
2492 {
2493     // Remove the image map by name.
2494     // But don't remove some other image map that just happens to have the same name.
2495     // FIXME: Use a HashCountedSet as we do for IDs to find the first remaining map
2496     // once a map has been removed.
2497     const AtomicString& name = imageMap->getName();
2498     ImageMapsByName::iterator it = m_imageMapsByName.find(name.impl());
2499     if (it != m_imageMapsByName.end() && it->second == imageMap)
2500         m_imageMapsByName.remove(it);
2501 }
2502
2503 HTMLMapElement *Document::getImageMap(const String& URL) const
2504 {
2505     if (URL.isNull())
2506         return 0;
2507     int hashPos = URL.find('#');
2508     AtomicString name = (hashPos < 0 ? URL : URL.substring(hashPos + 1)).impl();
2509     return m_imageMapsByName.get(name.impl());
2510 }
2511
2512 void Document::setDecoder(Decoder *decoder)
2513 {
2514     m_decoder = decoder;
2515 }
2516
2517 UChar Document::backslashAsCurrencySymbol() const
2518 {
2519     if (!m_decoder)
2520         return '\\';
2521     return m_decoder->encoding().backslashAsCurrencySymbol();
2522 }
2523
2524 DeprecatedString Document::completeURL(const DeprecatedString &URL)
2525 {
2526     // If both the URL and base URL are empty, like they are for documents
2527     // created using DOMImplementation::createDocument, just return the passed in URL.
2528     // (We do this because URL() returns "about:blank" for empty URLs.
2529     if (m_url.isEmpty() && m_baseURL.isEmpty())
2530         return URL;
2531     
2532     if (!m_decoder)
2533         return KURL(baseURL(), URL).url();
2534     return KURL(baseURL(), URL, m_decoder->encoding()).url();
2535 }
2536
2537 String Document::completeURL(const String &URL)
2538 {
2539     if (URL.isNull())
2540         return URL;
2541     return completeURL(URL.deprecatedString());
2542 }
2543
2544 bool Document::inPageCache()
2545 {
2546     return m_inPageCache;
2547 }
2548
2549 void Document::setInPageCache(bool flag)
2550 {
2551     if (m_inPageCache == flag)
2552         return;
2553
2554     m_inPageCache = flag;
2555     if (flag) {
2556         ASSERT(m_savedRenderer == 0);
2557         m_savedRenderer = renderer();
2558         if (m_view)
2559             m_view->resetScrollBars();
2560     } else {
2561         ASSERT(renderer() == 0 || renderer() == m_savedRenderer);
2562         ASSERT(m_renderArena);
2563         setRenderer(m_savedRenderer);
2564         m_savedRenderer = 0;
2565     }
2566 }
2567
2568 void Document::passwordFieldAdded()
2569 {
2570     m_passwordFields++;
2571 }
2572
2573 void Document::passwordFieldRemoved()
2574 {
2575     assert(m_passwordFields > 0);
2576     m_passwordFields--;
2577 }
2578
2579 bool Document::hasPasswordField() const
2580 {
2581     return m_passwordFields > 0;
2582 }
2583
2584 void Document::secureFormAdded()
2585 {
2586     m_secureForms++;
2587 }
2588
2589 void Document::secureFormRemoved()
2590 {
2591     assert(m_secureForms > 0);
2592     m_secureForms--;
2593 }
2594
2595 bool Document::hasSecureForm() const
2596 {
2597     return m_secureForms > 0;
2598 }
2599
2600 void Document::setShouldCreateRenderers(bool f)
2601 {
2602     m_createRenderers = f;
2603 }
2604
2605 bool Document::shouldCreateRenderers()
2606 {
2607     return m_createRenderers;
2608 }
2609
2610 String Document::toString() const
2611 {
2612     String result;
2613
2614     for (Node *child = firstChild(); child != NULL; child = child->nextSibling()) {
2615         result += child->toString();
2616     }
2617
2618     return result;
2619 }
2620
2621 // Support for Javascript execCommand, and related methods
2622
2623 JSEditor *Document::jsEditor()
2624 {
2625     if (!m_jsEditor)
2626         m_jsEditor = new JSEditor(this);
2627     return m_jsEditor;
2628 }
2629
2630 bool Document::execCommand(const String &command, bool userInterface, const String &value)
2631 {
2632     return jsEditor()->execCommand(command, userInterface, value);
2633 }
2634
2635 bool Document::queryCommandEnabled(const String &command)
2636 {
2637     return jsEditor()->queryCommandEnabled(command);
2638 }
2639
2640 bool Document::queryCommandIndeterm(const String &command)
2641 {
2642     return jsEditor()->queryCommandIndeterm(command);
2643 }
2644
2645 bool Document::queryCommandState(const String &command)
2646 {
2647     return jsEditor()->queryCommandState(command);
2648 }
2649
2650 bool Document::queryCommandSupported(const String &command)
2651 {
2652     return jsEditor()->queryCommandSupported(command);
2653 }
2654
2655 String Document::queryCommandValue(const String &command)
2656 {
2657     return jsEditor()->queryCommandValue(command);
2658 }
2659
2660 static IntRect placeholderRectForMarker(void)
2661 {
2662     return IntRect(-1,-1,-1,-1);
2663 }
2664
2665 void Document::addMarker(Range *range, DocumentMarker::MarkerType type)
2666 {
2667     // Use a TextIterator to visit the potentially multiple nodes the range covers.
2668     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
2669         RefPtr<Range> textPiece = markedText.range();
2670         int exception = 0;
2671         DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception)};
2672         addMarker(textPiece->startContainer(exception), marker);
2673     }
2674 }
2675
2676 void Document::removeMarkers(Range *range, DocumentMarker::MarkerType markerType)
2677 {
2678     // Use a TextIterator to visit the potentially multiple nodes the range covers.
2679     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
2680         RefPtr<Range> textPiece = markedText.range();
2681         int exception = 0;
2682         unsigned startOffset = textPiece->startOffset(exception);
2683         unsigned length = textPiece->endOffset(exception) - startOffset + 1;
2684         removeMarkers(textPiece->startContainer(exception), startOffset, length, markerType);
2685     }
2686 }
2687
2688 // Markers are stored in order sorted by their location.  They do not overlap each other, as currently
2689 // required by the drawing code in RenderText.cpp.
2690
2691 void Document::addMarker(Node *node, DocumentMarker newMarker) 
2692 {
2693     assert(newMarker.endOffset >= newMarker.startOffset);
2694     if (newMarker.endOffset == newMarker.startOffset)
2695         return;
2696     
2697     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2698     
2699     if (!vectorPair) {
2700         vectorPair = new MarkerMapVectorPair;
2701         vectorPair->first.append(newMarker);
2702         vectorPair->second.append(placeholderRectForMarker());
2703         m_markers.set(node, vectorPair);
2704     } else {
2705         Vector<DocumentMarker>& markers = vectorPair->first;
2706         Vector<IntRect>& rects = vectorPair->second;
2707         ASSERT(markers.size() == rects.size());
2708         Vector<DocumentMarker>::iterator it;
2709         for (it = markers.begin(); it != markers.end();) {
2710             DocumentMarker marker = *it;
2711             
2712             if (newMarker.endOffset < marker.startOffset+1) {
2713                 // This is the first marker that is completely after newMarker, and disjoint from it.
2714                 // We found our insertion point.\10
2715                 break;
2716             } else if (newMarker.startOffset > marker.endOffset) {
2717                 // maker is before newMarker, and disjoint from it.  Keep scanning.
2718                 it++;
2719             } else if (newMarker == marker) {
2720                 // already have this one, NOP
2721                 return;
2722             } else {
2723                 // marker and newMarker intersect or touch - merge them into newMarker
2724                 newMarker.startOffset = min(newMarker.startOffset, marker.startOffset);
2725                 newMarker.endOffset = max(newMarker.endOffset, marker.endOffset);
2726                 // remove old one, we'll add newMarker later
2727                 unsigned removalIndex = it - markers.begin();
2728                 markers.remove(removalIndex);
2729                 rects.remove(removalIndex);
2730                 // it points to the next marker to consider
2731             }
2732         }
2733         // at this point it points to the node before which we want to insert
2734         unsigned insertionIndex = it - markers.begin();
2735         markers.insert(insertionIndex, newMarker);
2736         rects.insert(insertionIndex, placeholderRectForMarker());
2737     }
2738     
2739     // repaint the affected node
2740     if (node->renderer())
2741         node->renderer()->repaint();
2742 }
2743
2744 // copies markers from srcNode to dstNode, applying the specified shift delta to the copies.  The shift is
2745 // useful if, e.g., the caller has created the dstNode from a non-prefix substring of the srcNode.
2746 void Document::copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType markerType)
2747 {
2748     if (length <= 0)
2749         return;
2750     
2751     MarkerMapVectorPair* vectorPair = m_markers.get(srcNode);
2752     if (!vectorPair)
2753         return;
2754
2755     ASSERT(vectorPair->first.size() == vectorPair->second.size());
2756
2757     bool docDirty = false;
2758     unsigned endOffset = startOffset + length - 1;
2759     Vector<DocumentMarker>::iterator it;
2760     Vector<DocumentMarker>& markers = vectorPair->first;
2761     for (it = markers.begin(); it != markers.end(); ++it) {
2762         DocumentMarker marker = *it;
2763
2764         // stop if we are now past the specified range
2765         if (marker.startOffset > endOffset)
2766             break;
2767         
2768         // skip marker that is before the specified range or is the wrong type
2769         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers))
2770             continue;
2771
2772         // pin the marker to the specified range and apply the shift delta
2773         docDirty = true;
2774         if (marker.startOffset < startOffset)
2775             marker.startOffset = startOffset;
2776         if (marker.endOffset > endOffset)
2777             marker.endOffset = endOffset;
2778         marker.startOffset += delta;
2779         marker.endOffset += delta;
2780         
2781         addMarker(dstNode, marker);
2782     }
2783     
2784     // repaint the affected node
2785     if (docDirty && dstNode->renderer())
2786         dstNode->renderer()->repaint();
2787 }
2788
2789 void Document::removeMarkers(Node *node, unsigned startOffset, int length, DocumentMarker::MarkerType markerType)
2790 {
2791     if (length <= 0)
2792         return;
2793
2794     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2795     if (!vectorPair)
2796         return;
2797
2798     Vector<DocumentMarker>& markers = vectorPair->first;
2799     Vector<IntRect>& rects = vectorPair->second;
2800     ASSERT(markers.size() == rects.size());
2801     bool docDirty = false;
2802     unsigned endOffset = startOffset + length - 1;
2803     Vector<DocumentMarker>::iterator it;
2804     for (it = markers.begin(); it < markers.end();) {
2805         DocumentMarker marker = *it;
2806
2807         // markers are returned in order, so stop if we are now past the specified range
2808         if (marker.startOffset > endOffset)
2809             break;
2810         
2811         // skip marker that is wrong type or before target
2812         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers)) {
2813             it++;
2814             continue;
2815         }
2816
2817         // at this point we know that marker and target intersect in some way
2818         docDirty = true;
2819
2820         // pitch the old marker and any associated rect
2821         markers.remove(it - markers.begin());
2822         rects.remove(it - markers.begin());
2823         // it now points to the next node
2824         
2825         // add either of the resulting slices that are left after removing target
2826         if (startOffset > marker.startOffset) {
2827             DocumentMarker newLeft = marker;
2828             newLeft.endOffset = startOffset;
2829             markers.insert(it - markers.begin(), newLeft);
2830             rects.insert(it - markers.begin(), placeholderRectForMarker());
2831             // it now points to the newly-inserted node, but we want to skip that one
2832             it++;
2833         }
2834         if (marker.endOffset > endOffset) {
2835             DocumentMarker newRight = marker;
2836             newRight.startOffset = endOffset;
2837             markers.insert(it - markers.begin(), newRight);
2838             rects.insert(it - markers.begin(), placeholderRectForMarker());
2839             // it now points to the newly-inserted node, but we want to skip that one
2840             it++;
2841         }
2842     }
2843
2844     if (markers.isEmpty()) {
2845         ASSERT(rects.isEmpty());
2846         m_markers.remove(node);
2847         delete vectorPair;
2848     }
2849
2850     // repaint the affected node
2851     if (docDirty && node->renderer())
2852         node->renderer()->repaint();
2853 }
2854
2855 Vector<DocumentMarker> Document::markersForNode(Node* node)
2856 {
2857     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2858     if (vectorPair)
2859         return vectorPair->first;
2860     return Vector<DocumentMarker>();
2861 }
2862
2863 Vector<IntRect> Document::renderedRectsForMarkers(DocumentMarker::MarkerType markerType)
2864 {
2865     Vector<IntRect> result;
2866     
2867     // outer loop: process each node
2868     MarkerMap::iterator end = m_markers.end();
2869     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
2870         // inner loop; process each marker in this node
2871         MarkerMapVectorPair* vectorPair = nodeIterator->second;
2872         Vector<DocumentMarker>& markers = vectorPair->first;
2873         Vector<IntRect>& rects = vectorPair->second;
2874         ASSERT(markers.size() == rects.size());
2875         unsigned markerCount = markers.size();
2876         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
2877             DocumentMarker marker = markers[markerIndex];
2878             
2879             // skip marker that is wrong type
2880             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
2881                 continue;
2882             
2883             IntRect r = rects[markerIndex];
2884             // skip placeholder rects
2885             if (r == placeholderRectForMarker())
2886                 continue;
2887
2888             result.append(r);
2889         }
2890     }
2891     
2892     return result;
2893 }
2894
2895
2896 void Document::removeMarkers(Node* node)
2897 {
2898     MarkerMap::iterator i = m_markers.find(node);
2899     if (i != m_markers.end()) {
2900         delete i->second;
2901         m_markers.remove(i);
2902         if (RenderObject* renderer = node->renderer())
2903             renderer->repaint();
2904     }
2905 }
2906
2907 void Document::removeMarkers(DocumentMarker::MarkerType markerType)
2908 {
2909     // outer loop: process each markered node in the document
2910     MarkerMap markerMapCopy = m_markers;
2911     MarkerMap::iterator end = markerMapCopy.end();
2912     for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i) {
2913         Node* node = i->first.get();
2914         bool nodeNeedsRepaint = false;
2915
2916         // inner loop: process each marker in the current node
2917         MarkerMapVectorPair* vectorPair = i->second;
2918         Vector<DocumentMarker>& markers = vectorPair->first;
2919         Vector<IntRect>& rects = vectorPair->second;
2920         ASSERT(markers.size() == rects.size());
2921         Vector<DocumentMarker>::iterator markerIterator;
2922         for (markerIterator = markers.begin(); markerIterator != markers.end();) {
2923             DocumentMarker marker = *markerIterator;
2924
2925             // skip nodes that are not of the specified type
2926             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers) {
2927                 ++markerIterator;
2928                 continue;
2929             }
2930
2931             // pitch the old marker
2932             markers.remove(markerIterator - markers.begin());
2933             rects.remove(markerIterator - markers.begin());
2934             nodeNeedsRepaint = true;
2935             // markerIterator now points to the next node
2936         }
2937
2938         // Redraw the node if it changed. Do this before the node is removed from m_markers, since 
2939         // m_markers might contain the last reference to the node.
2940         if (nodeNeedsRepaint) {
2941             RenderObject* renderer = node->renderer();
2942             if (renderer)
2943                 renderer->repaint();
2944         }
2945
2946         // delete the node's list if it is now empty
2947         if (markers.isEmpty()) {
2948             ASSERT(rects.isEmpty());
2949             m_markers.remove(node);
2950             delete vectorPair;
2951         }
2952     }
2953 }
2954
2955 void Document::repaintMarkers(DocumentMarker::MarkerType markerType)
2956 {
2957     // outer loop: process each markered node in the document
2958     MarkerMap::iterator end = m_markers.end();
2959     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
2960         Node* node = i->first.get();
2961         
2962         // inner loop: process each marker in the current node
2963         MarkerMapVectorPair* vectorPair = i->second;
2964         Vector<DocumentMarker>& markers = vectorPair->first;
2965         Vector<DocumentMarker>::iterator markerIterator;
2966         bool nodeNeedsRepaint = false;
2967         for (markerIterator = markers.begin(); markerIterator != markers.end(); ++markerIterator) {
2968             DocumentMarker marker = *markerIterator;
2969             
2970             // skip nodes that are not of the specified type
2971             if (marker.type == markerType || markerType == DocumentMarker::AllMarkers) {
2972                 nodeNeedsRepaint = true;
2973                 break;
2974             }
2975         }
2976         
2977         if (!nodeNeedsRepaint)
2978             continue;
2979         
2980         // cause the node to be redrawn
2981         if (RenderObject* renderer = node->renderer())
2982             renderer->repaint();
2983     }
2984 }
2985
2986 void Document::setRenderedRectForMarker(Node* node, DocumentMarker marker, const IntRect& r)
2987 {
2988     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2989     if (!vectorPair) {
2990         ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
2991         return;
2992     }
2993     
2994     Vector<DocumentMarker>& markers = vectorPair->first;
2995     ASSERT(markers.size() == vectorPair->second.size());
2996     unsigned markerCount = markers.size();
2997     for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
2998         DocumentMarker m = markers[markerIndex];
2999         if (m == marker) {
3000             vectorPair->second[markerIndex] = r;
3001             return;
3002         }
3003     }
3004     
3005     ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
3006 }
3007
3008 void Document::invalidateRenderedRectsForMarkersInRect(const IntRect& r)
3009 {
3010     // outer loop: process each markered node in the document
3011     MarkerMap::iterator end = m_markers.end();
3012     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
3013         
3014         // inner loop: process each rect in the current node
3015         MarkerMapVectorPair* vectorPair = i->second;
3016         Vector<IntRect>& rects = vectorPair->second;
3017         
3018         unsigned rectCount = rects.size();
3019         for (unsigned rectIndex = 0; rectIndex < rectCount; ++rectIndex)
3020             if (rects[rectIndex].intersects(r))
3021                 rects[rectIndex] = placeholderRectForMarker();
3022     }
3023 }
3024
3025 void Document::shiftMarkers(Node *node, unsigned startOffset, int delta, DocumentMarker::MarkerType markerType)
3026 {
3027     MarkerMapVectorPair* vectorPair = m_markers.get(node);
3028     if (!vectorPair)
3029         return;
3030     
3031     Vector<DocumentMarker>& markers = vectorPair->first;
3032     Vector<IntRect>& rects = vectorPair->second;
3033     ASSERT(markers.size() == rects.size());
3034     
3035     bool docDirty = false;
3036     Vector<DocumentMarker>::iterator it;
3037     for (it = markers.begin(); it != markers.end(); ++it) {
3038         DocumentMarker &marker = *it;
3039         if (marker.startOffset >= startOffset && (markerType == DocumentMarker::AllMarkers || marker.type == markerType)) {
3040             assert((int)marker.startOffset + delta >= 0);
3041             marker.startOffset += delta;
3042             marker.endOffset += delta;
3043             docDirty = true;
3044             
3045             // Marker moved, so previously-computed rendered rectangle is now invalid
3046             rects[it - markers.begin()] = placeholderRectForMarker();
3047         }
3048     }
3049     
3050     // repaint the affected node
3051     if (docDirty && node->renderer())
3052         node->renderer()->repaint();
3053 }
3054
3055 #ifdef KHTML_XSLT
3056
3057 void Document::applyXSLTransform(ProcessingInstruction* pi)
3058 {
3059     RefPtr<XSLTProcessor> processor = new XSLTProcessor;
3060     processor->setXSLStylesheet(static_cast<XSLStyleSheet*>(pi->sheet()));
3061     
3062     DeprecatedString resultMIMEType;
3063     DeprecatedString newSource;
3064     DeprecatedString resultEncoding;
3065     if (!processor->transformToString(this, resultMIMEType, newSource, resultEncoding))
3066         return;
3067     // FIXME: If the transform failed we should probably report an error (like Mozilla does).
3068     processor->createDocumentFromSource(newSource, resultEncoding, resultMIMEType, this, view());
3069 }
3070
3071 #endif
3072
3073 void Document::setDesignMode(InheritedBool value)
3074 {
3075     m_designMode = value;
3076 }
3077
3078 Document::InheritedBool Document::getDesignMode() const
3079 {
3080     return m_designMode;
3081 }
3082
3083 bool Document::inDesignMode() const
3084 {
3085     for (const Document* d = this; d; d = d->parentDocument()) {
3086         if (d->m_designMode != inherit)
3087             return d->m_designMode;      
3088     }
3089     return false;
3090 }
3091
3092 Document *Document::parentDocument() const
3093 {
3094     Frame *childPart = frame();
3095     if (!childPart)
3096         return 0;
3097     Frame *parent = childPart->tree()->parent();
3098     if (!parent)
3099         return 0;
3100     return parent->document();
3101 }
3102
3103 Document *Document::topDocument() const
3104 {
3105     Document *doc = const_cast<Document *>(this);
3106     Element *element;
3107     while ((element = doc->ownerElement()) != 0)
3108         doc = element->document();
3109     
3110     return doc;
3111 }
3112
3113 PassRefPtr<Attr> Document::createAttributeNS(const String &namespaceURI, const String &qualifiedName, ExceptionCode& ec)
3114 {
3115     if (qualifiedName.isNull()) {
3116         ec = NAMESPACE_ERR;
3117         return 0;
3118     }
3119
3120     String localName = qualifiedName;
3121     String prefix;
3122     int colonpos;
3123     if ((colonpos = qualifiedName.find(':')) >= 0) {
3124         prefix = qualifiedName.copy();
3125         localName = qualifiedName.copy();
3126         prefix.truncate(colonpos);
3127         localName.remove(0, colonpos+1);
3128     }
3129
3130     if (!isValidName(localName)) {
3131         ec = INVALID_CHARACTER_ERR;
3132         return 0;
3133     }
3134     
3135     // FIXME: Assume this is a mapped attribute, since createAttribute isn't namespace-aware.  There's no harm to XML
3136     // documents if we're wrong.
3137     return new Attr(0, this, new MappedAttribute(QualifiedName(prefix.impl(), 
3138                                                                        localName.impl(),
3139                                                                        namespaceURI.impl()), String("").impl()));
3140 }
3141
3142 #if SVG_SUPPORT
3143 const SVGDocumentExtensions* Document::svgExtensions()
3144 {
3145     return m_svgExtensions;
3146 }
3147
3148 SVGDocumentExtensions* Document::accessSVGExtensions()
3149 {
3150     if (!m_svgExtensions)
3151         m_svgExtensions = new SVGDocumentExtensions(this);
3152     return m_svgExtensions;
3153 }
3154 #endif
3155
3156 void Document::radioButtonChecked(HTMLInputElement *caller, HTMLFormElement *form)
3157 {
3158     // Without a name, there is no group.
3159     if (caller->name().isEmpty())
3160         return;
3161     if (!form)
3162         form = defaultForm;
3163     // Uncheck the currently selected item
3164     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3165     if (!formRadioButtons) {
3166         formRadioButtons = new NameToInputMap;
3167         m_selectedRadioButtons.set(form, formRadioButtons);
3168     }
3169     
3170     HTMLInputElement* currentCheckedRadio = formRadioButtons->get(caller->name().impl());
3171     if (currentCheckedRadio && currentCheckedRadio != caller)
3172         currentCheckedRadio->setChecked(false);
3173
3174     formRadioButtons->set(caller->name().impl(), caller);
3175 }
3176
3177 HTMLInputElement* Document::checkedRadioButtonForGroup(AtomicStringImpl* name, HTMLFormElement *form)
3178 {
3179     if (!form)
3180         form = defaultForm;
3181     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3182     if (!formRadioButtons)
3183         return 0;
3184     
3185     return formRadioButtons->get(name);
3186 }
3187
3188 void Document::removeRadioButtonGroup(AtomicStringImpl* name, HTMLFormElement *form)
3189 {
3190     if (!form)
3191         form = defaultForm;
3192     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3193     if (formRadioButtons) {
3194         formRadioButtons->remove(name);
3195         if (formRadioButtons->isEmpty()) {
3196             m_selectedRadioButtons.remove(form);
3197             delete formRadioButtons;
3198         }
3199     }
3200 }
3201
3202 PassRefPtr<HTMLCollection> Document::images()
3203 {
3204     return new HTMLCollection(this, HTMLCollection::DocImages);
3205 }
3206
3207 PassRefPtr<HTMLCollection> Document::applets()
3208 {
3209     return new HTMLCollection(this, HTMLCollection::DocApplets);
3210 }
3211
3212 PassRefPtr<HTMLCollection> Document::embeds()
3213 {
3214     return new HTMLCollection(this, HTMLCollection::DocEmbeds);
3215 }
3216
3217 PassRefPtr<HTMLCollection> Document::objects()
3218 {
3219     return new HTMLCollection(this, HTMLCollection::DocObjects);
3220 }
3221
3222 PassRefPtr<HTMLCollection> Document::scripts()
3223 {
3224     return new HTMLCollection(this, HTMLCollection::DocScripts);
3225 }
3226
3227 PassRefPtr<HTMLCollection> Document::links()
3228 {
3229     return new HTMLCollection(this, HTMLCollection::DocLinks);
3230 }
3231
3232 PassRefPtr<HTMLCollection> Document::forms()
3233 {
3234     return new HTMLCollection(this, HTMLCollection::DocForms);
3235 }
3236
3237 PassRefPtr<HTMLCollection> Document::anchors()
3238 {
3239     return new HTMLCollection(this, HTMLCollection::DocAnchors);
3240 }
3241
3242 PassRefPtr<HTMLCollection> Document::all()
3243 {
3244     return new HTMLCollection(this, HTMLCollection::DocAll);
3245 }
3246
3247 PassRefPtr<HTMLCollection> Document::windowNamedItems(const String &name)
3248 {
3249     return new HTMLNameCollection(this, HTMLCollection::WindowNamedItems, name);
3250 }
3251
3252 PassRefPtr<HTMLCollection> Document::documentNamedItems(const String &name)
3253 {
3254     return new HTMLNameCollection(this, HTMLCollection::DocumentNamedItems, name);
3255 }
3256
3257 HTMLCollection::CollectionInfo* Document::nameCollectionInfo(HTMLCollection::Type type, const String& name)
3258 {
3259     HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo>& map = m_nameCollectionInfo[type - HTMLCollection::UnnamedCollectionTypes];
3260     
3261     AtomicString atomicName(name);
3262     
3263     HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo>::iterator iter = map.find(atomicName.impl());
3264     if (iter == map.end())
3265         iter = map.add(atomicName.impl(), HTMLCollection::CollectionInfo()).first;
3266     
3267     return &iter->second;
3268 }
3269
3270 PassRefPtr<NameNodeList> Document::getElementsByName(const String &elementName)
3271 {
3272     return new NameNodeList(this, elementName);
3273 }
3274
3275 void Document::finishedParsing()
3276 {
3277     setParsing(false);
3278     if (Frame* f = frame())
3279         f->finishedParsing();
3280 }
3281
3282 Vector<String> Document::formElementsState() const
3283 {
3284     Vector<String> stateVector;
3285     stateVector.reserveCapacity(m_formElementsWithState.size() * 3);
3286     typedef HashSet<HTMLGenericFormElement*>::const_iterator Iterator;
3287     Iterator end = m_formElementsWithState.end();
3288     for (Iterator it = m_formElementsWithState.begin(); it != end; ++it) {
3289         HTMLGenericFormElement* e = *it;
3290         stateVector.append(e->name().domString());
3291         stateVector.append(e->type().domString());
3292         stateVector.append(e->stateValue());
3293     }
3294     return stateVector;
3295 }
3296
3297 #if XPATH_SUPPORT
3298
3299 PassRefPtr<XPathExpression> Document::createExpression(const String& expression,
3300                                                        XPathNSResolver* resolver,
3301                                                        ExceptionCode& ec)
3302 {
3303     if (!m_xpathEvaluator)
3304         m_xpathEvaluator = new XPathEvaluator;
3305     return m_xpathEvaluator->createExpression(expression, resolver, ec);
3306 }
3307
3308 PassRefPtr<XPathNSResolver> Document::createNSResolver(Node* nodeResolver)
3309 {
3310     if (!m_xpathEvaluator)
3311         m_xpathEvaluator = new XPathEvaluator;
3312     return m_xpathEvaluator->createNSResolver(nodeResolver);
3313 }
3314
3315 PassRefPtr<XPathResult> Document::evaluate(const String& expression,
3316                                            Node* contextNode,
3317                                            XPathNSResolver* resolver,
3318                                            unsigned short type,
3319                                            XPathResult* result,
3320                                            ExceptionCode& ec)
3321 {
3322     if (!m_xpathEvaluator)
3323         m_xpathEvaluator = new XPathEvaluator;
3324     return m_xpathEvaluator->evaluate(expression, contextNode, resolver, type, result, ec);
3325 }
3326
3327 #endif // XPATH_SUPPORT
3328
3329 void Document::setStateForNewFormElements(const Vector<String>& stateVector)
3330 {
3331     // Walk the state vector backwards so that the value to use for each
3332     // name/type pair first is the one at the end of each individual vector
3333     // in the FormElementStateMap. We're using them like stacks.
3334     typedef FormElementStateMap::iterator Iterator;
3335     m_formElementsWithState.clear();
3336     for (size_t i = stateVector.size() / 3 * 3; i; i -= 3) {
3337         AtomicString a = stateVector[i - 3];
3338         AtomicString b = stateVector[i - 2];
3339         const String& c = stateVector[i - 1];
3340         FormElementKey key(a.impl(), b.impl());
3341         Iterator it = m_stateForNewFormElements.find(key);
3342         if (it != m_stateForNewFormElements.end())
3343             it->second.append(c);
3344         else {
3345             Vector<String> v(1);
3346             v[0] = c;
3347             m_stateForNewFormElements.set(key, v);
3348         }
3349     }
3350 }
3351
3352 bool Document::hasStateForNewFormElements() const
3353 {
3354     return !m_stateForNewFormElements.isEmpty();
3355 }
3356
3357 bool Document::takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state)
3358 {
3359     typedef FormElementStateMap::iterator Iterator;
3360     Iterator it = m_stateForNewFormElements.find(FormElementKey(name, type));
3361     if (it == m_stateForNewFormElements.end())
3362         return false;
3363     ASSERT(it->second.size());
3364     state = it->second.last();
3365     if (it->second.size() > 1)
3366         it->second.removeLast();
3367     else
3368         m_stateForNewFormElements.remove(it);
3369     return true;
3370 }
3371
3372 FormElementKey::FormElementKey(AtomicStringImpl* name, AtomicStringImpl* type)
3373     : m_name(name), m_type(type)
3374 {
3375     ref();
3376 }
3377
3378 FormElementKey::~FormElementKey()
3379 {
3380     deref();
3381 }
3382
3383 FormElementKey::FormElementKey(const FormElementKey& other)
3384     : m_name(other.name()), m_type(other.type())
3385 {
3386     ref();
3387 }
3388
3389 FormElementKey& FormElementKey::operator=(const FormElementKey& other)
3390 {
3391     other.ref();
3392     deref();
3393     m_name = other.name();
3394     m_type = other.type();
3395     return *this;
3396 }
3397
3398 void FormElementKey::ref() const
3399 {
3400     if (name() && name() != HashTraits<AtomicStringImpl*>::deletedValue())
3401         name()->ref();
3402     if (type())
3403         type()->ref();
3404 }
3405
3406 void FormElementKey::deref() const
3407 {
3408     if (name() && name() != HashTraits<AtomicStringImpl*>::deletedValue())
3409         name()->deref();
3410     if (type())
3411         type()->deref();
3412 }
3413
3414 unsigned FormElementKeyHash::hash(const FormElementKey& k)
3415 {
3416     ASSERT(sizeof(k) % (sizeof(uint16_t) * 2) == 0);
3417
3418     unsigned l = sizeof(k) / (sizeof(uint16_t) * 2);
3419     const uint16_t* s = reinterpret_cast<const uint16_t*>(&k);
3420     uint32_t hash = PHI;
3421
3422     // Main loop
3423     for (; l > 0; l--) {
3424         hash += s[0];
3425         uint32_t tmp = (s[1] << 11) ^ hash;
3426         hash = (hash << 16) ^ tmp;
3427         s += 2;
3428         hash += hash >> 11;
3429     }
3430         
3431     // Force "avalanching" of final 127 bits
3432     hash ^= hash << 3;
3433     hash += hash >> 5;
3434     hash ^= hash << 2;
3435     hash += hash >> 15;
3436     hash ^= hash << 10;
3437
3438     // this avoids ever returning a hash code of 0, since that is used to
3439     // signal "hash not computed yet", using a value that is likely to be
3440     // effectively the same as 0 when the low bits are masked
3441     if (hash == 0)
3442         hash = 0x80000000;
3443
3444     return hash;
3445 }
3446
3447 FormElementKey FormElementKeyHashTraits::deletedValue()
3448 {
3449     return HashTraits<AtomicStringImpl*>::deletedValue();
3450 }
3451
3452 }