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