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