2008-05-30 Maciej Stachowiak <mjs@apple.com>
[WebKit.git] / WebCore / page / Frame.cpp
1 /*
2  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
3  *                     1999 Lars Knoll <knoll@kde.org>
4  *                     1999 Antti Koivisto <koivisto@kde.org>
5  *                     2000 Simon Hausmann <hausmann@kde.org>
6  *                     2000 Stefan Schimanski <1Stein@gmx.de>
7  *                     2001 George Staikos <staikos@kde.org>
8  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
9  * Copyright (C) 2005 Alexey Proskuryakov <ap@nypop.com>
10  * Copyright (C) 2007 Trolltech ASA
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Library General Public
14  * License as published by the Free Software Foundation; either
15  * version 2 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Library General Public License for more details.
21  *
22  * You should have received a copy of the GNU Library General Public License
23  * along with this library; see the file COPYING.LIB.  If not, write to
24  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25  * Boston, MA 02110-1301, USA.
26  */
27
28 #include "config.h"
29 #include "Frame.h"
30 #include "FramePrivate.h"
31
32 #include "ApplyStyleCommand.h"
33 #include "BeforeUnloadEvent.h"
34 #include "CSSComputedStyleDeclaration.h"
35 #include "CSSProperty.h"
36 #include "CSSPropertyNames.h"
37 #include "CachedCSSStyleSheet.h"
38 #include "DOMWindow.h"
39 #include "DocLoader.h"
40 #include "DocumentType.h"
41 #include "EditingText.h"
42 #include "EditorClient.h"
43 #include "EventNames.h"
44 #include "FocusController.h"
45 #include "FrameLoader.h"
46 #include "FrameView.h"
47 #include "GraphicsContext.h"
48 #include "HTMLDocument.h"
49 #include "HTMLFormElement.h"
50 #include "HTMLFrameElementBase.h"
51 #include "HTMLGenericFormElement.h"
52 #include "HTMLNames.h"
53 #include "HTMLTableCellElement.h"
54 #include "HitTestResult.h"
55 #include "JSDOMWindowShell.h"
56 #include "Logging.h"
57 #include "markup.h"
58 #include "MediaFeatureNames.h"
59 #include "NP_jsobject.h"
60 #include "Navigator.h"
61 #include "NodeList.h"
62 #include "Page.h"
63 #include "RegularExpression.h"
64 #include "RenderPart.h"
65 #include "RenderTableCell.h"
66 #include "RenderTextControl.h"
67 #include "RenderTheme.h"
68 #include "RenderView.h"
69 #include "Settings.h"
70 #include "SystemTime.h"
71 #include "TextIterator.h"
72 #include "TextResourceDecoder.h"
73 #include "XMLNames.h"
74 #include "kjs_proxy.h"
75 #include "npruntime_impl.h"
76 #include "runtime_root.h"
77 #include "visible_units.h"
78
79 #if FRAME_LOADS_USER_STYLESHEET
80 #include "UserStyleSheetLoader.h"
81 #endif
82
83 #if ENABLE(SVG)
84 #include "SVGDocument.h"
85 #include "SVGDocumentExtensions.h"
86 #include "SVGNames.h"
87 #include "XLinkNames.h"
88 #endif
89
90 using namespace std;
91
92 using KJS::JSLock;
93
94 namespace WebCore {
95
96 using namespace EventNames;
97 using namespace HTMLNames;
98
99 double Frame::s_currentPaintTimeStamp = 0.0;
100
101 #ifndef NDEBUG
102 WTFLogChannel LogWebCoreFrameLeaks =  { 0x00000000, "", WTFLogChannelOn };
103
104 struct FrameCounter { 
105     static int count; 
106     ~FrameCounter() 
107     { 
108         if (count)
109             LOG(WebCoreFrameLeaks, "LEAK: %d Frame\n", count);
110     }
111 };
112 int FrameCounter::count = 0;
113 static FrameCounter frameCounter;
114 #endif
115
116 static inline Frame* parentFromOwnerElement(HTMLFrameOwnerElement* ownerElement)
117 {
118     if (!ownerElement)
119         return 0;
120     return ownerElement->document()->frame();
121 }
122
123 Frame::Frame(Page* page, HTMLFrameOwnerElement* ownerElement, FrameLoaderClient* frameLoaderClient) 
124     : RefCounted<Frame>(0)
125     , d(new FramePrivate(page, parentFromOwnerElement(ownerElement), this, ownerElement, frameLoaderClient))
126 {
127     AtomicString::init();
128     EventNames::init();
129     HTMLNames::init();
130     QualifiedName::init();
131     MediaFeatureNames::init();
132
133 #if ENABLE(SVG)
134     SVGNames::init();
135     XLinkNames::init();
136 #endif
137
138     XMLNames::init();
139
140 #if PLATFORM(MAC) && ENABLE(MAC_JAVA_BRIDGE)
141     static bool initializedJavaJSBindings;
142     if (!initializedJavaJSBindings) {
143         initializedJavaJSBindings = true;
144         initJavaJSBindings();
145     }
146 #endif
147
148     if (!ownerElement)
149         page->setMainFrame(this);
150     else {
151         // FIXME: It's bad to have a ref() here but not in the !ownerElement case.
152         // We need to straighten this out.
153         ref();
154         page->incrementFrameCount();
155         ownerElement->m_contentFrame = this;
156     }
157
158 #ifndef NDEBUG
159     ++FrameCounter::count;
160 #endif
161 }
162
163 Frame::~Frame()
164 {
165     setView(0);
166     loader()->clearRecordedFormValues();
167     loader()->cancelAndClear();
168     
169     // FIXME: We should not be doing all this work inside the destructor
170
171     ASSERT(!d->m_lifeSupportTimer.isActive());
172
173 #ifndef NDEBUG
174     --FrameCounter::count;
175 #endif
176
177     if (d->m_jscript.haveWindowShell())
178         d->m_jscript.windowShell()->disconnectFrame();
179
180     disconnectOwnerElement();
181     
182     if (d->m_domWindow)
183         d->m_domWindow->disconnectFrame();
184             
185     if (d->m_view) {
186         d->m_view->hide();
187         d->m_view->clearFrame();
188     }
189
190     disconnectPlatformScriptObjects();
191
192     ASSERT(!d->m_lifeSupportTimer.isActive());
193
194 #if FRAME_LOADS_USER_STYLESHEET
195     delete d->m_userStyleSheetLoader;
196 #endif
197
198     delete d;
199     d = 0;
200 }
201
202 void Frame::init()
203 {
204     d->m_loader.init();
205 }
206
207 FrameLoader* Frame::loader() const
208 {
209     return &d->m_loader;
210 }
211
212 FrameView* Frame::view() const
213 {
214     return d->m_view.get();
215 }
216
217 void Frame::setView(FrameView* view)
218 {
219     // Detach the document now, so any onUnload handlers get run - if
220     // we wait until the view is destroyed, then things won't be
221     // hooked up enough for some JavaScript calls to work.
222     if (!view && d->m_doc && d->m_doc->attached() && !d->m_doc->inPageCache()) {
223         // FIXME: We don't call willRemove here. Why is that OK?
224         d->m_doc->detach();
225         if (d->m_view)
226             d->m_view->unscheduleRelayout();
227     }
228     eventHandler()->clear();
229
230     d->m_view = view;
231
232     // Only one form submission is allowed per view of a part.
233     // Since this part may be getting reused as a result of being
234     // pulled from the back/forward cache, reset this flag.
235     loader()->resetMultipleFormSubmissionProtection();
236 }
237
238 KJSProxy* Frame::scriptProxy()
239 {
240     return &d->m_jscript;
241 }
242
243 Document* Frame::document() const
244 {
245     return d->m_doc.get();
246 }
247
248 void Frame::setDocument(PassRefPtr<Document> newDoc)
249 {
250     if (d->m_doc && d->m_doc->attached() && !d->m_doc->inPageCache()) {
251         // FIXME: We don't call willRemove here. Why is that OK?
252         d->m_doc->detach();
253     }
254
255     d->m_doc = newDoc;
256     if (d->m_doc && selectionController()->isFocusedAndActive())
257         setUseSecureKeyboardEntry(d->m_doc->useSecureKeyboardEntryWhenActive());
258         
259     if (d->m_doc && !d->m_doc->attached())
260         d->m_doc->attach();
261
262     // Update the cached 'document' property, which is now stale.
263     d->m_jscript.updateDocument();
264 }
265
266 Settings* Frame::settings() const
267 {
268     return d->m_page ? d->m_page->settings() : 0;
269 }
270
271 String Frame::selectedText() const
272 {
273     return plainText(selectionController()->toRange().get());
274 }
275
276 IntRect Frame::firstRectForRange(Range* range) const
277 {
278     int extraWidthToEndOfLine = 0;
279     ExceptionCode ec = 0;
280     ASSERT(range->startContainer(ec));
281     ASSERT(range->endContainer(ec));
282     InlineBox* startInlineBox;
283     int startCaretOffset;
284     range->startPosition().getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);
285     IntRect startCaretRect = range->startContainer(ec)->renderer()->caretRect(startInlineBox, startCaretOffset, &extraWidthToEndOfLine);
286
287     InlineBox* endInlineBox;
288     int endCaretOffset;
289     range->endPosition().getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);
290     IntRect endCaretRect = range->endContainer(ec)->renderer()->caretRect(endInlineBox, endCaretOffset);
291
292     if (startCaretRect.y() == endCaretRect.y()) {
293         // start and end are on the same line
294         return IntRect(min(startCaretRect.x(), endCaretRect.x()), 
295                        startCaretRect.y(), 
296                        abs(endCaretRect.x() - startCaretRect.x()),
297                        max(startCaretRect.height(), endCaretRect.height()));
298     }
299     
300     // start and end aren't on the same line, so go from start to the end of its line
301     return IntRect(startCaretRect.x(), 
302                    startCaretRect.y(),
303                    startCaretRect.width() + extraWidthToEndOfLine,
304                    startCaretRect.height());
305 }
306
307 SelectionController* Frame::selectionController() const
308 {
309     return &d->m_selectionController;
310 }
311
312 Editor* Frame::editor() const
313 {
314     return &d->m_editor;
315 }
316
317 TextGranularity Frame::selectionGranularity() const
318 {
319     return d->m_selectionGranularity;
320 }
321
322 void Frame::setSelectionGranularity(TextGranularity granularity) const
323 {
324     d->m_selectionGranularity = granularity;
325 }
326
327 SelectionController* Frame::dragCaretController() const
328 {
329     return d->m_page->dragCaretController();
330 }
331
332
333 AnimationController* Frame::animationController() const
334 {
335     return &d->m_animationController;
336 }
337
338 static RegularExpression* createRegExpForLabels(const Vector<String>& labels)
339 {
340     // REVIEW- version of this call in FrameMac.mm caches based on the NSArray ptrs being
341     // the same across calls.  We can't do that.
342
343     static RegularExpression wordRegExp = RegularExpression("\\w");
344     String pattern("(");
345     unsigned int numLabels = labels.size();
346     unsigned int i;
347     for (i = 0; i < numLabels; i++) {
348         String label = labels[i];
349
350         bool startsWithWordChar = false;
351         bool endsWithWordChar = false;
352         if (label.length() != 0) {
353             startsWithWordChar = wordRegExp.search(label.substring(0, 1)) >= 0;
354             endsWithWordChar = wordRegExp.search(label.substring(label.length() - 1, 1)) >= 0;
355         }
356         
357         if (i != 0)
358             pattern.append("|");
359         // Search for word boundaries only if label starts/ends with "word characters".
360         // If we always searched for word boundaries, this wouldn't work for languages
361         // such as Japanese.
362         if (startsWithWordChar) {
363             pattern.append("\\b");
364         }
365         pattern.append(label);
366         if (endsWithWordChar) {
367             pattern.append("\\b");
368         }
369     }
370     pattern.append(")");
371     return new RegularExpression(pattern, false);
372 }
373
374 String Frame::searchForLabelsAboveCell(RegularExpression* regExp, HTMLTableCellElement* cell)
375 {
376     RenderTableCell* cellRenderer = static_cast<RenderTableCell*>(cell->renderer());
377
378     if (cellRenderer && cellRenderer->isTableCell()) {
379         RenderTableCell* cellAboveRenderer = cellRenderer->table()->cellAbove(cellRenderer);
380
381         if (cellAboveRenderer) {
382             HTMLTableCellElement* aboveCell =
383                 static_cast<HTMLTableCellElement*>(cellAboveRenderer->element());
384
385             if (aboveCell) {
386                 // search within the above cell we found for a match
387                 for (Node* n = aboveCell->firstChild(); n; n = n->traverseNextNode(aboveCell)) {
388                     if (n->isTextNode() && n->renderer() && n->renderer()->style()->visibility() == VISIBLE) {
389                         // For each text chunk, run the regexp
390                         String nodeString = n->nodeValue();
391                         int pos = regExp->searchRev(nodeString);
392                         if (pos >= 0)
393                             return nodeString.substring(pos, regExp->matchedLength());
394                     }
395                 }
396             }
397         }
398     }
399     // Any reason in practice to search all cells in that are above cell?
400     return String();
401 }
402
403 String Frame::searchForLabelsBeforeElement(const Vector<String>& labels, Element* element)
404 {
405     OwnPtr<RegularExpression> regExp(createRegExpForLabels(labels));
406     // We stop searching after we've seen this many chars
407     const unsigned int charsSearchedThreshold = 500;
408     // This is the absolute max we search.  We allow a little more slop than
409     // charsSearchedThreshold, to make it more likely that we'll search whole nodes.
410     const unsigned int maxCharsSearched = 600;
411     // If the starting element is within a table, the cell that contains it
412     HTMLTableCellElement* startingTableCell = 0;
413     bool searchedCellAbove = false;
414
415     // walk backwards in the node tree, until another element, or form, or end of tree
416     int unsigned lengthSearched = 0;
417     Node* n;
418     for (n = element->traversePreviousNode();
419          n && lengthSearched < charsSearchedThreshold;
420          n = n->traversePreviousNode())
421     {
422         if (n->hasTagName(formTag)
423             || (n->isHTMLElement()
424                 && static_cast<HTMLElement*>(n)->isGenericFormElement()))
425         {
426             // We hit another form element or the start of the form - bail out
427             break;
428         } else if (n->hasTagName(tdTag) && !startingTableCell) {
429             startingTableCell = static_cast<HTMLTableCellElement*>(n);
430         } else if (n->hasTagName(trTag) && startingTableCell) {
431             String result = searchForLabelsAboveCell(regExp.get(), startingTableCell);
432             if (!result.isEmpty())
433                 return result;
434             searchedCellAbove = true;
435         } else if (n->isTextNode() && n->renderer() && n->renderer()->style()->visibility() == VISIBLE) {
436             // For each text chunk, run the regexp
437             String nodeString = n->nodeValue();
438             // add 100 for slop, to make it more likely that we'll search whole nodes
439             if (lengthSearched + nodeString.length() > maxCharsSearched)
440                 nodeString = nodeString.right(charsSearchedThreshold - lengthSearched);
441             int pos = regExp->searchRev(nodeString);
442             if (pos >= 0)
443                 return nodeString.substring(pos, regExp->matchedLength());
444             lengthSearched += nodeString.length();
445         }
446     }
447
448     // If we started in a cell, but bailed because we found the start of the form or the
449     // previous element, we still might need to search the row above us for a label.
450     if (startingTableCell && !searchedCellAbove) {
451          return searchForLabelsAboveCell(regExp.get(), startingTableCell);
452     }
453     return String();
454 }
455
456 String Frame::matchLabelsAgainstElement(const Vector<String>& labels, Element* element)
457 {
458     String name = element->getAttribute(nameAttr);
459     if (name.isEmpty())
460         return String();
461
462     // Make numbers and _'s in field names behave like word boundaries, e.g., "address2"
463     replace(name, RegularExpression("\\d"), " ");
464     name.replace('_', ' ');
465     
466     OwnPtr<RegularExpression> regExp(createRegExpForLabels(labels));
467     // Use the largest match we can find in the whole name string
468     int pos;
469     int length;
470     int bestPos = -1;
471     int bestLength = -1;
472     int start = 0;
473     do {
474         pos = regExp->search(name, start);
475         if (pos != -1) {
476             length = regExp->matchedLength();
477             if (length >= bestLength) {
478                 bestPos = pos;
479                 bestLength = length;
480             }
481             start = pos + 1;
482         }
483     } while (pos != -1);
484
485     if (bestPos != -1)
486         return name.substring(bestPos, bestLength);
487     return String();
488 }
489
490 const Selection& Frame::mark() const
491 {
492     return d->m_mark;
493 }
494
495 void Frame::setMark(const Selection& s)
496 {
497     ASSERT(!s.base().node() || s.base().node()->document() == document());
498     ASSERT(!s.extent().node() || s.extent().node()->document() == document());
499     ASSERT(!s.start().node() || s.start().node()->document() == document());
500     ASSERT(!s.end().node() || s.end().node()->document() == document());
501
502     d->m_mark = s;
503 }
504
505 void Frame::notifyRendererOfSelectionChange(bool userTriggered)
506 {
507     RenderObject* renderer = 0;
508     if (selectionController()->rootEditableElement())
509         renderer = selectionController()->rootEditableElement()->shadowAncestorNode()->renderer();
510
511     // If the current selection is in a textfield or textarea, notify the renderer that the selection has changed
512     if (renderer && (renderer->isTextArea() || renderer->isTextField()))
513         static_cast<RenderTextControl*>(renderer)->selectionChanged(userTriggered);
514 }
515
516 void Frame::invalidateSelection()
517 {
518     selectionController()->setNeedsLayout();
519     selectionLayoutChanged();
520 }
521
522 void Frame::setCaretVisible(bool flag)
523 {
524     if (d->m_caretVisible == flag)
525         return;
526     clearCaretRectIfNeeded();
527     d->m_caretVisible = flag;
528     selectionLayoutChanged();
529 }
530
531 void Frame::clearCaretRectIfNeeded()
532 {
533     if (d->m_caretPaint) {
534         d->m_caretPaint = false;
535         selectionController()->invalidateCaretRect();
536     }
537 }
538
539 // Helper function that tells whether a particular node is an element that has an entire
540 // Frame and FrameView, a <frame>, <iframe>, or <object>.
541 static bool isFrameElement(const Node *n)
542 {
543     if (!n)
544         return false;
545     RenderObject *renderer = n->renderer();
546     if (!renderer || !renderer->isWidget())
547         return false;
548     Widget* widget = static_cast<RenderWidget*>(renderer)->widget();
549     return widget && widget->isFrameView();
550 }
551
552 void Frame::setFocusedNodeIfNeeded()
553 {
554     if (!document() || selectionController()->isNone() || !selectionController()->isFocusedAndActive())
555         return;
556
557     Node* target = selectionController()->rootEditableElement();
558     if (target) {
559         RenderObject* renderer = target->renderer();
560
561         // Walk up the render tree to search for a node to focus.
562         // Walking up the DOM tree wouldn't work for shadow trees, like those behind the engine-based text fields.
563         while (renderer) {
564             // We don't want to set focus on a subframe when selecting in a parent frame,
565             // so add the !isFrameElement check here. There's probably a better way to make this
566             // work in the long term, but this is the safest fix at this time.
567             if (target && target->isMouseFocusable() && !isFrameElement(target)) {
568                 page()->focusController()->setFocusedNode(target, this);
569                 return;
570             }
571             renderer = renderer->parent();
572             if (renderer)
573                 target = renderer->element();
574         }
575         document()->setFocusedNode(0);
576     }
577 }
578
579 void Frame::selectionLayoutChanged()
580 {
581     bool caretRectChanged = selectionController()->recomputeCaretRect();
582
583     bool shouldBlink = d->m_caretVisible
584         && selectionController()->isCaret() && selectionController()->isContentEditable();
585
586     // If the caret moved, stop the blink timer so we can restart with a
587     // black caret in the new location.
588     if (caretRectChanged || !shouldBlink)
589         d->m_caretBlinkTimer.stop();
590
591     // Start blinking with a black caret. Be sure not to restart if we're
592     // already blinking in the right location.
593     if (shouldBlink && !d->m_caretBlinkTimer.isActive()) {
594         d->m_caretBlinkTimer.startRepeating(theme()->caretBlinkFrequency());
595         if (!d->m_caretPaint) {
596             d->m_caretPaint = true;
597             selectionController()->invalidateCaretRect();
598         }
599     }
600
601     RenderView* canvas = contentRenderer();
602     if (!canvas)
603         return;
604
605     Selection selection = selectionController()->selection();
606         
607     if (!selection.isRange())
608         canvas->clearSelection();
609     else {
610         // Use the rightmost candidate for the start of the selection, and the leftmost candidate for the end of the selection.
611         // Example: foo <a>bar</a>.  Imagine that a line wrap occurs after 'foo', and that 'bar' is selected.   If we pass [foo, 3]
612         // as the start of the selection, the selection painting code will think that content on the line containing 'foo' is selected
613         // and will fill the gap before 'bar'.
614         Position startPos = selection.start();
615         if (startPos.downstream().isCandidate())
616             startPos = startPos.downstream();
617         Position endPos = selection.end();
618         if (endPos.upstream().isCandidate())
619             endPos = endPos.upstream();
620         
621         // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
622         // because we don't yet notify the SelectionController of text removal.
623         if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
624             RenderObject *startRenderer = startPos.node()->renderer();
625             RenderObject *endRenderer = endPos.node()->renderer();
626             canvas->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
627         }
628     }
629 }
630
631 void Frame::caretBlinkTimerFired(Timer<Frame>*)
632 {
633     ASSERT(d->m_caretVisible);
634     ASSERT(selectionController()->isCaret());
635     bool caretPaint = d->m_caretPaint;
636     if (selectionController()->isCaretBlinkingSuspended() && caretPaint)
637         return;
638     d->m_caretPaint = !caretPaint;
639     selectionController()->invalidateCaretRect();
640 }
641
642 void Frame::paintCaret(GraphicsContext* p, const IntRect& rect) const
643 {
644     if (d->m_caretPaint && d->m_caretVisible)
645         selectionController()->paintCaret(p, rect);
646 }
647
648 void Frame::paintDragCaret(GraphicsContext* p, const IntRect& rect) const
649 {
650     SelectionController* dragCaretController = d->m_page->dragCaretController();
651     ASSERT(dragCaretController->selection().isCaret());
652     if (dragCaretController->selection().start().node()->document()->frame() == this)
653         dragCaretController->paintCaret(p, rect);
654 }
655
656 float Frame::zoomFactor() const
657 {
658     return d->m_zoomFactor;
659 }
660
661 bool Frame::isZoomFactorTextOnly() const
662 {
663     return d->m_zoomFactorIsTextOnly;
664 }
665
666 bool Frame::shouldApplyTextZoom() const
667 {
668     if (d->m_zoomFactor == 1.0f || !d->m_zoomFactorIsTextOnly)
669         return false;
670 #if ENABLE(SVG)
671     if (d->m_doc && d->m_doc->isSVGDocument())
672         return false;
673 #endif
674     return true;
675 }
676
677 bool Frame::shouldApplyPageZoom() const
678 {
679     if (d->m_zoomFactor == 1.0f || d->m_zoomFactorIsTextOnly)
680         return false;
681 #if ENABLE(SVG)
682     if (d->m_doc && d->m_doc->isSVGDocument())
683         return false;
684 #endif
685     return true;
686 }
687
688 void Frame::setZoomFactor(float percent, bool isTextOnly)
689 {  
690     if (d->m_zoomFactor == percent && d->m_zoomFactorIsTextOnly == isTextOnly)
691         return;
692
693 #if ENABLE(SVG)
694     // SVG doesn't care if the zoom factor is text only.  It will always apply a 
695     // zoom to the whole SVG.
696     if (d->m_doc && d->m_doc->isSVGDocument()) {
697         if (!static_cast<SVGDocument*>(d->m_doc.get())->zoomAndPanEnabled())
698             return;
699         d->m_zoomFactor = percent;
700         d->m_zoomFactorIsTextOnly = true; // We do this to avoid doing any scaling of CSS pixels, since the SVG has its own notion of zoom.
701         if (d->m_doc->renderer())
702             d->m_doc->renderer()->repaint();
703         return;
704     }
705 #endif
706
707     d->m_zoomFactor = percent;
708     d->m_zoomFactorIsTextOnly = isTextOnly;
709
710     if (d->m_doc)
711         d->m_doc->recalcStyle(Node::Force);
712
713     for (Frame* child = tree()->firstChild(); child; child = child->tree()->nextSibling())
714         child->setZoomFactor(d->m_zoomFactor, isTextOnly);
715
716     if (d->m_doc && d->m_doc->renderer() && d->m_doc->renderer()->needsLayout())
717         view()->layout();
718 }
719
720 void Frame::setPrinting(bool printing, float minPageWidth, float maxPageWidth, bool adjustViewSize)
721 {
722     if (!d->m_doc)
723         return;
724
725     d->m_doc->setPrinting(printing);
726     view()->setMediaType(printing ? "print" : "screen");
727     d->m_doc->updateStyleSelector();
728     forceLayoutWithPageWidthRange(minPageWidth, maxPageWidth, adjustViewSize);
729
730     for (Frame* child = tree()->firstChild(); child; child = child->tree()->nextSibling())
731         child->setPrinting(printing, minPageWidth, maxPageWidth, adjustViewSize);
732 }
733
734 void Frame::setJSStatusBarText(const String& text)
735 {
736     d->m_kjsStatusBarText = text;
737     if (d->m_page)
738         d->m_page->chrome()->setStatusbarText(this, d->m_kjsStatusBarText);
739 }
740
741 void Frame::setJSDefaultStatusBarText(const String& text)
742 {
743     d->m_kjsDefaultStatusBarText = text;
744     if (d->m_page)
745         d->m_page->chrome()->setStatusbarText(this, d->m_kjsDefaultStatusBarText);
746 }
747
748 String Frame::jsStatusBarText() const
749 {
750     return d->m_kjsStatusBarText;
751 }
752
753 String Frame::jsDefaultStatusBarText() const
754 {
755    return d->m_kjsDefaultStatusBarText;
756 }
757
758 void Frame::setNeedsReapplyStyles()
759 {
760     if (d->m_needsReapplyStyles)
761         return;
762
763     d->m_needsReapplyStyles = true;
764
765     // Invalidate the FrameView so that FrameView::layout will get called,
766     // which calls reapplyStyles.
767     view()->invalidate();
768 }
769
770 bool Frame::needsReapplyStyles() const
771 {
772     return d->m_needsReapplyStyles;
773 }
774
775 void Frame::reapplyStyles()
776 {
777     d->m_needsReapplyStyles = false;
778
779     // FIXME: This call doesn't really make sense in a method called
780     // "reapplyStyles". We should probably eventually move it into its own
781     // method.
782     if (d->m_doc)
783         d->m_doc->docLoader()->setAutoLoadImages(d->m_page && d->m_page->settings()->loadsImagesAutomatically());
784         
785 #if FRAME_LOADS_USER_STYLESHEET
786     const KURL userStyleSheetLocation = d->m_page ? d->m_page->settings()->userStyleSheetLocation() : KURL();
787     if (!userStyleSheetLocation.isEmpty())
788         setUserStyleSheetLocation(userStyleSheetLocation);
789     else
790         setUserStyleSheet(String());
791 #endif
792
793     // FIXME: It's not entirely clear why the following is needed.
794     // The document automatically does this as required when you set the style sheet.
795     // But we had problems when this code was removed. Details are in
796     // <http://bugs.webkit.org/show_bug.cgi?id=8079>.
797     if (d->m_doc)
798         d->m_doc->updateStyleSelector();
799 }
800
801 bool Frame::shouldChangeSelection(const Selection& newSelection) const
802 {
803     return shouldChangeSelection(selectionController()->selection(), newSelection, newSelection.affinity(), false);
804 }
805
806 bool Frame::shouldChangeSelection(const Selection& oldSelection, const Selection& newSelection, EAffinity affinity, bool stillSelecting) const
807 {
808     return editor()->client()->shouldChangeSelectedRange(oldSelection.toRange().get(), newSelection.toRange().get(),
809                                                          affinity, stillSelecting);
810 }
811
812 bool Frame::shouldDeleteSelection(const Selection& selection) const
813 {
814     return editor()->client()->shouldDeleteRange(selection.toRange().get());
815 }
816
817 bool Frame::isContentEditable() const 
818 {
819     if (d->m_editor.clientIsEditable())
820         return true;
821     if (!d->m_doc)
822         return false;
823     return d->m_doc->inDesignMode();
824 }
825
826 #if !PLATFORM(MAC)
827
828 void Frame::setUseSecureKeyboardEntry(bool)
829 {
830 }
831
832 #endif
833
834 void Frame::updateSecureKeyboardEntryIfActive()
835 {
836     if (selectionController()->isFocusedAndActive())
837         setUseSecureKeyboardEntry(d->m_doc->useSecureKeyboardEntryWhenActive());
838 }
839
840 CSSMutableStyleDeclaration *Frame::typingStyle() const
841 {
842     return d->m_typingStyle.get();
843 }
844
845 void Frame::setTypingStyle(CSSMutableStyleDeclaration *style)
846 {
847     d->m_typingStyle = style;
848 }
849
850 void Frame::clearTypingStyle()
851 {
852     d->m_typingStyle = 0;
853 }
854
855 void Frame::computeAndSetTypingStyle(CSSStyleDeclaration *style, EditAction editingAction)
856 {
857     if (!style || style->length() == 0) {
858         clearTypingStyle();
859         return;
860     }
861
862     // Calculate the current typing style.
863     RefPtr<CSSMutableStyleDeclaration> mutableStyle = style->makeMutable();
864     if (typingStyle()) {
865         typingStyle()->merge(mutableStyle.get());
866         mutableStyle = typingStyle();
867     }
868
869     Node *node = selectionController()->selection().visibleStart().deepEquivalent().node();
870     CSSComputedStyleDeclaration computedStyle(node);
871     computedStyle.diff(mutableStyle.get());
872     
873     // Handle block styles, substracting these from the typing style.
874     RefPtr<CSSMutableStyleDeclaration> blockStyle = mutableStyle->copyBlockProperties();
875     blockStyle->diff(mutableStyle.get());
876     if (document() && blockStyle->length() > 0)
877         applyCommand(new ApplyStyleCommand(document(), blockStyle.get(), editingAction));
878     
879     // Set the remaining style as the typing style.
880     d->m_typingStyle = mutableStyle.release();
881 }
882
883 String Frame::selectionStartStylePropertyValue(int stylePropertyID) const
884 {
885     Node *nodeToRemove;
886     RefPtr<CSSStyleDeclaration> selectionStyle = selectionComputedStyle(nodeToRemove);
887     if (!selectionStyle)
888         return String();
889
890     String value = selectionStyle->getPropertyValue(stylePropertyID);
891
892     if (nodeToRemove) {
893         ExceptionCode ec = 0;
894         nodeToRemove->remove(ec);
895         ASSERT(ec == 0);
896     }
897
898     return value;
899 }
900
901 CSSComputedStyleDeclaration *Frame::selectionComputedStyle(Node *&nodeToRemove) const
902 {
903     nodeToRemove = 0;
904
905     if (!document())
906         return 0;
907
908     if (selectionController()->isNone())
909         return 0;
910
911     RefPtr<Range> range(selectionController()->toRange());
912     Position pos = range->editingStartPosition();
913
914     Element *elem = pos.element();
915     if (!elem)
916         return 0;
917     
918     RefPtr<Element> styleElement = elem;
919     ExceptionCode ec = 0;
920
921     if (d->m_typingStyle) {
922         styleElement = document()->createElementNS(xhtmlNamespaceURI, "span", ec);
923         ASSERT(ec == 0);
924
925         styleElement->setAttribute(styleAttr, d->m_typingStyle->cssText().impl(), ec);
926         ASSERT(ec == 0);
927         
928         styleElement->appendChild(document()->createEditingTextNode(""), ec);
929         ASSERT(ec == 0);
930
931         if (elem->renderer() && elem->renderer()->canHaveChildren()) {
932             elem->appendChild(styleElement, ec);
933         } else {
934             Node *parent = elem->parent();
935             Node *next = elem->nextSibling();
936
937             if (next) {
938                 parent->insertBefore(styleElement, next, ec);
939             } else {
940                 parent->appendChild(styleElement, ec);
941             }
942         }
943         ASSERT(ec == 0);
944
945         nodeToRemove = styleElement.get();
946     }
947
948     return new CSSComputedStyleDeclaration(styleElement);
949 }
950
951 void Frame::textFieldDidBeginEditing(Element* e)
952 {
953     if (editor()->client())
954         editor()->client()->textFieldDidBeginEditing(e);
955 }
956
957 void Frame::textFieldDidEndEditing(Element* e)
958 {
959     if (editor()->client())
960         editor()->client()->textFieldDidEndEditing(e);
961 }
962
963 void Frame::textDidChangeInTextField(Element* e)
964 {
965     if (editor()->client())
966         editor()->client()->textDidChangeInTextField(e);
967 }
968
969 bool Frame::doTextFieldCommandFromEvent(Element* e, KeyboardEvent* ke)
970 {
971     if (editor()->client())
972         return editor()->client()->doTextFieldCommandFromEvent(e, ke);
973
974     return false;
975 }
976
977 void Frame::textWillBeDeletedInTextField(Element* input)
978 {
979     if (editor()->client())
980         editor()->client()->textWillBeDeletedInTextField(input);
981 }
982
983 void Frame::textDidChangeInTextArea(Element* e)
984 {
985     if (editor()->client())
986         editor()->client()->textDidChangeInTextArea(e);
987 }
988
989 void Frame::applyEditingStyleToBodyElement() const
990 {
991     if (!d->m_doc)
992         return;
993         
994     RefPtr<NodeList> list = d->m_doc->getElementsByTagName("body");
995     unsigned len = list->length();
996     for (unsigned i = 0; i < len; i++) {
997         applyEditingStyleToElement(static_cast<Element*>(list->item(i)));    
998     }
999 }
1000
1001 void Frame::removeEditingStyleFromBodyElement() const
1002 {
1003     if (!d->m_doc)
1004         return;
1005         
1006     RefPtr<NodeList> list = d->m_doc->getElementsByTagName("body");
1007     unsigned len = list->length();
1008     for (unsigned i = 0; i < len; i++) {
1009         removeEditingStyleFromElement(static_cast<Element*>(list->item(i)));    
1010     }
1011 }
1012
1013 void Frame::applyEditingStyleToElement(Element* element) const
1014 {
1015     if (!element)
1016         return;
1017
1018     CSSStyleDeclaration* style = element->style();
1019     ASSERT(style);
1020
1021     ExceptionCode ec = 0;
1022     style->setProperty(CSSPropertyWordWrap, "break-word", false, ec);
1023     ASSERT(ec == 0);
1024     style->setProperty(CSSPropertyWebkitNbspMode, "space", false, ec);
1025     ASSERT(ec == 0);
1026     style->setProperty(CSSPropertyWebkitLineBreak, "after-white-space", false, ec);
1027     ASSERT(ec == 0);
1028 }
1029
1030 void Frame::removeEditingStyleFromElement(Element*) const
1031 {
1032 }
1033
1034 #ifndef NDEBUG
1035 static HashSet<Frame*>& keepAliveSet()
1036 {
1037     static HashSet<Frame*> staticKeepAliveSet;
1038     return staticKeepAliveSet;
1039 }
1040 #endif
1041
1042 void Frame::keepAlive()
1043 {
1044     if (d->m_lifeSupportTimer.isActive())
1045         return;
1046 #ifndef NDEBUG
1047     keepAliveSet().add(this);
1048 #endif
1049     ref();
1050     d->m_lifeSupportTimer.startOneShot(0);
1051 }
1052
1053 #ifndef NDEBUG
1054 void Frame::cancelAllKeepAlive()
1055 {
1056     HashSet<Frame*>::iterator end = keepAliveSet().end();
1057     for (HashSet<Frame*>::iterator it = keepAliveSet().begin(); it != end; ++it) {
1058         Frame* frame = *it;
1059         frame->d->m_lifeSupportTimer.stop();
1060         frame->deref();
1061     }
1062     keepAliveSet().clear();
1063 }
1064 #endif
1065
1066 void Frame::lifeSupportTimerFired(Timer<Frame>*)
1067 {
1068 #ifndef NDEBUG
1069     keepAliveSet().remove(this);
1070 #endif
1071     deref();
1072 }
1073
1074 KJS::Bindings::RootObject* Frame::bindingRootObject()
1075 {
1076     if (!scriptProxy()->isEnabled())
1077         return 0;
1078
1079     if (!d->m_bindingRootObject) {
1080         JSLock lock;
1081         d->m_bindingRootObject = KJS::Bindings::RootObject::create(0, scriptProxy()->globalObject());
1082     }
1083     return d->m_bindingRootObject.get();
1084 }
1085
1086 PassRefPtr<KJS::Bindings::RootObject> Frame::createRootObject(void* nativeHandle, KJS::JSGlobalObject* globalObject)
1087 {
1088     RootObjectMap::iterator it = d->m_rootObjects.find(nativeHandle);
1089     if (it != d->m_rootObjects.end())
1090         return it->second;
1091     
1092     RefPtr<KJS::Bindings::RootObject> rootObject = KJS::Bindings::RootObject::create(nativeHandle, globalObject);
1093     
1094     d->m_rootObjects.set(nativeHandle, rootObject);
1095     return rootObject.release();
1096 }
1097
1098 #if ENABLE(NETSCAPE_PLUGIN_API)
1099 NPObject* Frame::windowScriptNPObject()
1100 {
1101     if (!d->m_windowScriptNPObject) {
1102         if (scriptProxy()->isEnabled()) {
1103             // JavaScript is enabled, so there is a JavaScript window object.  Return an NPObject bound to the window
1104             // object.
1105             KJS::JSLock lock;
1106             KJS::JSObject* win = toJSDOMWindow(this);
1107             ASSERT(win);
1108             KJS::Bindings::RootObject* root = bindingRootObject();
1109             d->m_windowScriptNPObject = _NPN_CreateScriptObject(0, win, root);
1110         } else {
1111             // JavaScript is not enabled, so we cannot bind the NPObject to the JavaScript window object.
1112             // Instead, we create an NPObject of a different class, one which is not bound to a JavaScript object.
1113             d->m_windowScriptNPObject = _NPN_CreateNoScriptObject();
1114         }
1115     }
1116
1117     return d->m_windowScriptNPObject;
1118 }
1119 #endif
1120     
1121 void Frame::clearScriptProxy()
1122 {
1123     d->m_jscript.clear();
1124 }
1125
1126 void Frame::clearDOMWindow()
1127 {
1128     if (d->m_domWindow)
1129         d->m_domWindow->clear();
1130     d->m_domWindow = 0;
1131 }
1132
1133 void Frame::cleanupScriptObjectsForPlugin(void* nativeHandle)
1134 {
1135     RootObjectMap::iterator it = d->m_rootObjects.find(nativeHandle);
1136     
1137     if (it == d->m_rootObjects.end())
1138         return;
1139     
1140     it->second->invalidate();
1141     d->m_rootObjects.remove(it);
1142 }
1143     
1144 void Frame::clearScriptObjects()
1145 {
1146     JSLock lock;
1147
1148     RootObjectMap::const_iterator end = d->m_rootObjects.end();
1149     for (RootObjectMap::const_iterator it = d->m_rootObjects.begin(); it != end; ++it)
1150         it->second->invalidate();
1151
1152     d->m_rootObjects.clear();
1153
1154     if (d->m_bindingRootObject) {
1155         d->m_bindingRootObject->invalidate();
1156         d->m_bindingRootObject = 0;
1157     }
1158
1159 #if ENABLE(NETSCAPE_PLUGIN_API)
1160     if (d->m_windowScriptNPObject) {
1161         // Call _NPN_DeallocateObject() instead of _NPN_ReleaseObject() so that we don't leak if a plugin fails to release the window
1162         // script object properly.
1163         // This shouldn't cause any problems for plugins since they should have already been stopped and destroyed at this point.
1164         _NPN_DeallocateObject(d->m_windowScriptNPObject);
1165         d->m_windowScriptNPObject = 0;
1166     }
1167 #endif
1168
1169     clearPlatformScriptObjects();
1170 }
1171
1172 RenderView* Frame::contentRenderer() const
1173 {
1174     Document* doc = document();
1175     if (!doc)
1176         return 0;
1177     RenderObject* object = doc->renderer();
1178     if (!object)
1179         return 0;
1180     ASSERT(object->isRenderView());
1181     return static_cast<RenderView*>(object);
1182 }
1183
1184 HTMLFrameOwnerElement* Frame::ownerElement() const
1185 {
1186     return d->m_ownerElement;
1187 }
1188
1189 RenderPart* Frame::ownerRenderer() const
1190 {
1191     HTMLFrameOwnerElement* ownerElement = d->m_ownerElement;
1192     if (!ownerElement)
1193         return 0;
1194     RenderObject* object = ownerElement->renderer();
1195     if (!object)
1196         return 0;
1197     // FIXME: If <object> is ever fixed to disassociate itself from frames
1198     // that it has started but canceled, then this can turn into an ASSERT
1199     // since d->m_ownerElement would be 0 when the load is canceled.
1200     // https://bugs.webkit.org/show_bug.cgi?id=18585
1201     if (!object->isRenderPart())
1202         return 0;
1203     return static_cast<RenderPart*>(object);
1204 }
1205
1206 // returns FloatRect because going through IntRect would truncate any floats
1207 FloatRect Frame::selectionRect(bool clipToVisibleContent) const
1208 {
1209     RenderView* root = contentRenderer();
1210     if (!root)
1211         return IntRect();
1212     
1213     IntRect selectionRect = root->selectionRect(clipToVisibleContent);
1214     return clipToVisibleContent ? intersection(selectionRect, d->m_view->visibleContentRect()) : selectionRect;
1215 }
1216
1217 void Frame::selectionTextRects(Vector<FloatRect>& rects, bool clipToVisibleContent) const
1218 {
1219     RenderView* root = contentRenderer();
1220     if (!root)
1221         return;
1222
1223     RefPtr<Range> selectedRange = selectionController()->toRange();
1224
1225     Vector<IntRect> intRects;
1226     selectedRange->addLineBoxRects(intRects, true);
1227
1228     unsigned size = intRects.size();
1229     FloatRect visibleContentRect = d->m_view->visibleContentRect();
1230     for (unsigned i = 0; i < size; ++i)
1231         if (clipToVisibleContent)
1232             rects.append(intersection(intRects[i], visibleContentRect));
1233         else
1234             rects.append(intRects[i]);
1235 }
1236
1237
1238 bool Frame::isFrameSet() const
1239 {
1240     Document* document = d->m_doc.get();
1241     if (!document || !document->isHTMLDocument())
1242         return false;
1243     Node *body = static_cast<HTMLDocument*>(document)->body();
1244     return body && body->renderer() && body->hasTagName(framesetTag);
1245 }
1246
1247 // Scans logically forward from "start", including any child frames
1248 static HTMLFormElement *scanForForm(Node *start)
1249 {
1250     Node *n;
1251     for (n = start; n; n = n->traverseNextNode()) {
1252         if (n->hasTagName(formTag))
1253             return static_cast<HTMLFormElement*>(n);
1254         else if (n->isHTMLElement() && static_cast<HTMLElement*>(n)->isGenericFormElement())
1255             return static_cast<HTMLGenericFormElement*>(n)->form();
1256         else if (n->hasTagName(frameTag) || n->hasTagName(iframeTag)) {
1257             Node *childDoc = static_cast<HTMLFrameElementBase*>(n)->contentDocument();
1258             if (HTMLFormElement *frameResult = scanForForm(childDoc))
1259                 return frameResult;
1260         }
1261     }
1262     return 0;
1263 }
1264
1265 // We look for either the form containing the current focus, or for one immediately after it
1266 HTMLFormElement *Frame::currentForm() const
1267 {
1268     // start looking either at the active (first responder) node, or where the selection is
1269     Node *start = d->m_doc ? d->m_doc->focusedNode() : 0;
1270     if (!start)
1271         start = selectionController()->start().node();
1272     
1273     // try walking up the node tree to find a form element
1274     Node *n;
1275     for (n = start; n; n = n->parentNode()) {
1276         if (n->hasTagName(formTag))
1277             return static_cast<HTMLFormElement*>(n);
1278         else if (n->isHTMLElement()
1279                    && static_cast<HTMLElement*>(n)->isGenericFormElement())
1280             return static_cast<HTMLGenericFormElement*>(n)->form();
1281     }
1282     
1283     // try walking forward in the node tree to find a form element
1284     return start ? scanForForm(start) : 0;
1285 }
1286
1287 // FIXME: should this go in SelectionController?
1288 void Frame::revealSelection(const RenderLayer::ScrollAlignment& alignment) const
1289 {
1290     IntRect rect;
1291     
1292     switch (selectionController()->state()) {
1293         case Selection::NONE:
1294             return;
1295             
1296         case Selection::CARET:
1297             rect = selectionController()->caretRect();
1298             break;
1299             
1300         case Selection::RANGE:
1301             rect = enclosingIntRect(selectionRect(false));
1302             break;
1303     }
1304
1305     Position start = selectionController()->start();
1306
1307     ASSERT(start.node());
1308     if (start.node() && start.node()->renderer()) {
1309         // FIXME: This code only handles scrolling the startContainer's layer, but
1310         // the selection rect could intersect more than just that. 
1311         // See <rdar://problem/4799899>.
1312         if (RenderLayer *layer = start.node()->renderer()->enclosingLayer())
1313             layer->scrollRectToVisible(rect, alignment, alignment);
1314     }
1315 }
1316
1317 void Frame::revealCaret(const RenderLayer::ScrollAlignment& alignment) const
1318 {
1319     if (selectionController()->isNone())
1320         return;
1321
1322     Position extent = selectionController()->extent();
1323     if (extent.node() && extent.node()->renderer()) {
1324         IntRect extentRect = VisiblePosition(extent).caretRect();
1325         RenderLayer* layer = extent.node()->renderer()->enclosingLayer();
1326         if (layer)
1327             layer->scrollRectToVisible(extentRect, alignment, alignment);
1328     }
1329 }
1330
1331 // FIXME: why is this here instead of on the FrameView?
1332 void Frame::paint(GraphicsContext* p, const IntRect& rect)
1333 {
1334 #ifndef NDEBUG
1335     bool fillWithRed;
1336     if (!document() || document()->printing())
1337         fillWithRed = false; // Printing, don't fill with red (can't remember why).
1338     else if (document()->ownerElement())
1339         fillWithRed = false; // Subframe, don't fill with red.
1340     else if (view() && view()->isTransparent())
1341         fillWithRed = false; // Transparent, don't fill with red.
1342     else if (d->m_paintRestriction == PaintRestrictionSelectionOnly || d->m_paintRestriction == PaintRestrictionSelectionOnlyBlackText)
1343         fillWithRed = false; // Selections are transparent, don't fill with red.
1344     else if (d->m_elementToDraw)
1345         fillWithRed = false; // Element images are transparent, don't fill with red.
1346     else
1347         fillWithRed = true;
1348     
1349     if (fillWithRed)
1350         p->fillRect(rect, Color(0xFF, 0, 0));
1351 #endif
1352
1353     bool isTopLevelPainter = !s_currentPaintTimeStamp;
1354     if (isTopLevelPainter)
1355         s_currentPaintTimeStamp = currentTime();
1356     
1357     if (contentRenderer()) {
1358         ASSERT(d->m_view && !d->m_view->needsLayout());
1359         ASSERT(!d->m_isPainting);
1360         
1361         d->m_isPainting = true;
1362         
1363         // d->m_elementToDraw is used to draw only one element
1364         RenderObject* eltRenderer = d->m_elementToDraw ? d->m_elementToDraw->renderer() : 0;
1365         if (d->m_paintRestriction == PaintRestrictionNone)
1366             document()->invalidateRenderedRectsForMarkersInRect(rect);
1367         contentRenderer()->layer()->paint(p, rect, d->m_paintRestriction, eltRenderer);
1368         
1369         d->m_isPainting = false;
1370
1371 #if ENABLE(DASHBOARD_SUPPORT)
1372         // Regions may have changed as a result of the visibility/z-index of element changing.
1373         if (document()->dashboardRegionsDirty())
1374             view()->updateDashboardRegions();
1375 #endif
1376     } else
1377         LOG_ERROR("called Frame::paint with nil renderer");
1378         
1379     if (isTopLevelPainter)
1380         s_currentPaintTimeStamp = 0;
1381 }
1382
1383 void Frame::setPaintRestriction(PaintRestriction pr)
1384 {
1385     d->m_paintRestriction = pr;
1386 }
1387     
1388 bool Frame::isPainting() const
1389 {
1390     return d->m_isPainting;
1391 }
1392
1393 void Frame::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float bottomLimit)
1394 {
1395     RenderView* root = contentRenderer();
1396     if (root) {
1397         // Use a context with painting disabled.
1398         GraphicsContext context((PlatformGraphicsContext*)0);
1399         root->setTruncatedAt((int)floorf(oldBottom));
1400         IntRect dirtyRect(0, (int)floorf(oldTop), root->docWidth(), (int)ceilf(oldBottom - oldTop));
1401         root->layer()->paint(&context, dirtyRect);
1402         *newBottom = root->bestTruncatedAt();
1403         if (*newBottom == 0)
1404             *newBottom = oldBottom;
1405     } else
1406         *newBottom = oldBottom;
1407 }
1408
1409 Frame* Frame::frameForWidget(const Widget* widget)
1410 {
1411     ASSERT_ARG(widget, widget);
1412
1413     if (RenderWidget* renderer = RenderWidget::find(widget))
1414         if (Node* node = renderer->node())
1415             return node->document()->frame();
1416
1417     // Assume all widgets are either a FrameView or owned by a RenderWidget.
1418     // FIXME: That assumption is not right for scroll bars!
1419     ASSERT(widget->isFrameView());
1420     return static_cast<const FrameView*>(widget)->frame();
1421 }
1422
1423 void Frame::forceLayout(bool allowSubtree)
1424 {
1425     FrameView *v = d->m_view.get();
1426     if (v) {
1427         v->layout(allowSubtree);
1428         // We cannot unschedule a pending relayout, since the force can be called with
1429         // a tiny rectangle from a drawRect update.  By unscheduling we in effect
1430         // "validate" and stop the necessary full repaint from occurring.  Basically any basic
1431         // append/remove DHTML is broken by this call.  For now, I have removed the optimization
1432         // until we have a better invalidation stategy. -dwh
1433         //v->unscheduleRelayout();
1434     }
1435 }
1436
1437 void Frame::forceLayoutWithPageWidthRange(float minPageWidth, float maxPageWidth, bool adjustViewSize)
1438 {
1439     // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
1440     // the state of things before and after the layout
1441     RenderView *root = static_cast<RenderView*>(document()->renderer());
1442     if (root) {
1443         // This magic is basically copied from khtmlview::print
1444         int pageW = (int)ceilf(minPageWidth);
1445         root->setWidth(pageW);
1446         root->setNeedsLayoutAndPrefWidthsRecalc();
1447         forceLayout();
1448         
1449         // If we don't fit in the minimum page width, we'll lay out again. If we don't fit in the
1450         // maximum page width, we will lay out to the maximum page width and clip extra content.
1451         // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
1452         // implementation should not do this!
1453         int rightmostPos = root->rightmostPosition();
1454         if (rightmostPos > minPageWidth) {
1455             pageW = min(rightmostPos, (int)ceilf(maxPageWidth));
1456             root->setWidth(pageW);
1457             root->setNeedsLayoutAndPrefWidthsRecalc();
1458             forceLayout();
1459         }
1460     }
1461
1462     if (adjustViewSize && view())
1463         view()->adjustViewSize();
1464 }
1465
1466 void Frame::sendResizeEvent()
1467 {
1468     if (Document* doc = document())
1469         doc->dispatchWindowEvent(EventNames::resizeEvent, false, false);
1470 }
1471
1472 void Frame::sendScrollEvent()
1473 {
1474     FrameView* v = d->m_view.get();
1475     if (!v)
1476         return;
1477     v->setWasScrolledByUser(true);
1478     Document* doc = document();
1479     if (!doc)
1480         return;
1481     doc->dispatchHTMLEvent(scrollEvent, true, false);
1482 }
1483
1484 void Frame::clearTimers(FrameView *view, Document *document)
1485 {
1486     if (view) {
1487         view->unscheduleRelayout();
1488         if (view->frame()) {
1489             if (document && document->renderer() && document->renderer()->hasLayer())
1490                 document->renderer()->layer()->suspendMarquees();
1491             view->frame()->animationController()->suspendAnimations();
1492         }
1493     }
1494 }
1495
1496 void Frame::clearTimers()
1497 {
1498     clearTimers(d->m_view.get(), document());
1499 }
1500
1501 RenderStyle *Frame::styleForSelectionStart(Node *&nodeToRemove) const
1502 {
1503     nodeToRemove = 0;
1504     
1505     if (!document())
1506         return 0;
1507     if (selectionController()->isNone())
1508         return 0;
1509     
1510     Position pos = selectionController()->selection().visibleStart().deepEquivalent();
1511     if (!pos.isCandidate())
1512         return 0;
1513     Node *node = pos.node();
1514     if (!node)
1515         return 0;
1516     
1517     if (!d->m_typingStyle)
1518         return node->renderer()->style();
1519     
1520     ExceptionCode ec = 0;
1521     RefPtr<Element> styleElement = document()->createElementNS(xhtmlNamespaceURI, "span", ec);
1522     ASSERT(ec == 0);
1523     
1524     String styleText = d->m_typingStyle->cssText() + " display: inline";
1525     styleElement->setAttribute(styleAttr, styleText.impl(), ec);
1526     ASSERT(ec == 0);
1527     
1528     styleElement->appendChild(document()->createEditingTextNode(""), ec);
1529     ASSERT(ec == 0);
1530     
1531     node->parentNode()->appendChild(styleElement, ec);
1532     ASSERT(ec == 0);
1533     
1534     nodeToRemove = styleElement.get();    
1535     return styleElement->renderer() ? styleElement->renderer()->style() : 0;
1536 }
1537
1538 void Frame::setSelectionFromNone()
1539 {
1540     // Put a caret inside the body if the entire frame is editable (either the 
1541     // entire WebView is editable or designMode is on for this document).
1542     Document *doc = document();
1543     if (!doc || !selectionController()->isNone() || !isContentEditable())
1544         return;
1545         
1546     Node* node = doc->documentElement();
1547     while (node && !node->hasTagName(bodyTag))
1548         node = node->traverseNextNode();
1549     if (node)
1550         selectionController()->setSelection(Selection(Position(node, 0), DOWNSTREAM));
1551 }
1552
1553 bool Frame::inViewSourceMode() const
1554 {
1555     return d->m_inViewSourceMode;
1556 }
1557
1558 void Frame::setInViewSourceMode(bool mode) const
1559 {
1560     d->m_inViewSourceMode = mode;
1561 }
1562
1563 UChar Frame::backslashAsCurrencySymbol() const
1564 {
1565     Document *doc = document();
1566     if (!doc)
1567         return '\\';
1568     TextResourceDecoder *decoder = doc->decoder();
1569     if (!decoder)
1570         return '\\';
1571
1572     return decoder->encoding().backslashAsCurrencySymbol();
1573 }
1574
1575 static bool isInShadowTree(Node* node)
1576 {
1577     for (Node* n = node; n; n = n->parentNode())
1578         if (n->isShadowNode())
1579             return true;
1580     return false;
1581 }
1582
1583 // Searches from the beginning of the document if nothing is selected.
1584 bool Frame::findString(const String& target, bool forward, bool caseFlag, bool wrapFlag, bool startInSelection)
1585 {
1586     if (target.isEmpty() || !document())
1587         return false;
1588     
1589     // Start from an edge of the selection, if there's a selection that's not in shadow content. Which edge
1590     // is used depends on whether we're searching forward or backward, and whether startInSelection is set.
1591     RefPtr<Range> searchRange(rangeOfContents(document()));
1592     Selection selection(selectionController()->selection());
1593     Node* selectionBaseNode = selection.base().node();
1594     
1595     // FIXME 3099526: We don't search in the shadow trees (e.g. text fields and textareas), though we'd like to
1596     // someday. If we don't explicitly skip them here, we'll miss hits in the regular content.
1597     bool selectionIsInMainContent = selectionBaseNode && !isInShadowTree(selectionBaseNode);
1598
1599     if (selectionIsInMainContent) {
1600         if (forward)
1601             setStart(searchRange.get(), startInSelection ? selection.visibleStart() : selection.visibleEnd());
1602         else
1603             setEnd(searchRange.get(), startInSelection ? selection.visibleEnd() : selection.visibleStart());
1604     }
1605     RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, forward, caseFlag));
1606     // If we started in the selection and the found range exactly matches the existing selection, find again.
1607     // Build a selection with the found range to remove collapsed whitespace.
1608     // Compare ranges instead of selection objects to ignore the way that the current selection was made.
1609     if (startInSelection && selectionIsInMainContent && *Selection(resultRange.get()).toRange() == *selection.toRange()) {
1610         searchRange = rangeOfContents(document());
1611         if (forward)
1612             setStart(searchRange.get(), selection.visibleEnd());
1613         else
1614             setEnd(searchRange.get(), selection.visibleStart());
1615         resultRange = findPlainText(searchRange.get(), target, forward, caseFlag);
1616     }
1617     
1618     int exception = 0;
1619     
1620     // If we didn't find anything and we're wrapping, search again in the entire document (this will
1621     // redundantly re-search the area already searched in some cases).
1622     if (resultRange->collapsed(exception) && wrapFlag) {
1623         searchRange = rangeOfContents(document());
1624         resultRange = findPlainText(searchRange.get(), target, forward, caseFlag);
1625         // We used to return false here if we ended up with the same range that we started with
1626         // (e.g., the selection was already the only instance of this text). But we decided that
1627         // this should be a success case instead, so we'll just fall through in that case.
1628     }
1629
1630     if (resultRange->collapsed(exception))
1631         return false;
1632
1633     selectionController()->setSelection(Selection(resultRange.get(), DOWNSTREAM));
1634     revealSelection();
1635     return true;
1636 }
1637
1638 unsigned Frame::markAllMatchesForText(const String& target, bool caseFlag, unsigned limit)
1639 {
1640     if (target.isEmpty() || !document())
1641         return 0;
1642     
1643     RefPtr<Range> searchRange(rangeOfContents(document()));
1644     
1645     int exception = 0;
1646     unsigned matchCount = 0;
1647     do {
1648         RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, caseFlag));
1649         if (resultRange->collapsed(exception))
1650             break;
1651         
1652         // A non-collapsed result range can in some funky whitespace cases still not
1653         // advance the range's start position (4509328). Break to avoid infinite loop.
1654         VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM);
1655         if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
1656             break;
1657
1658         ++matchCount;
1659         
1660         document()->addMarker(resultRange.get(), DocumentMarker::TextMatch);        
1661         
1662         // Stop looking if we hit the specified limit. A limit of 0 means no limit.
1663         if (limit > 0 && matchCount >= limit)
1664             break;
1665         
1666         setStart(searchRange.get(), newStart);
1667     } while (true);
1668     
1669     // Do a "fake" paint in order to execute the code that computes the rendered rect for 
1670     // each text match.
1671     Document* doc = document();
1672     if (doc && d->m_view && contentRenderer()) {
1673         doc->updateLayout(); // Ensure layout is up to date.
1674         IntRect visibleRect(enclosingIntRect(d->m_view->visibleContentRect()));
1675         GraphicsContext context((PlatformGraphicsContext*)0);
1676         context.setPaintingDisabled(true);
1677         paint(&context, visibleRect);
1678     }
1679     
1680     return matchCount;
1681 }
1682
1683 bool Frame::markedTextMatchesAreHighlighted() const
1684 {
1685     return d->m_highlightTextMatches;
1686 }
1687
1688 void Frame::setMarkedTextMatchesAreHighlighted(bool flag)
1689 {
1690     if (flag == d->m_highlightTextMatches || !document())
1691         return;
1692     
1693     d->m_highlightTextMatches = flag;
1694     document()->repaintMarkers(DocumentMarker::TextMatch);
1695 }
1696
1697 FrameTree* Frame::tree() const
1698 {
1699     return &d->m_treeNode;
1700 }
1701
1702 DOMWindow* Frame::domWindow() const
1703 {
1704     if (!d->m_domWindow)
1705         d->m_domWindow = DOMWindow::create(const_cast<Frame*>(this));
1706
1707     return d->m_domWindow.get();
1708 }
1709
1710 Page* Frame::page() const
1711 {
1712     return d->m_page;
1713 }
1714
1715 EventHandler* Frame::eventHandler() const
1716 {
1717     return &d->m_eventHandler;
1718 }
1719
1720 void Frame::pageDestroyed()
1721 {
1722     if (Frame* parent = tree()->parent())
1723         parent->loader()->checkLoadComplete();
1724
1725     if (d->m_page && d->m_page->focusController()->focusedFrame() == this)
1726         d->m_page->focusController()->setFocusedFrame(0);
1727
1728     // This will stop any JS timers
1729     if (d->m_jscript.haveWindowShell()) {
1730         if (JSDOMWindowShell* windowShell = toJSDOMWindowShell(this))
1731             windowShell->disconnectFrame();
1732     }
1733
1734     clearScriptObjects();
1735     
1736     d->m_page = 0;
1737 }
1738
1739 void Frame::disconnectOwnerElement()
1740 {
1741     if (d->m_ownerElement) {
1742         if (Document* doc = document())
1743             doc->clearAXObjectCache();
1744         d->m_ownerElement->m_contentFrame = 0;
1745         if (d->m_page)
1746             d->m_page->decrementFrameCount();
1747     }
1748     d->m_ownerElement = 0;
1749 }
1750
1751 String Frame::documentTypeString() const
1752 {
1753     if (Document* doc = document()) {
1754         if (DocumentType* doctype = doc->doctype())
1755             return createMarkup(doctype);
1756     }
1757
1758     return String();
1759 }
1760
1761 bool Frame::prohibitsScrolling() const
1762 {
1763     return d->m_prohibitsScrolling;
1764 }
1765
1766 void Frame::setProhibitsScrolling(bool prohibit)
1767 {
1768     d->m_prohibitsScrolling = prohibit;
1769 }
1770
1771 void Frame::focusWindow()
1772 {
1773     if (!page())
1774         return;
1775
1776     // If we're a top level window, bring the window to the front.
1777     if (!tree()->parent())
1778         page()->chrome()->focus();
1779
1780     eventHandler()->focusDocumentView();
1781 }
1782
1783 void Frame::unfocusWindow()
1784 {
1785     if (!page())
1786         return;
1787     
1788     // If we're a top level window, deactivate the window.
1789     if (!tree()->parent())
1790         page()->chrome()->unfocus();
1791 }
1792
1793 bool Frame::shouldClose()
1794 {
1795     Chrome* chrome = page() ? page()->chrome() : 0;
1796     if (!chrome || !chrome->canRunBeforeUnloadConfirmPanel())
1797         return true;
1798
1799     RefPtr<Document> doc = document();
1800     if (!doc)
1801         return true;
1802     HTMLElement* body = doc->body();
1803     if (!body)
1804         return true;
1805
1806     RefPtr<BeforeUnloadEvent> beforeUnloadEvent = new BeforeUnloadEvent;
1807     beforeUnloadEvent->setTarget(doc);
1808     doc->handleWindowEvent(beforeUnloadEvent.get(), false);
1809
1810     if (!beforeUnloadEvent->defaultPrevented() && doc)
1811         doc->defaultEventHandler(beforeUnloadEvent.get());
1812     if (beforeUnloadEvent->result().isNull())
1813         return true;
1814
1815     String text = beforeUnloadEvent->result();
1816     text.replace('\\', backslashAsCurrencySymbol());
1817
1818     return chrome->runBeforeUnloadConfirmPanel(text, this);
1819 }
1820
1821 void Frame::scheduleClose()
1822 {
1823     if (!shouldClose())
1824         return;
1825
1826     Chrome* chrome = page() ? page()->chrome() : 0;
1827     if (chrome)
1828         chrome->closeWindowSoon();
1829 }
1830
1831 void Frame::respondToChangedSelection(const Selection& oldSelection, bool closeTyping)
1832 {
1833     if (document()) {
1834         bool isContinuousSpellCheckingEnabled = editor()->isContinuousSpellCheckingEnabled();
1835         bool isContinuousGrammarCheckingEnabled = isContinuousSpellCheckingEnabled && editor()->isGrammarCheckingEnabled();
1836         if (isContinuousSpellCheckingEnabled) {
1837             Selection newAdjacentWords;
1838             Selection newSelectedSentence;
1839             if (selectionController()->selection().isContentEditable()) {
1840                 VisiblePosition newStart(selectionController()->selection().visibleStart());
1841                 newAdjacentWords = Selection(startOfWord(newStart, LeftWordIfOnBoundary), endOfWord(newStart, RightWordIfOnBoundary));
1842                 if (isContinuousGrammarCheckingEnabled)
1843                     newSelectedSentence = Selection(startOfSentence(newStart), endOfSentence(newStart));
1844             }
1845
1846             // When typing we check spelling elsewhere, so don't redo it here.
1847             // If this is a change in selection resulting from a delete operation,
1848             // oldSelection may no longer be in the document.
1849             if (closeTyping && oldSelection.isContentEditable() && oldSelection.start().node() && oldSelection.start().node()->inDocument()) {
1850                 VisiblePosition oldStart(oldSelection.visibleStart());
1851                 Selection oldAdjacentWords = Selection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));   
1852                 if (oldAdjacentWords != newAdjacentWords) {
1853                     editor()->markMisspellings(oldAdjacentWords);
1854                     if (isContinuousGrammarCheckingEnabled) {
1855                         Selection oldSelectedSentence = Selection(startOfSentence(oldStart), endOfSentence(oldStart));   
1856                         if (oldSelectedSentence != newSelectedSentence)
1857                             editor()->markBadGrammar(oldSelectedSentence);
1858                     }
1859                 }
1860             }
1861
1862             // This only erases markers that are in the first unit (word or sentence) of the selection.
1863             // Perhaps peculiar, but it matches AppKit.
1864             if (RefPtr<Range> wordRange = newAdjacentWords.toRange())
1865                 document()->removeMarkers(wordRange.get(), DocumentMarker::Spelling);
1866             if (RefPtr<Range> sentenceRange = newSelectedSentence.toRange())
1867                 document()->removeMarkers(sentenceRange.get(), DocumentMarker::Grammar);
1868         }
1869
1870         // When continuous spell checking is off, existing markers disappear after the selection changes.
1871         if (!isContinuousSpellCheckingEnabled)
1872             document()->removeMarkers(DocumentMarker::Spelling);
1873         if (!isContinuousGrammarCheckingEnabled)
1874             document()->removeMarkers(DocumentMarker::Grammar);
1875     }
1876
1877     editor()->respondToChangedSelection(oldSelection);
1878 }
1879
1880 VisiblePosition Frame::visiblePositionForPoint(const IntPoint& framePoint)
1881 {
1882     HitTestResult result = eventHandler()->hitTestResultAtPoint(framePoint, true);
1883     Node* node = result.innerNode();
1884     if (!node)
1885         return VisiblePosition();
1886     RenderObject* renderer = node->renderer();
1887     if (!renderer)
1888         return VisiblePosition();
1889     VisiblePosition visiblePos = renderer->positionForCoordinates(result.localPoint().x(), result.localPoint().y());
1890     if (visiblePos.isNull())
1891         visiblePos = VisiblePosition(Position(node, 0));
1892     return visiblePos;
1893 }
1894     
1895 Document* Frame::documentAtPoint(const IntPoint& point)
1896 {  
1897     if (!view()) 
1898         return 0;
1899     
1900     IntPoint pt = view()->windowToContents(point);
1901     HitTestResult result = HitTestResult(pt);
1902     
1903     if (contentRenderer())
1904         result = eventHandler()->hitTestResultAtPoint(pt, false);
1905     return result.innerNode() ? result.innerNode()->document() : 0;
1906 }
1907     
1908 FramePrivate::FramePrivate(Page* page, Frame* parent, Frame* thisFrame, HTMLFrameOwnerElement* ownerElement,
1909                            FrameLoaderClient* frameLoaderClient)
1910     : m_page(page)
1911     , m_treeNode(thisFrame, parent)
1912     , m_loader(thisFrame, frameLoaderClient)
1913     , m_ownerElement(ownerElement)
1914     , m_jscript(thisFrame)
1915     , m_zoomFactor(parent ? parent->d->m_zoomFactor : 1.0f)
1916     , m_zoomFactorIsTextOnly(parent ? parent->d->m_zoomFactorIsTextOnly : true)
1917     , m_selectionGranularity(CharacterGranularity)
1918     , m_selectionController(thisFrame)
1919     , m_caretBlinkTimer(thisFrame, &Frame::caretBlinkTimerFired)
1920     , m_editor(thisFrame)
1921     , m_eventHandler(thisFrame)
1922     , m_animationController(thisFrame)
1923     , m_caretVisible(false)
1924     , m_caretPaint(true)
1925     , m_isPainting(false)
1926     , m_lifeSupportTimer(thisFrame, &Frame::lifeSupportTimerFired)
1927     , m_paintRestriction(PaintRestrictionNone)
1928     , m_highlightTextMatches(false)
1929     , m_inViewSourceMode(false)
1930     , frameCount(0)
1931     , m_prohibitsScrolling(false)
1932     , m_needsReapplyStyles(false)
1933 #if ENABLE(NETSCAPE_PLUGIN_API)
1934     , m_windowScriptNPObject(0)
1935 #endif
1936 #if FRAME_LOADS_USER_STYLESHEET
1937     , m_userStyleSheetLoader(0)
1938 #endif
1939 #if PLATFORM(MAC)
1940     , m_windowScriptObject(nil)
1941 #endif
1942 {
1943 }
1944
1945 FramePrivate::~FramePrivate()
1946 {
1947 }
1948
1949 } // namespace WebCore