Forgot to capitalize the "US".
[WebKit-https.git] / WebCore / page / FrameView.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 Dirk Mueller <mueller@kde.org>
6  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
7  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
8  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "FrameView.h"
28
29 #include "AXObjectCache.h"
30 #include "CSSStyleSelector.h"
31 #include "ChromeClient.h"
32 #include "DocLoader.h"
33 #include "EventHandler.h"
34 #include "FloatRect.h"
35 #include "FocusController.h"
36 #include "Frame.h"
37 #include "FrameLoader.h"
38 #include "FrameLoaderClient.h"
39 #include "FrameTree.h"
40 #include "GraphicsContext.h"
41 #include "HTMLDocument.h"
42 #include "HTMLFrameElement.h"
43 #include "HTMLFrameSetElement.h"
44 #include "HTMLNames.h"
45 #include "OverflowEvent.h"
46 #include "Page.h"
47 #include "RenderPart.h"
48 #include "RenderPartObject.h"
49 #include "RenderScrollbar.h"
50 #include "RenderTheme.h"
51 #include "RenderView.h"
52 #include "Settings.h"
53 #include <wtf/CurrentTime.h>
54
55 #if USE(ACCELERATED_COMPOSITING)
56 #include "RenderLayerCompositor.h"
57 #endif
58
59 namespace WebCore {
60
61 using namespace HTMLNames;
62
63 double FrameView::sCurrentPaintTimeStamp = 0.0;
64
65 #if ENABLE(REPAINT_THROTTLING)
66 // Normal delay
67 static const double deferredRepaintDelay = 0.025;
68 // Negative value would mean that first few repaints happen without a delay
69 static const double initialDeferredRepaintDelayDuringLoading = 0;
70 // The delay grows on each repaint to this maximum value
71 static const double maxDeferredRepaintDelayDuringLoading = 2.5;
72 // On each repaint the delay increses by this amount
73 static const double deferredRepaintDelayIncrementDuringLoading = 0.5;
74 #else
75 // FIXME: Repaint throttling could be good to have on all platform.
76 // The balance between CPU use and repaint frequency will need some tuning for desktop.
77 // More hooks may be needed to reset the delay on things like GIF and CSS animations.
78 static const double deferredRepaintDelay = 0;
79 static const double initialDeferredRepaintDelayDuringLoading = 0;
80 static const double maxDeferredRepaintDelayDuringLoading = 0;
81 static const double deferredRepaintDelayIncrementDuringLoading = 0;
82 #endif
83
84 // The maximum number of updateWidgets iterations that should be done before returning.
85 static const unsigned maxUpdateWidgetsIterations = 2;
86
87 struct ScheduledEvent {
88     RefPtr<Event> m_event;
89     RefPtr<Node> m_eventTarget;
90 };
91
92 FrameView::FrameView(Frame* frame)
93     : m_refCount(1)
94     , m_frame(frame)
95     , m_vmode(ScrollbarAuto)
96     , m_hmode(ScrollbarAuto)
97     , m_slowRepaintObjectCount(0)
98     , m_layoutTimer(this, &FrameView::layoutTimerFired)
99     , m_layoutRoot(0)
100     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
101     , m_needToInitScrollbars(true)
102     , m_isTransparent(false)
103     , m_baseBackgroundColor(Color::white)
104     , m_mediaType("screen")
105     , m_enqueueEvents(0)
106     , m_overflowStatusDirty(true)
107     , m_viewportRenderer(0)
108     , m_wasScrolledByUser(false)
109     , m_inProgrammaticScroll(false)
110     , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)
111     , m_shouldUpdateWhileOffscreen(true)
112 {
113     init();
114     show();
115 }
116
117 FrameView::FrameView(Frame* frame, const IntSize& initialSize)
118     : m_refCount(1)
119     , m_frame(frame)
120     , m_vmode(ScrollbarAuto)
121     , m_hmode(ScrollbarAuto)
122     , m_slowRepaintObjectCount(0)
123     , m_layoutTimer(this, &FrameView::layoutTimerFired)
124     , m_layoutRoot(0)
125     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
126     , m_needToInitScrollbars(true)
127     , m_isTransparent(false)
128     , m_baseBackgroundColor(Color::white)
129     , m_mediaType("screen")
130     , m_enqueueEvents(0)
131     , m_overflowStatusDirty(true)
132     , m_viewportRenderer(0)
133     , m_wasScrolledByUser(false)
134     , m_inProgrammaticScroll(false)
135     , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)
136     , m_shouldUpdateWhileOffscreen(true)
137 {
138     init();
139     Widget::setFrameRect(IntRect(x(), y(), initialSize.width(), initialSize.height()));
140     show();
141 }
142
143 FrameView::~FrameView()
144 {
145     if (m_postLayoutTasksTimer.isActive()) {
146         m_postLayoutTasksTimer.stop();
147         m_scheduledEvents.clear();
148         m_enqueueEvents = 0;
149     }
150
151     resetScrollbars();
152     setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.
153     setHasVerticalScrollbar(false);
154     
155     ASSERT(m_refCount == 0);
156     ASSERT(m_scheduledEvents.isEmpty());
157     ASSERT(!m_enqueueEvents);
158
159     if (m_frame) {
160         ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
161         RenderPart* renderer = m_frame->ownerRenderer();
162         if (renderer && renderer->widget() == this)
163             renderer->setWidget(0);
164     }
165 }
166
167 void FrameView::reset()
168 {
169     m_useSlowRepaints = false;
170     m_borderX = 30;
171     m_borderY = 30;
172     m_layoutTimer.stop();
173     m_layoutRoot = 0;
174     m_delayedLayout = false;
175     m_doFullRepaint = true;
176     m_layoutSchedulingEnabled = true;
177     m_midLayout = false;
178     m_layoutCount = 0;
179     m_nestedLayoutCount = 0;
180     m_postLayoutTasksTimer.stop();
181     m_firstLayout = true;
182     m_firstLayoutCallbackPending = false;
183     m_wasScrolledByUser = false;
184     m_lastLayoutSize = IntSize();
185     m_lastZoomFactor = 1.0f;
186     m_deferringRepaints = 0;
187     m_repaintCount = 0;
188     m_repaintRects.clear();
189     m_deferredRepaintDelay = initialDeferredRepaintDelayDuringLoading;
190     m_deferredRepaintTimer.stop();
191     m_lastPaintTime = 0;
192     m_paintRestriction = PaintRestrictionNone;
193     m_isPainting = false;
194     m_isVisuallyNonEmpty = false;
195     m_firstVisuallyNonEmptyLayoutCallbackPending = true;
196 }
197
198 bool FrameView::isFrameView() const 
199
200     return true; 
201 }
202
203 void FrameView::clearFrame()
204 {
205     m_frame = 0;
206 }
207
208 void FrameView::resetScrollbars()
209 {
210     // Reset the document's scrollbars back to our defaults before we yield the floor.
211     m_firstLayout = true;
212     setScrollbarsSuppressed(true);
213     setScrollbarModes(m_hmode, m_vmode);
214     setScrollbarsSuppressed(false);
215 }
216
217 void FrameView::init()
218 {
219     reset();
220
221     m_margins = IntSize(-1, -1); // undefined
222     m_size = IntSize();
223
224     // Propagate the marginwidth/height and scrolling modes to the view.
225     Element* ownerElement = m_frame && m_frame->document() ? m_frame->document()->ownerElement() : 0;
226     if (ownerElement && (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag))) {
227         HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
228         if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
229             setCanHaveScrollbars(false);
230         int marginWidth = frameElt->getMarginWidth();
231         int marginHeight = frameElt->getMarginHeight();
232         if (marginWidth != -1)
233             setMarginWidth(marginWidth);
234         if (marginHeight != -1)
235             setMarginHeight(marginHeight);
236     }
237 }
238
239 void FrameView::clear()
240 {
241     setCanBlitOnScroll(true);
242     
243     reset();
244
245     if (m_frame) {
246         if (RenderPart* renderer = m_frame->ownerRenderer())
247             renderer->viewCleared();
248     }
249
250     setScrollbarsSuppressed(true);
251 }
252
253 bool FrameView::didFirstLayout() const
254 {
255     return !m_firstLayout;
256 }
257
258 void FrameView::initScrollbars()
259 {
260     if (!m_needToInitScrollbars)
261         return;
262     m_needToInitScrollbars = false;
263     updateDefaultScrollbarState();
264 }
265
266 void FrameView::updateDefaultScrollbarState()
267 {
268     m_hmode = horizontalScrollbarMode();
269     m_vmode = verticalScrollbarMode();
270     setScrollbarModes(m_hmode, m_vmode);
271 }
272
273 void FrameView::invalidateRect(const IntRect& rect)
274 {
275     if (!parent()) {
276         if (hostWindow())
277             hostWindow()->repaint(rect, true);
278         return;
279     }
280
281     if (!m_frame)
282         return;
283
284     RenderPart* renderer = m_frame->ownerRenderer();
285     if (!renderer)
286         return;
287
288     IntRect repaintRect = rect;
289     repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),
290                      renderer->borderTop() + renderer->paddingTop());
291     renderer->repaintRectangle(repaintRect);
292 }
293
294 void FrameView::setMarginWidth(int w)
295 {
296     // make it update the rendering area when set
297     m_margins.setWidth(w);
298 }
299
300 void FrameView::setMarginHeight(int h)
301 {
302     // make it update the rendering area when set
303     m_margins.setHeight(h);
304 }
305
306 void FrameView::setCanHaveScrollbars(bool canScroll)
307 {
308     ScrollView::setCanHaveScrollbars(canScroll);
309     scrollbarModes(m_hmode, m_vmode);
310 }
311
312 PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation)
313 {
314     // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).
315     Document* doc = m_frame->document();
316
317     // Try the <body> element first as a scrollbar source.
318     Element* body = doc ? doc->body() : 0;
319     if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR))
320         return RenderScrollbar::createCustomScrollbar(this, orientation, body->renderBox());
321     
322     // If the <body> didn't have a custom style, then the root element might.
323     Element* docElement = doc ? doc->documentElement() : 0;
324     if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR))
325         return RenderScrollbar::createCustomScrollbar(this, orientation, docElement->renderBox());
326         
327     // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
328     RenderPart* frameRenderer = m_frame->ownerRenderer();
329     if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR))
330         return RenderScrollbar::createCustomScrollbar(this, orientation, frameRenderer);
331     
332     // Nobody set a custom style, so we just use a native scrollbar.
333     return ScrollView::createScrollbar(orientation);
334 }
335
336 void FrameView::setContentsSize(const IntSize& size)
337 {
338     ScrollView::setContentsSize(size);
339
340     Page* page = frame() ? frame()->page() : 0;
341     if (!page)
342         return;
343
344     page->chrome()->contentsSizeChanged(frame(), size); //notify only
345 }
346
347 void FrameView::adjustViewSize()
348 {
349     ASSERT(m_frame->view() == this);
350     RenderView* root = m_frame->contentRenderer();
351     if (!root)
352         return;
353     setContentsSize(IntSize(root->overflowWidth(), root->overflowHeight()));
354 }
355
356 void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)
357 {
358     // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats
359     // overflow:hidden and overflow:scroll on <body> as applying to the document's
360     // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
361     // use the root element.
362     switch (o->style()->overflowX()) {
363         case OHIDDEN:
364             hMode = ScrollbarAlwaysOff;
365             break;
366         case OSCROLL:
367             hMode = ScrollbarAlwaysOn;
368             break;
369         case OAUTO:
370             hMode = ScrollbarAuto;
371             break;
372         default:
373             // Don't set it at all.
374             ;
375     }
376     
377      switch (o->style()->overflowY()) {
378         case OHIDDEN:
379             vMode = ScrollbarAlwaysOff;
380             break;
381         case OSCROLL:
382             vMode = ScrollbarAlwaysOn;
383             break;
384         case OAUTO:
385             vMode = ScrollbarAuto;
386             break;
387         default:
388             // Don't set it at all.
389             ;
390     }
391
392     m_viewportRenderer = o;
393 }
394
395 #if USE(ACCELERATED_COMPOSITING)
396 void FrameView::updateCompositingLayers(CompositingUpdate updateType)
397 {
398     RenderView* view = m_frame->contentRenderer();
399     if (!view || !view->usesCompositing())
400         return;
401
402     if (updateType == ForcedCompositingUpdate)
403         view->compositor()->setCompositingLayersNeedUpdate();
404     
405     view->compositor()->updateCompositingLayers();
406 }
407
408 void FrameView::setNeedsOneShotDrawingSynchronization()
409 {
410     Page* page = frame() ? frame()->page() : 0;
411     if (page)
412         page->chrome()->client()->setNeedsOneShotDrawingSynchronization();
413 }
414 #endif // USE(ACCELERATED_COMPOSITING)
415
416 void FrameView::didMoveOnscreen()
417 {
418     RenderView* view = m_frame->contentRenderer();
419     if (view)
420         view->didMoveOnscreen();
421 }
422
423 void FrameView::willMoveOffscreen()
424 {
425     RenderView* view = m_frame->contentRenderer();
426     if (view)
427         view->willMoveOffscreen();
428 }
429
430 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
431 {
432     return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;
433 }
434
435 void FrameView::layout(bool allowSubtree)
436 {
437     if (m_midLayout)
438         return;
439
440     m_layoutTimer.stop();
441     m_delayedLayout = false;
442
443     // Protect the view from being deleted during layout (in recalcStyle)
444     RefPtr<FrameView> protector(this);
445
446     if (!m_frame) {
447         // FIXME: Do we need to set m_size.width here?
448         // FIXME: Should we set m_size.height here too?
449         m_size.setWidth(layoutWidth());
450         return;
451     }
452     
453     // we shouldn't enter layout() while painting
454     ASSERT(!isPainting());
455     if (isPainting())
456         return;
457
458     if (!allowSubtree && m_layoutRoot) {
459         m_layoutRoot->markContainingBlocksForLayout(false);
460         m_layoutRoot = 0;
461     }
462
463     ASSERT(m_frame->view() == this);
464     // This early return should be removed when rdar://5598072 is resolved. In the meantime, there is a
465     // gigantic CrashTracer because of this issue, and the early return will hopefully cause graceful 
466     // failure instead.  
467     if (m_frame->view() != this)
468         return;
469
470     Document* document = m_frame->document();
471
472     m_layoutSchedulingEnabled = false;
473
474     if (!m_nestedLayoutCount && m_postLayoutTasksTimer.isActive()) {
475         // This is a new top-level layout. If there are any remaining tasks from the previous
476         // layout, finish them now.
477         m_postLayoutTasksTimer.stop();
478         performPostLayoutTasks();
479     }
480
481     // Viewport-dependent media queries may cause us to need completely different style information.
482     // Check that here.
483     if (document->styleSelector()->affectedByViewportChange())
484         document->updateStyleSelector();
485
486     // Always ensure our style info is up-to-date.  This can happen in situations where
487     // the layout beats any sort of style recalc update that needs to occur.
488     if (m_frame->needsReapplyStyles())
489         m_frame->reapplyStyles();
490     else if (document->childNeedsStyleRecalc())
491         document->recalcStyle();
492     
493     bool subtree = m_layoutRoot;
494
495     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit, 
496     // so there's no point to continuing to layout
497     if (protector->hasOneRef())
498         return;
499
500     RenderObject* root = subtree ? m_layoutRoot : document->renderer();
501     if (!root) {
502         // FIXME: Do we need to set m_size here?
503         m_layoutSchedulingEnabled = true;
504         return;
505     }
506
507     m_nestedLayoutCount++;
508
509     ScrollbarMode hMode = m_hmode;
510     ScrollbarMode vMode = m_vmode;
511
512     if (!subtree) {
513         RenderObject* rootRenderer = document->documentElement() ? document->documentElement()->renderer() : 0;
514         Node* body = document->body();
515         if (body && body->renderer()) {
516             if (body->hasTagName(framesetTag)) {
517                 body->renderer()->setChildNeedsLayout(true);
518                 vMode = ScrollbarAlwaysOff;
519                 hMode = ScrollbarAlwaysOff;
520             } else if (body->hasTagName(bodyTag)) {
521                 if (!m_firstLayout && m_size.height() != layoutHeight()
522                         && toRenderBox(body->renderer())->stretchesToViewHeight())
523                     body->renderer()->setChildNeedsLayout(true);
524                 // It's sufficient to just check the X overflow,
525                 // since it's illegal to have visible in only one direction.
526                 RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE && document->documentElement()->hasTagName(htmlTag) ? body->renderer() : rootRenderer;
527                 applyOverflowToViewport(o, hMode, vMode);
528             }
529         } else if (rootRenderer)
530             applyOverflowToViewport(rootRenderer, hMode, vMode);
531 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
532         if (m_firstLayout && !document->ownerElement())
533             printf("Elapsed time before first layout: %d\n", document->elapsedTime());
534 #endif
535     }
536
537     m_doFullRepaint = !subtree && (m_firstLayout || toRenderView(root)->printing());
538
539     if (!subtree) {
540         // Now set our scrollbar state for the layout.
541         ScrollbarMode currentHMode = horizontalScrollbarMode();
542         ScrollbarMode currentVMode = verticalScrollbarMode();
543
544         if (m_firstLayout || (hMode != currentHMode || vMode != currentVMode)) {
545             setScrollbarsSuppressed(true);
546             if (m_firstLayout) {
547                 m_firstLayout = false;
548                 m_firstLayoutCallbackPending = true;
549                 m_lastLayoutSize = IntSize(width(), height());
550                 m_lastZoomFactor = root->style()->zoom();
551
552                 // Set the initial vMode to AlwaysOn if we're auto.
553                 if (vMode == ScrollbarAuto)
554                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
555                 // Set the initial hMode to AlwaysOff if we're auto.
556                 if (hMode == ScrollbarAuto)
557                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
558             }
559             setScrollbarModes(hMode, vMode);
560             setScrollbarsSuppressed(false, true);
561         }
562
563         IntSize oldSize = m_size;
564
565         m_size = IntSize(layoutWidth(), layoutHeight());
566
567         if (oldSize != m_size)
568             m_doFullRepaint = true;
569     }
570
571     RenderLayer* layer = root->enclosingLayer();
572
573     pauseScheduledEvents();
574
575     if (subtree)
576         root->view()->pushLayoutState(root);
577         
578     m_midLayout = true;
579     beginDeferredRepaints();
580     root->layout();
581     endDeferredRepaints();
582     m_midLayout = false;
583
584     if (subtree)
585         root->view()->popLayoutState();
586     m_layoutRoot = 0;
587
588     m_frame->invalidateSelection();
589    
590     m_layoutSchedulingEnabled = true;
591
592     if (!subtree && !toRenderView(root)->printing())
593         adjustViewSize();
594
595     // Now update the positions of all layers.
596     beginDeferredRepaints();
597     layer->updateLayerPositions(m_doFullRepaint);
598     endDeferredRepaints();
599
600 #if USE(ACCELERATED_COMPOSITING)
601     updateCompositingLayers();
602 #endif
603     
604     m_layoutCount++;
605
606 #if PLATFORM(MAC)
607     if (AXObjectCache::accessibilityEnabled())
608         root->document()->axObjectCache()->postNotificationToElement(root, "AXLayoutComplete");
609 #endif
610 #if ENABLE(DASHBOARD_SUPPORT)
611     updateDashboardRegions();
612 #endif
613
614     ASSERT(!root->needsLayout());
615
616     setCanBlitOnScroll(!useSlowRepaints());
617
618     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
619         updateOverflowStatus(layoutWidth() < contentsWidth(),
620                              layoutHeight() < contentsHeight());
621
622     if (!m_postLayoutTasksTimer.isActive()) {
623         // Calls resumeScheduledEvents()
624         performPostLayoutTasks();
625
626         if (!m_postLayoutTasksTimer.isActive() && needsLayout()) {
627             // Post-layout widget updates or an event handler made us need layout again.
628             // Lay out again, but this time defer widget updates and event dispatch until after
629             // we return.
630             m_postLayoutTasksTimer.startOneShot(0);
631             pauseScheduledEvents();
632             layout();
633         }
634     } else {
635         resumeScheduledEvents();
636         ASSERT(m_enqueueEvents);
637     }
638
639     m_nestedLayoutCount--;
640 }
641
642 void FrameView::addWidgetToUpdate(RenderPartObject* object)
643 {
644     if (!m_widgetUpdateSet)
645         m_widgetUpdateSet.set(new HashSet<RenderPartObject*>);
646
647     m_widgetUpdateSet->add(object);
648 }
649
650 void FrameView::removeWidgetToUpdate(RenderPartObject* object)
651 {
652     if (!m_widgetUpdateSet)
653         return;
654
655     m_widgetUpdateSet->remove(object);
656 }
657
658 void FrameView::setMediaType(const String& mediaType)
659 {
660     m_mediaType = mediaType;
661 }
662
663 String FrameView::mediaType() const
664 {
665     // See if we have an override type.
666     String overrideType = m_frame->loader()->client()->overrideMediaType();
667     if (!overrideType.isNull())
668         return overrideType;
669     return m_mediaType;
670 }
671
672 bool FrameView::useSlowRepaints() const
673 {
674     return m_useSlowRepaints || m_slowRepaintObjectCount > 0;
675 }
676
677 void FrameView::setUseSlowRepaints()
678 {
679     m_useSlowRepaints = true;
680     setCanBlitOnScroll(false);
681 }
682
683 void FrameView::addSlowRepaintObject()
684 {
685     if (!m_slowRepaintObjectCount)
686         setCanBlitOnScroll(false);
687     m_slowRepaintObjectCount++;
688 }
689
690 void FrameView::removeSlowRepaintObject()
691 {
692     ASSERT(m_slowRepaintObjectCount > 0);
693     m_slowRepaintObjectCount--;
694     if (!m_slowRepaintObjectCount)
695         setCanBlitOnScroll(!m_useSlowRepaints);
696 }
697
698 void FrameView::restoreScrollbar()
699 {
700     setScrollbarsSuppressed(false);
701 }
702
703 void FrameView::scrollRectIntoViewRecursively(const IntRect& r)
704 {
705     bool wasInProgrammaticScroll = m_inProgrammaticScroll;
706     m_inProgrammaticScroll = true;
707     ScrollView::scrollRectIntoViewRecursively(r);
708     m_inProgrammaticScroll = wasInProgrammaticScroll;
709 }
710
711 void FrameView::setScrollPosition(const IntPoint& scrollPoint)
712 {
713     bool wasInProgrammaticScroll = m_inProgrammaticScroll;
714     m_inProgrammaticScroll = true;
715     ScrollView::setScrollPosition(scrollPoint);
716     m_inProgrammaticScroll = wasInProgrammaticScroll;
717 }
718
719 HostWindow* FrameView::hostWindow() const
720 {
721     Page* page = frame() ? frame()->page() : 0;
722     if (!page)
723         return 0;
724     return page->chrome();
725 }
726
727 const unsigned cRepaintRectUnionThreshold = 25;
728
729 void FrameView::repaintContentRectangle(const IntRect& r, bool immediate)
730 {
731     ASSERT(!m_frame->document()->ownerElement());
732
733     double delay = adjustedDeferredRepaintDelay();
734     if ((m_deferringRepaints || m_deferredRepaintTimer.isActive() || delay) && !immediate) {
735         IntRect visibleContent = visibleContentRect();
736         visibleContent.intersect(r);
737         if (visibleContent.isEmpty())
738             return;
739         if (m_repaintCount == cRepaintRectUnionThreshold) {
740             IntRect unionedRect;
741             for (unsigned i = 0; i < cRepaintRectUnionThreshold; ++i)
742                 unionedRect.unite(m_repaintRects[i]);
743             m_repaintRects.clear();
744             m_repaintRects.append(unionedRect);
745         }
746         if (m_repaintCount < cRepaintRectUnionThreshold)
747             m_repaintRects.append(r);
748         else
749             m_repaintRects[0].unite(r);
750         m_repaintCount++;
751     
752         if (!m_deferringRepaints && !m_deferredRepaintTimer.isActive())
753              m_deferredRepaintTimer.startOneShot(delay);
754         return;
755     }
756     
757     if (!immediate && isOffscreen() && !shouldUpdateWhileOffscreen())
758         return;
759
760     ScrollView::repaintContentRectangle(r, immediate);
761 }
762
763 void FrameView::beginDeferredRepaints()
764 {
765     Page* page = m_frame->page();
766     if (page->mainFrame() != m_frame)
767         return page->mainFrame()->view()->beginDeferredRepaints();
768
769     m_deferringRepaints++;
770 }
771
772
773 void FrameView::endDeferredRepaints()
774 {
775     Page* page = m_frame->page();
776     if (page->mainFrame() != m_frame)
777         return page->mainFrame()->view()->endDeferredRepaints();
778
779     ASSERT(m_deferringRepaints > 0);
780
781     if (--m_deferringRepaints)
782         return;
783     
784     if (m_deferredRepaintTimer.isActive())
785         return;
786
787     if (double delay = adjustedDeferredRepaintDelay()) {
788         m_deferredRepaintTimer.startOneShot(delay);
789         return;
790     }
791     
792     doDeferredRepaints();
793 }
794
795 void FrameView::checkStopDelayingDeferredRepaints()
796 {
797     if (!m_deferredRepaintTimer.isActive())
798         return;
799
800     Document* document = m_frame->document();
801     if (document && (document->parsing() || document->docLoader()->requestCount()))
802         return;
803     
804     m_deferredRepaintTimer.stop();
805
806     doDeferredRepaints();
807 }
808     
809 void FrameView::doDeferredRepaints()
810 {
811     ASSERT(!m_deferringRepaints);
812     if (isOffscreen() && !shouldUpdateWhileOffscreen()) {
813         m_repaintRects.clear();
814         m_repaintCount = 0;
815         return;
816     }
817     unsigned size = m_repaintRects.size();
818     for (unsigned i = 0; i < size; i++)
819         ScrollView::repaintContentRectangle(m_repaintRects[i], false);
820     m_repaintRects.clear();
821     m_repaintCount = 0;
822     
823     updateDeferredRepaintDelay();
824 }
825
826 void FrameView::updateDeferredRepaintDelay()
827 {
828     Document* document = m_frame->document();
829     if (!document || (!document->parsing() && !document->docLoader()->requestCount())) {
830         m_deferredRepaintDelay = deferredRepaintDelay;
831         return;
832     }
833     if (m_deferredRepaintDelay < maxDeferredRepaintDelayDuringLoading) {
834         m_deferredRepaintDelay += deferredRepaintDelayIncrementDuringLoading;
835         if (m_deferredRepaintDelay > maxDeferredRepaintDelayDuringLoading)
836             m_deferredRepaintDelay = maxDeferredRepaintDelayDuringLoading;
837     }
838 }
839
840 void FrameView::resetDeferredRepaintDelay()
841 {
842     m_deferredRepaintDelay = 0;
843     if (m_deferredRepaintTimer.isActive())
844         m_deferredRepaintTimer.startOneShot(0);
845 }
846
847 double FrameView::adjustedDeferredRepaintDelay() const
848 {
849     if (!m_deferredRepaintDelay)
850         return 0;
851     double timeSinceLastPaint = currentTime() - m_lastPaintTime;
852     return max(0., m_deferredRepaintDelay - timeSinceLastPaint);
853 }
854     
855 void FrameView::deferredRepaintTimerFired(Timer<FrameView>*)
856 {
857     doDeferredRepaints();
858 }    
859
860 void FrameView::layoutTimerFired(Timer<FrameView>*)
861 {
862 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
863     if (!m_frame->document()->ownerElement())
864         printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());
865 #endif
866     layout();
867 }
868
869 void FrameView::scheduleRelayout()
870 {
871     ASSERT(!m_frame->document()->inPageCache());
872     ASSERT(m_frame->view() == this);
873
874     if (m_layoutRoot) {
875         m_layoutRoot->markContainingBlocksForLayout(false);
876         m_layoutRoot = 0;
877     }
878     if (!m_layoutSchedulingEnabled)
879         return;
880     if (!needsLayout())
881         return;
882     if (!m_frame->document()->shouldScheduleLayout())
883         return;
884
885     int delay = m_frame->document()->minimumLayoutDelay();
886     if (m_layoutTimer.isActive() && m_delayedLayout && !delay)
887         unscheduleRelayout();
888     if (m_layoutTimer.isActive())
889         return;
890
891     m_delayedLayout = delay != 0;
892
893 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
894     if (!m_frame->document()->ownerElement())
895         printf("Scheduling layout for %d\n", delay);
896 #endif
897
898     m_layoutTimer.startOneShot(delay * 0.001);
899 }
900
901 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)
902 {
903     for (RenderObject* r = descendant; r; r = r->container()) {
904         if (r == ancestor)
905             return true;
906     }
907     return false;
908 }
909
910 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)
911 {
912     ASSERT(m_frame->view() == this);
913
914     if (!m_layoutSchedulingEnabled || (m_frame->contentRenderer()
915             && m_frame->contentRenderer()->needsLayout())) {
916         if (relayoutRoot)
917             relayoutRoot->markContainingBlocksForLayout(false);
918         return;
919     }
920
921     if (layoutPending()) {
922         if (m_layoutRoot != relayoutRoot) {
923             if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {
924                 // Keep the current root
925                 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);
926             } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {
927                 // Re-root at relayoutRoot
928                 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);
929                 m_layoutRoot = relayoutRoot;
930             } else {
931                 // Just do a full relayout
932                 if (m_layoutRoot)
933                     m_layoutRoot->markContainingBlocksForLayout(false);
934                 m_layoutRoot = 0;
935                 relayoutRoot->markContainingBlocksForLayout(false);
936             }
937         }
938     } else {
939         int delay = m_frame->document()->minimumLayoutDelay();
940         m_layoutRoot = relayoutRoot;
941         m_delayedLayout = delay != 0;
942         m_layoutTimer.startOneShot(delay * 0.001);
943     }
944 }
945
946 bool FrameView::layoutPending() const
947 {
948     return m_layoutTimer.isActive();
949 }
950
951 bool FrameView::needsLayout() const
952 {
953     // This can return true in cases where the document does not have a body yet.
954     // Document::shouldScheduleLayout takes care of preventing us from scheduling
955     // layout in that case.
956     if (!m_frame)
957         return false;
958     RenderView* root = m_frame->contentRenderer();
959     Document* document = m_frame->document();
960     return layoutPending()
961         || (root && root->needsLayout())
962         || m_layoutRoot
963         || document->childNeedsStyleRecalc() // can occur when using WebKit ObjC interface
964         || m_frame->needsReapplyStyles();
965 }
966
967 void FrameView::setNeedsLayout()
968 {
969     RenderView* root = m_frame->contentRenderer();
970     if (root)
971         root->setNeedsLayout(true);
972 }
973
974 void FrameView::unscheduleRelayout()
975 {
976     if (!m_layoutTimer.isActive())
977         return;
978
979 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
980     if (!m_frame->document()->ownerElement())
981         printf("Layout timer unscheduled at %d\n", m_frame->document()->elapsedTime());
982 #endif
983     
984     m_layoutTimer.stop();
985     m_delayedLayout = false;
986 }
987
988 bool FrameView::isTransparent() const
989 {
990     return m_isTransparent;
991 }
992
993 void FrameView::setTransparent(bool isTransparent)
994 {
995     m_isTransparent = isTransparent;
996 }
997
998 Color FrameView::baseBackgroundColor() const
999 {
1000     return m_baseBackgroundColor;
1001 }
1002
1003 void FrameView::setBaseBackgroundColor(Color bc)
1004 {
1005     if (!bc.isValid())
1006         bc = Color::white;
1007     m_baseBackgroundColor = bc;
1008 }
1009
1010 void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent)
1011 {
1012     for (Frame* frame = m_frame.get(); frame; frame = frame->tree()->traverseNext(m_frame.get())) {
1013         FrameView* view = frame->view();
1014         if (!view)
1015             continue;
1016
1017         view->setTransparent(transparent);
1018         view->setBaseBackgroundColor(backgroundColor);
1019     }
1020 }
1021
1022 bool FrameView::shouldUpdateWhileOffscreen() const
1023 {
1024     return m_shouldUpdateWhileOffscreen;
1025 }
1026
1027 void FrameView::setShouldUpdateWhileOffscreen(bool shouldUpdateWhileOffscreen)
1028 {
1029     m_shouldUpdateWhileOffscreen = shouldUpdateWhileOffscreen;
1030 }
1031
1032 void FrameView::scheduleEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget)
1033 {
1034     if (!m_enqueueEvents) {
1035         ExceptionCode ec = 0;
1036         eventTarget->dispatchEvent(event, ec);
1037         return;
1038     }
1039
1040     ScheduledEvent* scheduledEvent = new ScheduledEvent;
1041     scheduledEvent->m_event = event;
1042     scheduledEvent->m_eventTarget = eventTarget;
1043     m_scheduledEvents.append(scheduledEvent);
1044 }
1045
1046 void FrameView::pauseScheduledEvents()
1047 {
1048     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1049     m_enqueueEvents++;
1050 }
1051
1052 void FrameView::resumeScheduledEvents()
1053 {
1054     m_enqueueEvents--;
1055     if (!m_enqueueEvents)
1056         dispatchScheduledEvents();
1057     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1058 }
1059
1060 bool FrameView::updateWidgets()
1061 {
1062     if (m_nestedLayoutCount > 1 || !m_widgetUpdateSet || m_widgetUpdateSet->isEmpty())
1063         return true;
1064     
1065     Vector<RenderPartObject*> objectVector;
1066     copyToVector(*m_widgetUpdateSet, objectVector);
1067     size_t size = objectVector.size();
1068     for (size_t i = 0; i < size; ++i) {
1069         RenderPartObject* object = objectVector[i];
1070         object->updateWidget(false);
1071         
1072         // updateWidget() can destroy the RenderPartObject, so we need to make sure it's
1073         // alive by checking if it's still in m_widgetUpdateSet.
1074         if (m_widgetUpdateSet->contains(object)) {
1075             object->updateWidgetPosition();
1076             m_widgetUpdateSet->remove(object);
1077         }
1078     }
1079     
1080     return m_widgetUpdateSet->isEmpty();
1081 }
1082     
1083 void FrameView::performPostLayoutTasks()
1084 {
1085     if (m_firstLayoutCallbackPending) {
1086         m_firstLayoutCallbackPending = false;
1087         m_frame->loader()->didFirstLayout();
1088     }
1089
1090     if (m_isVisuallyNonEmpty && m_firstVisuallyNonEmptyLayoutCallbackPending) {
1091         m_firstVisuallyNonEmptyLayoutCallbackPending = false;
1092         m_frame->loader()->didFirstVisuallyNonEmptyLayout();
1093     }
1094
1095     RenderView* root = m_frame->contentRenderer();
1096
1097     root->updateWidgetPositions();
1098     
1099     for (unsigned i = 0; i < maxUpdateWidgetsIterations; i++) {
1100         if (updateWidgets())
1101             break;
1102     }
1103     
1104     resumeScheduledEvents();
1105
1106     if (!root->printing()) {
1107         IntSize currentSize = IntSize(width(), height());
1108         float currentZoomFactor = root->style()->zoom();
1109         bool resized = !m_firstLayout && (currentSize != m_lastLayoutSize || currentZoomFactor != m_lastZoomFactor);
1110         m_lastLayoutSize = currentSize;
1111         m_lastZoomFactor = currentZoomFactor;
1112         if (resized)
1113             m_frame->eventHandler()->sendResizeEvent();
1114     }
1115 }
1116
1117 void FrameView::postLayoutTimerFired(Timer<FrameView>*)
1118 {
1119     performPostLayoutTasks();
1120 }
1121
1122 void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1123 {
1124     if (!m_viewportRenderer)
1125         return;
1126     
1127     if (m_overflowStatusDirty) {
1128         m_horizontalOverflow = horizontalOverflow;
1129         m_verticalOverflow = verticalOverflow;
1130         m_overflowStatusDirty = false;
1131         return;
1132     }
1133     
1134     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1135     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1136     
1137     if (horizontalOverflowChanged || verticalOverflowChanged) {
1138         m_horizontalOverflow = horizontalOverflow;
1139         m_verticalOverflow = verticalOverflow;
1140         
1141         scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow,
1142             verticalOverflowChanged, verticalOverflow),
1143             m_viewportRenderer->node());
1144     }
1145     
1146 }
1147
1148 void FrameView::dispatchScheduledEvents()
1149 {
1150     if (m_scheduledEvents.isEmpty())
1151         return;
1152
1153     Vector<ScheduledEvent*> scheduledEventsCopy = m_scheduledEvents;
1154     m_scheduledEvents.clear();
1155     
1156     Vector<ScheduledEvent*>::iterator end = scheduledEventsCopy.end();
1157     for (Vector<ScheduledEvent*>::iterator it = scheduledEventsCopy.begin(); it != end; ++it) {
1158         ScheduledEvent* scheduledEvent = *it;
1159         
1160         ExceptionCode ec = 0;
1161         
1162         // Only dispatch events to nodes that are in the document
1163         if (scheduledEvent->m_eventTarget->inDocument())
1164             scheduledEvent->m_eventTarget->dispatchEvent(scheduledEvent->m_event, ec);
1165         
1166         delete scheduledEvent;
1167     }
1168 }
1169
1170 IntRect FrameView::windowClipRect(bool clipToContents) const
1171 {
1172     ASSERT(m_frame->view() == this);
1173
1174     // Set our clip rect to be our contents.
1175     IntRect clipRect = contentsToWindow(visibleContentRect(!clipToContents));
1176     if (!m_frame || !m_frame->document()->ownerElement())
1177         return clipRect;
1178
1179     // Take our owner element and get the clip rect from the enclosing layer.
1180     Element* elt = m_frame->document()->ownerElement();
1181     RenderLayer* layer = elt->renderer()->enclosingLayer();
1182     // FIXME: layer should never be null, but sometimes seems to be anyway.
1183     if (!layer)
1184         return clipRect;
1185     FrameView* parentView = elt->document()->view();
1186     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
1187     return clipRect;
1188 }
1189
1190 IntRect FrameView::windowClipRectForLayer(const RenderLayer* layer, bool clipToLayerContents) const
1191 {
1192     // If we have no layer, just return our window clip rect.
1193     if (!layer)
1194         return windowClipRect();
1195
1196     // Apply the clip from the layer.
1197     IntRect clipRect;
1198     if (clipToLayerContents)
1199         clipRect = layer->childrenClipRect();
1200     else
1201         clipRect = layer->selfClipRect();
1202     clipRect = contentsToWindow(clipRect); 
1203     return intersection(clipRect, windowClipRect());
1204 }
1205
1206 bool FrameView::isActive() const
1207 {
1208     Page* page = frame()->page();
1209     return page && page->focusController()->isActive();
1210 }
1211
1212 void FrameView::valueChanged(Scrollbar* bar)
1213 {
1214     // Figure out if we really moved.
1215     IntSize offset = scrollOffset();
1216     ScrollView::valueChanged(bar);
1217     if (offset != scrollOffset())
1218         frame()->eventHandler()->sendScrollEvent();
1219 }
1220
1221 void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
1222 {
1223     // Add in our offset within the FrameView.
1224     IntRect dirtyRect = rect;
1225     dirtyRect.move(scrollbar->x(), scrollbar->y());
1226     invalidateRect(dirtyRect);
1227 }
1228
1229 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
1230 {
1231     tickmarks = frame()->document()->renderedRectsForMarkers(DocumentMarker::TextMatch);
1232 }
1233
1234 IntRect FrameView::windowResizerRect() const
1235 {
1236     Page* page = frame() ? frame()->page() : 0;
1237     if (!page)
1238         return IntRect();
1239     return page->chrome()->windowResizerRect();
1240 }
1241
1242 #if ENABLE(DASHBOARD_SUPPORT)
1243 void FrameView::updateDashboardRegions()
1244 {
1245     Document* document = m_frame->document();
1246     if (!document->hasDashboardRegions())
1247         return;
1248     Vector<DashboardRegionValue> newRegions;
1249     document->renderBox()->collectDashboardRegions(newRegions);
1250     if (newRegions == document->dashboardRegions())
1251         return;
1252     document->setDashboardRegions(newRegions);
1253     Page* page = m_frame->page();
1254     if (!page)
1255         return;
1256     page->chrome()->client()->dashboardRegionsChanged();
1257 }
1258 #endif
1259
1260 void FrameView::updateControlTints()
1261 {
1262     // This is called when control tints are changed from aqua/graphite to clear and vice versa.
1263     // We do a "fake" paint, and when the theme gets a paint call, it can then do an invalidate.
1264     // This is only done if the theme supports control tinting. It's up to the theme and platform
1265     // to define when controls get the tint and to call this function when that changes.
1266     
1267     // Optimize the common case where we bring a window to the front while it's still empty.
1268     if (!m_frame || m_frame->loader()->url().isEmpty()) 
1269         return;
1270     
1271     if (theme()->supportsControlTints() && m_frame->contentRenderer()) {
1272         if (needsLayout())
1273             layout();
1274         PlatformGraphicsContext* const noContext = 0;
1275         GraphicsContext context(noContext);
1276         context.setUpdatingControlTints(true);
1277         if (platformWidget())
1278             paintContents(&context, visibleContentRect());
1279         else
1280             paint(&context, frameRect());
1281     }
1282 }
1283
1284 bool FrameView::wasScrolledByUser() const
1285 {
1286     return m_wasScrolledByUser;
1287 }
1288
1289 void FrameView::setWasScrolledByUser(bool wasScrolledByUser)
1290 {
1291     if (m_inProgrammaticScroll)
1292         return;
1293     m_wasScrolledByUser = wasScrolledByUser;
1294 }
1295
1296 void FrameView::paintContents(GraphicsContext* p, const IntRect& rect)
1297 {
1298     if (!frame())
1299         return;
1300     
1301     Document* document = frame()->document();
1302
1303 #ifndef NDEBUG
1304     bool fillWithRed;
1305     if (document->printing())
1306         fillWithRed = false; // Printing, don't fill with red (can't remember why).
1307     else if (document->ownerElement())
1308         fillWithRed = false; // Subframe, don't fill with red.
1309     else if (isTransparent())
1310         fillWithRed = false; // Transparent, don't fill with red.
1311     else if (m_paintRestriction == PaintRestrictionSelectionOnly || m_paintRestriction == PaintRestrictionSelectionOnlyBlackText)
1312         fillWithRed = false; // Selections are transparent, don't fill with red.
1313     else if (m_nodeToDraw)
1314         fillWithRed = false; // Element images are transparent, don't fill with red.
1315     else
1316         fillWithRed = true;
1317     
1318     if (fillWithRed)
1319         p->fillRect(rect, Color(0xFF, 0, 0));
1320 #endif
1321
1322     bool isTopLevelPainter = !sCurrentPaintTimeStamp;
1323     if (isTopLevelPainter)
1324         sCurrentPaintTimeStamp = currentTime();
1325     
1326     RenderView* contentRenderer = frame()->contentRenderer();
1327     if (!contentRenderer) {
1328         LOG_ERROR("called Frame::paint with nil renderer");
1329         return;
1330     }
1331
1332     ASSERT(!needsLayout());
1333     if (needsLayout())
1334         return;
1335
1336     ASSERT(!m_isPainting);
1337         
1338     m_isPainting = true;
1339         
1340     // m_nodeToDraw is used to draw only one element (and its descendants)
1341     RenderObject* eltRenderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0;
1342     if (m_paintRestriction == PaintRestrictionNone)
1343         document->invalidateRenderedRectsForMarkersInRect(rect);
1344     contentRenderer->layer()->paint(p, rect, m_paintRestriction, eltRenderer);
1345     
1346     m_isPainting = false;
1347     m_lastPaintTime = currentTime();
1348
1349 #if ENABLE(DASHBOARD_SUPPORT)
1350     // Regions may have changed as a result of the visibility/z-index of element changing.
1351     if (document->dashboardRegionsDirty())
1352         updateDashboardRegions();
1353 #endif
1354
1355     if (isTopLevelPainter)
1356         sCurrentPaintTimeStamp = 0;
1357 }
1358
1359 void FrameView::setPaintRestriction(PaintRestriction pr)
1360 {
1361     m_paintRestriction = pr;
1362 }
1363     
1364 bool FrameView::isPainting() const
1365 {
1366     return m_isPainting;
1367 }
1368
1369 void FrameView::setNodeToDraw(Node* node)
1370 {
1371     m_nodeToDraw = node;
1372 }
1373
1374 void FrameView::layoutIfNeededRecursive()
1375 {
1376     // We have to crawl our entire tree looking for any FrameViews that need
1377     // layout and make sure they are up to date.
1378     // Mac actually tests for intersection with the dirty region and tries not to
1379     // update layout for frames that are outside the dirty region.  Not only does this seem
1380     // pointless (since those frames will have set a zero timer to layout anyway), but
1381     // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
1382     // region but then become included later by the second frame adding rects to the dirty region
1383     // when it lays out.
1384
1385     if (needsLayout())
1386         layout();
1387
1388     const HashSet<Widget*>* viewChildren = children();
1389     HashSet<Widget*>::const_iterator end = viewChildren->end();
1390     for (HashSet<Widget*>::const_iterator current = viewChildren->begin(); current != end; ++current)
1391         if ((*current)->isFrameView())
1392             static_cast<FrameView*>(*current)->layoutIfNeededRecursive();
1393
1394     // layoutIfNeededRecursive is called when we need to make sure layout is up-to-date before
1395     // painting, so we need to flush out any deferred repaints too.
1396     if (m_deferredRepaintTimer.isActive()) {
1397         m_deferredRepaintTimer.stop();
1398         doDeferredRepaints();
1399     }
1400 }
1401
1402 void FrameView::forceLayout(bool allowSubtree)
1403 {
1404     layout(allowSubtree);
1405     // We cannot unschedule a pending relayout, since the force can be called with
1406     // a tiny rectangle from a drawRect update.  By unscheduling we in effect
1407     // "validate" and stop the necessary full repaint from occurring.  Basically any basic
1408     // append/remove DHTML is broken by this call.  For now, I have removed the optimization
1409     // until we have a better invalidation stategy. -dwh
1410     //unscheduleRelayout();
1411 }
1412
1413 void FrameView::forceLayoutWithPageWidthRange(float minPageWidth, float maxPageWidth, bool _adjustViewSize)
1414 {
1415     // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
1416     // the state of things before and after the layout
1417     RenderView *root = toRenderView(m_frame->document()->renderer());
1418     if (root) {
1419         // This magic is basically copied from khtmlview::print
1420         int pageW = (int)ceilf(minPageWidth);
1421         root->setWidth(pageW);
1422         root->setNeedsLayoutAndPrefWidthsRecalc();
1423         forceLayout();
1424
1425         // If we don't fit in the minimum page width, we'll lay out again. If we don't fit in the
1426         // maximum page width, we will lay out to the maximum page width and clip extra content.
1427         // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
1428         // implementation should not do this!
1429         int rightmostPos = root->rightmostPosition();
1430         if (rightmostPos > minPageWidth) {
1431             pageW = std::min(rightmostPos, (int)ceilf(maxPageWidth));
1432             root->setWidth(pageW);
1433             root->setNeedsLayoutAndPrefWidthsRecalc();
1434             forceLayout();
1435         }
1436     }
1437
1438     if (_adjustViewSize)
1439         adjustViewSize();
1440 }
1441
1442 void FrameView::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float /*bottomLimit*/)
1443 {
1444     RenderView* root = m_frame->contentRenderer();
1445     if (root) {
1446         // Use a context with painting disabled.
1447         GraphicsContext context((PlatformGraphicsContext*)0);
1448         root->setTruncatedAt((int)floorf(oldBottom));
1449         IntRect dirtyRect(0, (int)floorf(oldTop), root->overflowWidth(), (int)ceilf(oldBottom - oldTop));
1450         root->layer()->paint(&context, dirtyRect);
1451         *newBottom = root->bestTruncatedAt();
1452         if (*newBottom == 0)
1453             *newBottom = oldBottom;
1454     } else
1455         *newBottom = oldBottom;
1456 }
1457
1458 } // namespace WebCore