1fefac4f0192ea3eb05415cb3434af5b09f6a741
[WebKit-https.git] / Source / WebCore / rendering / RenderView.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "RenderView.h"
23
24 #include "Document.h"
25 #include "Element.h"
26 #include "FloatQuad.h"
27 #include "Frame.h"
28 #include "FrameView.h"
29 #include "GraphicsContext.h"
30 #include "HTMLFrameOwnerElement.h"
31 #include "HitTestResult.h"
32 #include "Page.h"
33 #include "RenderFlowThread.h"
34 #include "RenderLayer.h"
35 #include "RenderSelectionInfo.h"
36 #include "RenderWidget.h"
37 #include "RenderWidgetProtector.h"
38 #include "TransformState.h"
39
40 #if USE(ACCELERATED_COMPOSITING)
41 #include "RenderLayerCompositor.h"
42 #endif
43
44 namespace WebCore {
45
46 RenderView::RenderView(Node* node, FrameView* view)
47     : RenderBlock(node)
48     , m_frameView(view)
49     , m_selectionStart(0)
50     , m_selectionEnd(0)
51     , m_selectionStartPos(-1)
52     , m_selectionEndPos(-1)
53     , m_maximalOutlineSize(0)
54     , m_pageLogicalHeight(0)
55     , m_pageLogicalHeightChanged(false)
56     , m_isRenderFlowThreadOrderDirty(false)
57     , m_layoutState(0)
58     , m_layoutStateDisableCount(0)
59     , m_currentRenderFlowThread(0)
60 {
61     // Clear our anonymous bit, set because RenderObject assumes
62     // any renderer with document as the node is anonymous.
63     setIsAnonymous(false);
64
65     // init RenderObject attributes
66     setInline(false);
67     
68     m_minPreferredLogicalWidth = 0;
69     m_maxPreferredLogicalWidth = 0;
70
71     setPreferredLogicalWidthsDirty(true, false);
72     
73     setPositioned(true); // to 0,0 :)
74 }
75
76 RenderView::~RenderView()
77 {
78 }
79
80 void RenderView::computeLogicalHeight()
81 {
82     if (!printing() && m_frameView)
83         setLogicalHeight(viewLogicalHeight());
84 }
85
86 void RenderView::computeLogicalWidth()
87 {
88     if (!printing() && m_frameView)
89         setLogicalWidth(viewLogicalWidth());
90 }
91
92 void RenderView::computePreferredLogicalWidths()
93 {
94     ASSERT(preferredLogicalWidthsDirty());
95
96     RenderBlock::computePreferredLogicalWidths();
97
98     m_maxPreferredLogicalWidth = m_minPreferredLogicalWidth;
99 }
100
101 bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const
102 {
103     return child->isBox();
104 }
105
106 void RenderView::layout()
107 {
108     if (!document()->paginated())
109         setPageLogicalHeight(0);
110
111     if (printing())
112         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth();
113
114     // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
115     bool relayoutChildren = !printing() && (!m_frameView || width() != viewWidth() || height() != viewHeight());
116     if (relayoutChildren) {
117         setChildNeedsLayout(true, false);
118         for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
119             if (child->style()->logicalHeight().isPercent() || child->style()->logicalMinHeight().isPercent() || child->style()->logicalMaxHeight().isPercent())
120                 child->setChildNeedsLayout(true, false);
121         }
122     }
123
124     ASSERT(!m_layoutState);
125     LayoutState state;
126     // FIXME: May be better to push a clip and avoid issuing offscreen repaints.
127     state.m_clipped = false;
128     state.m_pageLogicalHeight = m_pageLogicalHeight;
129     state.m_pageLogicalHeightChanged = m_pageLogicalHeightChanged;
130     state.m_isPaginated = state.m_pageLogicalHeight;
131     m_pageLogicalHeightChanged = false;
132     m_layoutState = &state;
133
134     if (needsLayout()) {
135         RenderBlock::layout();
136         if (hasRenderFlowThreads())
137             layoutRenderFlowThreads();
138     }
139
140     ASSERT(layoutDelta() == LayoutSize());
141     ASSERT(m_layoutStateDisableCount == 0);
142     ASSERT(m_layoutState == &state);
143     m_layoutState = 0;
144     setNeedsLayout(false);
145 }
146
147 void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, bool* wasFixed) const
148 {
149     // If a container was specified, and was not 0 or the RenderView,
150     // then we should have found it by now.
151     ASSERT_ARG(repaintContainer, !repaintContainer || repaintContainer == this);
152     ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == fixed);
153
154     if (!repaintContainer && useTransforms && shouldUseTransformFromContainer(0)) {
155         TransformationMatrix t;
156         getTransformFromContainer(0, LayoutSize(), t);
157         transformState.applyTransform(t);
158     }
159     
160     if (fixed && m_frameView)
161         transformState.move(m_frameView->scrollOffsetForFixedPosition());
162 }
163
164 void RenderView::mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState& transformState) const
165 {
166     if (fixed && m_frameView)
167         transformState.move(m_frameView->scrollOffsetForFixedPosition());
168
169     if (useTransforms && shouldUseTransformFromContainer(0)) {
170         TransformationMatrix t;
171         getTransformFromContainer(0, LayoutSize(), t);
172         transformState.applyTransform(t);
173     }
174 }
175
176 void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
177 {
178     // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
179     ASSERT(!needsLayout());
180     paintObject(paintInfo, paintOffset);
181 }
182
183 static inline bool isComposited(RenderObject* object)
184 {
185     return object->hasLayer() && toRenderBoxModelObject(object)->layer()->isComposited();
186 }
187
188 static inline bool rendererObscuresBackground(RenderObject* object)
189 {
190     return object && object->style()->visibility() == VISIBLE
191         && object->style()->opacity() == 1
192         && !object->style()->hasTransform()
193         && !isComposited(object);
194 }
195     
196 void RenderView::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint&)
197 {
198     // Check to see if we are enclosed by a layer that requires complex painting rules.  If so, we cannot blit
199     // when scrolling, and we need to use slow repaints.  Examples of layers that require this are transparent layers,
200     // layers with reflections, or transformed layers.
201     // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being inside
202     // a transform, transparency layer, etc.
203     Element* elt;
204     for (elt = document()->ownerElement(); view() && elt && elt->renderer(); elt = elt->document()->ownerElement()) {
205         RenderLayer* layer = elt->renderer()->enclosingLayer();
206         if (layer->cannotBlitToWindow()) {
207             frameView()->setCannotBlitToWindow();
208             break;
209         }
210
211 #if USE(ACCELERATED_COMPOSITING)
212         if (RenderLayer* compositingLayer = layer->enclosingCompositingLayer()) {
213             if (!compositingLayer->backing()->paintingGoesToWindow()) {
214                 frameView()->setCannotBlitToWindow();
215                 break;
216             }
217         }
218 #endif
219     }
220
221     if (document()->ownerElement() || !view())
222         return;
223
224     bool rootFillsViewport = false;
225     Node* documentElement = document()->documentElement();
226     if (RenderObject* rootRenderer = documentElement ? documentElement->renderer() : 0) {
227         // The document element's renderer is currently forced to be a block, but may not always be.
228         RenderBox* rootBox = rootRenderer->isBox() ? toRenderBox(rootRenderer) : 0;
229         rootFillsViewport = rootBox && !rootBox->x() && !rootBox->y() && rootBox->width() >= width() && rootBox->height() >= height();
230     }
231     
232     Page* page = document()->page();
233     float pageScaleFactor = page ? page->pageScaleFactor() : 1;
234
235     // If painting will entirely fill the view, no need to fill the background.
236     if (rootFillsViewport && rendererObscuresBackground(firstChild()) && pageScaleFactor >= 1)
237         return;
238
239     // This code typically only executes if the root element's visibility has been set to hidden,
240     // if there is a transform on the <html>, or if there is a page scale factor less than 1.
241     // Only fill with the base background color (typically white) if we're the root document, 
242     // since iframes/frames with no background in the child document should show the parent's background.
243     if (frameView()->isTransparent()) // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being transparent.
244         frameView()->setCannotBlitToWindow(); // The parent must show behind the child.
245     else {
246         Color baseColor = frameView()->baseBackgroundColor();
247         if (baseColor.alpha() > 0) {
248             CompositeOperator previousOperator = paintInfo.context->compositeOperation();
249             paintInfo.context->setCompositeOperation(CompositeCopy);
250             paintInfo.context->fillRect(paintInfo.rect, baseColor, style()->colorSpace());
251             paintInfo.context->setCompositeOperation(previousOperator);
252         } else
253             paintInfo.context->clearRect(paintInfo.rect);
254     }
255 }
256
257 bool RenderView::shouldRepaint(const IntRect& r) const
258 {
259     if (printing() || r.width() == 0 || r.height() == 0)
260         return false;
261
262     if (!m_frameView)
263         return false;
264     
265     return true;
266 }
267
268 void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
269 {
270     if (!shouldRepaint(ur))
271         return;
272
273     // We always just invalidate the root view, since we could be an iframe that is clipped out
274     // or even invisible.
275     Element* elt = document()->ownerElement();
276     if (!elt)
277         m_frameView->repaintContentRectangle(ur, immediate);
278     else if (RenderBox* obj = elt->renderBox()) {
279         IntRect vr = viewRect();
280         IntRect r = intersection(ur, vr);
281         
282         // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
283         // rectangle.
284         r.moveBy(-vr.location());
285         
286         // FIXME: Hardcoded offsets here are not good.
287         r.move(obj->borderLeft() + obj->paddingLeft(),
288                obj->borderTop() + obj->paddingTop());
289         obj->repaintRectangle(r, immediate);
290     }
291 }
292
293 void RenderView::repaintRectangleInViewAndCompositedLayers(const IntRect& ur, bool immediate)
294 {
295     if (!shouldRepaint(ur))
296         return;
297
298     repaintViewRectangle(ur, immediate);
299     
300 #if USE(ACCELERATED_COMPOSITING)
301     if (compositor()->inCompositingMode())
302         compositor()->repaintCompositedLayersAbsoluteRect(ur);
303 #endif
304 }
305
306 void RenderView::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed) const
307 {
308     // If a container was specified, and was not 0 or the RenderView,
309     // then we should have found it by now.
310     ASSERT_ARG(repaintContainer, !repaintContainer || repaintContainer == this);
311
312     if (printing())
313         return;
314
315     if (style()->isFlippedBlocksWritingMode()) {
316         // We have to flip by hand since the view's logical height has not been determined.  We
317         // can use the viewport width and height.
318         if (style()->isHorizontalWritingMode())
319             rect.setY(viewHeight() - rect.maxY());
320         else
321             rect.setX(viewWidth() - rect.maxX());
322     }
323
324     if (fixed && m_frameView)
325         rect.move(m_frameView->scrollXForFixedPosition(), m_frameView->scrollYForFixedPosition());
326         
327     // Apply our transform if we have one (because of full page zooming).
328     if (!repaintContainer && m_layer && m_layer->transform())
329         rect = m_layer->transform()->mapRect(rect);
330 }
331
332 void RenderView::absoluteRects(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
333 {
334     rects.append(LayoutRect(accumulatedOffset, m_layer->size()));
335 }
336
337 void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed)
338 {
339     if (wasFixed)
340         *wasFixed = false;
341     quads.append(FloatRect(FloatPoint(), m_layer->size()));
342 }
343
344 static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
345 {
346     if (!object)
347         return 0;
348
349     RenderObject* child = object->childAt(offset);
350     return child ? child : object->nextInPreOrderAfterChildren();
351 }
352
353 IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
354 {
355     document()->updateStyleIfNeeded();
356
357     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectionMap;
358     SelectionMap selectedObjects;
359
360     RenderObject* os = m_selectionStart;
361     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
362     while (os && os != stop) {
363         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
364             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
365             selectedObjects.set(os, new RenderSelectionInfo(os, clipToVisibleContent));
366             RenderBlock* cb = os->containingBlock();
367             while (cb && !cb->isRenderView()) {
368                 RenderSelectionInfo* blockInfo = selectedObjects.get(cb);
369                 if (blockInfo)
370                     break;
371                 selectedObjects.set(cb, new RenderSelectionInfo(cb, clipToVisibleContent));
372                 cb = cb->containingBlock();
373             }
374         }
375
376         os = os->nextInPreOrder();
377     }
378
379     // Now create a single bounding box rect that encloses the whole selection.
380     IntRect selRect;
381     SelectionMap::iterator end = selectedObjects.end();
382     for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
383         RenderSelectionInfo* info = i->second;
384         // RenderSelectionInfo::rect() is in the coordinates of the repaintContainer, so map to page coordinates.
385         IntRect currRect = info->rect();
386         if (RenderBoxModelObject* repaintContainer = info->repaintContainer()) {
387             FloatQuad absQuad = repaintContainer->localToAbsoluteQuad(FloatRect(currRect));
388             currRect = absQuad.enclosingBoundingBox(); 
389         }
390         selRect.unite(currRect);
391         delete info;
392     }
393     return selRect;
394 }
395
396 #if USE(ACCELERATED_COMPOSITING)
397 // Compositing layer dimensions take outline size into account, so we have to recompute layer
398 // bounds when it changes.
399 // FIXME: This is ugly; it would be nice to have a better way to do this.
400 void RenderView::setMaximalOutlineSize(int o)
401 {
402     if (o != m_maximalOutlineSize) {
403         m_maximalOutlineSize = o;
404
405         // maximalOutlineSize affects compositing layer dimensions.
406         compositor()->setCompositingLayersNeedRebuild();    // FIXME: this really just needs to be a geometry update.
407     }
408 }
409 #endif
410
411 void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionRepaintMode blockRepaintMode)
412 {
413     // Make sure both our start and end objects are defined.
414     // Check www.msnbc.com and try clicking around to find the case where this happened.
415     if ((start && !end) || (end && !start))
416         return;
417
418     // Just return if the selection hasn't changed.
419     if (m_selectionStart == start && m_selectionStartPos == startPos &&
420         m_selectionEnd == end && m_selectionEndPos == endPos)
421         return;
422
423     // Record the old selected objects.  These will be used later
424     // when we compare against the new selected objects.
425     int oldStartPos = m_selectionStartPos;
426     int oldEndPos = m_selectionEndPos;
427
428     // Objects each have a single selection rect to examine.
429     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectedObjectMap;
430     SelectedObjectMap oldSelectedObjects;
431     SelectedObjectMap newSelectedObjects;
432
433     // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
434     // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
435     // the union of those rects might remain the same even when changes have occurred.
436     typedef HashMap<RenderBlock*, RenderBlockSelectionInfo*> SelectedBlockMap;
437     SelectedBlockMap oldSelectedBlocks;
438     SelectedBlockMap newSelectedBlocks;
439
440     RenderObject* os = m_selectionStart;
441     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
442     while (os && os != stop) {
443         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
444             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
445             oldSelectedObjects.set(os, new RenderSelectionInfo(os, true));
446             if (blockRepaintMode == RepaintNewXOROld) {
447                 RenderBlock* cb = os->containingBlock();
448                 while (cb && !cb->isRenderView()) {
449                     RenderBlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
450                     if (blockInfo)
451                         break;
452                     oldSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
453                     cb = cb->containingBlock();
454                 }
455             }
456         }
457
458         os = os->nextInPreOrder();
459     }
460
461     // Now clear the selection.
462     SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
463     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
464         i->first->setSelectionState(SelectionNone);
465
466     // set selection start and end
467     m_selectionStart = start;
468     m_selectionStartPos = startPos;
469     m_selectionEnd = end;
470     m_selectionEndPos = endPos;
471
472     // Update the selection status of all objects between m_selectionStart and m_selectionEnd
473     if (start && start == end)
474         start->setSelectionState(SelectionBoth);
475     else {
476         if (start)
477             start->setSelectionState(SelectionStart);
478         if (end)
479             end->setSelectionState(SelectionEnd);
480     }
481
482     RenderObject* o = start;
483     stop = rendererAfterPosition(end, endPos);
484
485     while (o && o != stop) {
486         if (o != start && o != end && o->canBeSelectionLeaf())
487             o->setSelectionState(SelectionInside);
488         o = o->nextInPreOrder();
489     }
490
491     m_layer->clearBlockSelectionGapsBounds();
492
493     // Now that the selection state has been updated for the new objects, walk them again and
494     // put them in the new objects list.
495     o = start;
496     while (o && o != stop) {
497         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
498             newSelectedObjects.set(o, new RenderSelectionInfo(o, true));
499             RenderBlock* cb = o->containingBlock();
500             while (cb && !cb->isRenderView()) {
501                 RenderBlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
502                 if (blockInfo)
503                     break;
504                 newSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
505                 cb = cb->containingBlock();
506             }
507         }
508
509         o = o->nextInPreOrder();
510     }
511
512     if (!m_frameView) {
513         // We built the maps, but we aren't going to use them.
514         // We need to delete the values, otherwise they'll all leak!
515         deleteAllValues(oldSelectedObjects);
516         deleteAllValues(newSelectedObjects);
517         deleteAllValues(oldSelectedBlocks);
518         deleteAllValues(newSelectedBlocks);
519         return;
520     }
521
522     m_frameView->beginDeferredRepaints();
523
524     // Have any of the old selected objects changed compared to the new selection?
525     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
526         RenderObject* obj = i->first;
527         RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
528         RenderSelectionInfo* oldInfo = i->second;
529         if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
530             (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
531             (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
532             oldInfo->repaint();
533             if (newInfo) {
534                 newInfo->repaint();
535                 newSelectedObjects.remove(obj);
536                 delete newInfo;
537             }
538         }
539         delete oldInfo;
540     }
541
542     // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
543     SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
544     for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
545         RenderSelectionInfo* newInfo = i->second;
546         newInfo->repaint();
547         delete newInfo;
548     }
549
550     // Have any of the old blocks changed?
551     SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
552     for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
553         RenderBlock* block = i->first;
554         RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
555         RenderBlockSelectionInfo* oldInfo = i->second;
556         if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
557             oldInfo->repaint();
558             if (newInfo) {
559                 newInfo->repaint();
560                 newSelectedBlocks.remove(block);
561                 delete newInfo;
562             }
563         }
564         delete oldInfo;
565     }
566
567     // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
568     SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
569     for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
570         RenderBlockSelectionInfo* newInfo = i->second;
571         newInfo->repaint();
572         delete newInfo;
573     }
574
575     m_frameView->endDeferredRepaints();
576 }
577
578 void RenderView::clearSelection()
579 {
580     m_layer->repaintBlockSelectionGaps();
581     setSelection(0, -1, 0, -1, RepaintNewMinusOld);
582 }
583
584 void RenderView::selectionStartEnd(int& startPos, int& endPos) const
585 {
586     startPos = m_selectionStartPos;
587     endPos = m_selectionEndPos;
588 }
589
590 bool RenderView::printing() const
591 {
592     return document()->printing();
593 }
594
595 size_t RenderView::getRetainedWidgets(Vector<RenderWidget*>& renderWidgets)
596 {
597     size_t size = m_widgets.size();
598
599     renderWidgets.reserveCapacity(size);
600
601     RenderWidgetSet::const_iterator end = m_widgets.end();
602     for (RenderWidgetSet::const_iterator it = m_widgets.begin(); it != end; ++it) {
603         renderWidgets.uncheckedAppend(*it);
604         (*it)->ref();
605     }
606     
607     return size;
608 }
609
610 void RenderView::releaseWidgets(Vector<RenderWidget*>& renderWidgets)
611 {
612     size_t size = renderWidgets.size();
613
614     for (size_t i = 0; i < size; ++i)
615         renderWidgets[i]->deref(renderArena());
616 }
617
618 void RenderView::updateWidgetPositions()
619 {
620     // updateWidgetPosition() can possibly cause layout to be re-entered (via plug-ins running
621     // scripts in response to NPP_SetWindow, for example), so we need to keep the Widgets
622     // alive during enumeration.    
623
624     Vector<RenderWidget*> renderWidgets;
625     size_t size = getRetainedWidgets(renderWidgets);
626     
627     for (size_t i = 0; i < size; ++i)
628         renderWidgets[i]->updateWidgetPosition();
629
630     for (size_t i = 0; i < size; ++i)
631         renderWidgets[i]->widgetPositionsUpdated();
632
633     releaseWidgets(renderWidgets);
634 }
635
636 void RenderView::addWidget(RenderWidget* o)
637 {
638     m_widgets.add(o);
639 }
640
641 void RenderView::removeWidget(RenderWidget* o)
642 {
643     m_widgets.remove(o);
644 }
645
646 void RenderView::notifyWidgets(WidgetNotification notification)
647 {
648     Vector<RenderWidget*> renderWidgets;
649     size_t size = getRetainedWidgets(renderWidgets);
650
651     for (size_t i = 0; i < size; ++i)
652         renderWidgets[i]->notifyWidget(notification);
653
654     releaseWidgets(renderWidgets);
655 }
656
657 IntRect RenderView::viewRect() const
658 {
659     if (printing())
660         return IntRect(0, 0, width(), height());
661     if (m_frameView)
662         return m_frameView->visibleContentRect();
663     return IntRect();
664 }
665
666
667 IntRect RenderView::unscaledDocumentRect() const
668 {
669     IntRect overflowRect(layoutOverflowRect());
670     flipForWritingMode(overflowRect);
671     return overflowRect;
672 }
673
674 IntRect RenderView::documentRect() const
675 {
676     IntRect overflowRect(unscaledDocumentRect());
677     if (hasTransform())
678         overflowRect = layer()->currentTransform().mapRect(overflowRect);
679     return overflowRect;
680 }
681
682 int RenderView::viewHeight() const
683 {
684     int height = 0;
685     if (!printing() && m_frameView) {
686         height = m_frameView->layoutHeight();
687         height = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(height)) : height;
688     }
689     return height;
690 }
691
692 int RenderView::viewWidth() const
693 {
694     int width = 0;
695     if (!printing() && m_frameView) {
696         width = m_frameView->layoutWidth();
697         width = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(width)) : width;
698     }
699     return width;
700 }
701
702 float RenderView::zoomFactor() const
703 {
704     Frame* frame = m_frameView->frame();
705     return frame ? frame->pageZoomFactor() : 1;
706 }
707
708 void RenderView::pushLayoutState(RenderObject* root)
709 {
710     ASSERT(m_layoutStateDisableCount == 0);
711     ASSERT(m_layoutState == 0);
712
713     m_layoutState = new (renderArena()) LayoutState(root);
714 }
715
716 void RenderView::pushLayoutState(RenderFlowThread* flowThread, bool regionsChanged)
717 {
718     m_layoutState = new (renderArena()) LayoutState(m_layoutState, flowThread, regionsChanged);
719 }
720
721 bool RenderView::shouldDisableLayoutStateForSubtree(RenderObject* renderer) const
722 {
723     RenderObject* o = renderer;
724     while (o) {
725         if (o->hasColumns() || o->hasTransform() || o->hasReflection())
726             return true;
727         o = o->container();
728     }
729     return false;
730 }
731
732 void RenderView::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
733 {
734     if (result.innerNode())
735         return;
736
737     Node* node = document()->documentElement();
738     if (node) {
739         result.setInnerNode(node);
740         if (!result.innerNonSharedNode())
741             result.setInnerNonSharedNode(node);
742         result.setLocalPoint(point);
743     }
744 }
745
746 // FIXME: This function is obsolete and only used by embedded WebViews inside AppKit NSViews.
747 // Do not add callers of this function!
748 // The idea here is to take into account what object is moving the pagination point, and
749 // thus choose the best place to chop it.
750 void RenderView::setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak)
751 {
752     // Nobody else can set a page break once we have a forced break.
753     if (m_legacyPrinting.m_forcedPageBreak)
754         return;
755
756     // Forced breaks always win over unforced breaks.
757     if (forcedBreak) {
758         m_legacyPrinting.m_forcedPageBreak = true;
759         m_legacyPrinting.m_bestTruncatedAt = y;
760         return;
761     }
762
763     // Prefer the widest object that tries to move the pagination point
764     IntRect boundingBox = forRenderer->borderBoundingBox();
765     if (boundingBox.width() > m_legacyPrinting.m_truncatorWidth) {
766         m_legacyPrinting.m_truncatorWidth = boundingBox.width();
767         m_legacyPrinting.m_bestTruncatedAt = y;
768     }
769 }
770
771 #if USE(ACCELERATED_COMPOSITING)
772 bool RenderView::usesCompositing() const
773 {
774     return m_compositor && m_compositor->inCompositingMode();
775 }
776
777 RenderLayerCompositor* RenderView::compositor()
778 {
779     if (!m_compositor)
780         m_compositor = adoptPtr(new RenderLayerCompositor(this));
781
782     return m_compositor.get();
783 }
784 #endif
785
786 void RenderView::didMoveOnscreen()
787 {
788 #if USE(ACCELERATED_COMPOSITING)
789     if (m_compositor)
790         m_compositor->didMoveOnscreen();
791 #endif
792 }
793
794 void RenderView::willMoveOffscreen()
795 {
796 #if USE(ACCELERATED_COMPOSITING)
797     if (m_compositor)
798         m_compositor->willMoveOffscreen();
799 #endif
800 }
801
802 void RenderView::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
803 {
804     RenderBlock::styleDidChange(diff, oldStyle);
805     
806     for (RenderObject* renderer = firstChild(); renderer; renderer = renderer->nextSibling()) {
807         if (renderer->isRenderFlowThread()) {
808             RenderFlowThread* flowRenderer = toRenderFlowThread(renderer);
809             flowRenderer->setStyle(RenderFlowThread::createFlowThreadStyle(style()));
810         }
811     }
812 }
813
814 RenderFlowThread* RenderView::renderFlowThreadWithName(const AtomicString& flowThread)
815 {
816     if (!m_renderFlowThreadList)
817         m_renderFlowThreadList = adoptPtr(new RenderFlowThreadList());
818     else {
819         for (RenderFlowThreadList::iterator iter = m_renderFlowThreadList->begin(); iter != m_renderFlowThreadList->end(); ++iter) {
820             RenderFlowThread* flowRenderer = *iter;
821             if (flowRenderer->flowThread() == flowThread)
822                 return flowRenderer;
823         }
824     }
825
826     RenderFlowThread* flowRenderer = new (renderArena()) RenderFlowThread(document(), flowThread);
827     flowRenderer->setStyle(RenderFlowThread::createFlowThreadStyle(style()));
828     addChild(flowRenderer);
829     
830     m_renderFlowThreadList->add(flowRenderer);
831     setIsRenderFlowThreadOrderDirty(true);
832
833     return flowRenderer;
834 }
835
836 void RenderView::layoutRenderFlowThreads()
837 {
838     ASSERT(m_renderFlowThreadList);
839
840     if (isRenderFlowThreadOrderDirty()) {
841         // Arrange the thread list according to dependencies.
842         RenderFlowThreadList sortedList;
843         for (RenderFlowThreadList::iterator iter = m_renderFlowThreadList->begin(); iter != m_renderFlowThreadList->end(); ++iter) {
844             RenderFlowThread* flowRenderer = *iter;
845             if (sortedList.contains(flowRenderer))
846                 continue;
847             flowRenderer->pushDependencies(sortedList);
848             sortedList.add(flowRenderer);
849         }
850         m_renderFlowThreadList->swap(sortedList);
851         setIsRenderFlowThreadOrderDirty(false);
852     }
853
854     for (RenderFlowThreadList::iterator iter = m_renderFlowThreadList->begin(); iter != m_renderFlowThreadList->end(); ++iter) {
855         RenderFlowThread* flowRenderer = *iter;
856         flowRenderer->layoutIfNeeded();
857     }
858 }
859
860 } // namespace WebCore