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