--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/rendering/RenderView.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,761 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "RenderView.h"
+
+#include "Document.h"
+#include "Element.h"
+#include "FloatQuad.h"
+#include "Frame.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+#include "HTMLFrameOwnerElement.h"
+#include "HitTestResult.h"
+#include "RenderLayer.h"
+#include "RenderSelectionInfo.h"
+#include "RenderWidget.h"
+#include "RenderWidgetProtector.h"
+#include "TransformState.h"
+
+#if USE(ACCELERATED_COMPOSITING)
+#include "RenderLayerCompositor.h"
+#endif
+
+namespace WebCore {
+
+RenderView::RenderView(Node* node, FrameView* view)
+ : RenderBlock(node)
+ , m_frameView(view)
+ , m_selectionStart(0)
+ , m_selectionEnd(0)
+ , m_selectionStartPos(-1)
+ , m_selectionEndPos(-1)
+ , m_printImages(true)
+ , m_maximalOutlineSize(0)
+ , m_bestTruncatedAt(0)
+ , m_truncatorWidth(0)
+ , m_minimumColumnHeight(0)
+ , m_forcedPageBreak(false)
+ , m_layoutState(0)
+ , m_layoutStateDisableCount(0)
+{
+ // Clear our anonymous bit, set because RenderObject assumes
+ // any renderer with document as the node is anonymous.
+ setIsAnonymous(false);
+
+ // init RenderObject attributes
+ setInline(false);
+
+ m_minPrefWidth = 0;
+ m_maxPrefWidth = 0;
+
+ setPrefWidthsDirty(true, false);
+
+ setPositioned(true); // to 0,0 :)
+}
+
+RenderView::~RenderView()
+{
+}
+
+void RenderView::calcHeight()
+{
+ if (!printing() && m_frameView)
+ setHeight(viewHeight());
+}
+
+void RenderView::calcWidth()
+{
+ if (!printing() && m_frameView)
+ setWidth(viewWidth());
+ m_marginLeft = 0;
+ m_marginRight = 0;
+}
+
+void RenderView::calcPrefWidths()
+{
+ ASSERT(prefWidthsDirty());
+
+ RenderBlock::calcPrefWidths();
+
+ m_maxPrefWidth = m_minPrefWidth;
+}
+
+void RenderView::layout()
+{
+ if (printing())
+ m_minPrefWidth = m_maxPrefWidth = width();
+
+ // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
+ bool relayoutChildren = !printing() && (!m_frameView || width() != viewWidth() || height() != viewHeight());
+ if (relayoutChildren) {
+ setChildNeedsLayout(true, false);
+ for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+ if (child->style()->height().isPercent() || child->style()->minHeight().isPercent() || child->style()->maxHeight().isPercent())
+ child->setChildNeedsLayout(true, false);
+ }
+ }
+
+ ASSERT(!m_layoutState);
+ LayoutState state;
+ // FIXME: May be better to push a clip and avoid issuing offscreen repaints.
+ state.m_clipped = false;
+ m_layoutState = &state;
+
+ if (needsLayout())
+ RenderBlock::layout();
+
+ // Reset overflow and then replace it with docWidth and docHeight.
+ m_overflow.clear();
+ addLayoutOverflow(IntRect(0, 0, docWidth(), docHeight()));
+
+
+ ASSERT(layoutDelta() == IntSize());
+ ASSERT(m_layoutStateDisableCount == 0);
+ ASSERT(m_layoutState == &state);
+ m_layoutState = 0;
+ setNeedsLayout(false);
+}
+
+void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool /*useTransforms*/, TransformState& transformState) const
+{
+ // If a container was specified, and was not 0 or the RenderView,
+ // then we should have found it by now.
+ ASSERT_UNUSED(repaintContainer, !repaintContainer || repaintContainer == this);
+
+ if (fixed && m_frameView)
+ transformState.move(m_frameView->scrollOffset());
+}
+
+void RenderView::mapAbsoluteToLocalPoint(bool fixed, bool /*useTransforms*/, TransformState& transformState) const
+{
+ if (fixed && m_frameView)
+ transformState.move(-m_frameView->scrollOffset());
+}
+
+void RenderView::paint(PaintInfo& paintInfo, int tx, int ty)
+{
+ // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
+ ASSERT(!needsLayout());
+
+ // Cache the print rect because the dirty rect could get changed during painting.
+ if (printing())
+ setPrintRect(paintInfo.rect);
+ else
+ setPrintRect(IntRect());
+ paintObject(paintInfo, tx, ty);
+}
+
+static inline bool isComposited(RenderObject* object)
+{
+ return object->hasLayer() && toRenderBoxModelObject(object)->layer()->isComposited();
+}
+
+static inline bool rendererObscuresBackground(RenderObject* object)
+{
+ return object && object->style()->visibility() == VISIBLE
+ && object->style()->opacity() == 1
+ && !object->style()->hasTransform()
+ && !isComposited(object);
+}
+
+void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int, int)
+{
+ // Check to see if we are enclosed by a layer that requires complex painting rules. If so, we cannot blit
+ // when scrolling, and we need to use slow repaints. Examples of layers that require this are transparent layers,
+ // layers with reflections, or transformed layers.
+ // FIXME: This needs to be dynamic. We should be able to go back to blitting if we ever stop being inside
+ // a transform, transparency layer, etc.
+ Element* elt;
+ for (elt = document()->ownerElement(); view() && elt && elt->renderer(); elt = elt->document()->ownerElement()) {
+ RenderLayer* layer = elt->renderer()->enclosingLayer();
+ if (layer->requiresSlowRepaints()) {
+ frameView()->setUseSlowRepaints();
+ break;
+ }
+
+#if USE(ACCELERATED_COMPOSITING)
+ if (RenderLayer* compositingLayer = layer->enclosingCompositingLayer()) {
+ if (!compositingLayer->backing()->paintingGoesToWindow()) {
+ frameView()->setUseSlowRepaints();
+ break;
+ }
+ }
+#endif
+ }
+
+ if (document()->ownerElement() || !view())
+ return;
+
+ bool rootFillsViewport = false;
+ Node* documentElement = document()->documentElement();
+ if (RenderObject* rootRenderer = documentElement ? documentElement->renderer() : 0) {
+ // The document element's renderer is currently forced to be a block, but may not always be.
+ RenderBox* rootBox = rootRenderer->isBox() ? toRenderBox(rootRenderer) : 0;
+ rootFillsViewport = rootBox && !rootBox->x() && !rootBox->y() && rootBox->width() >= width() && rootBox->height() >= height();
+ }
+
+ // If painting will entirely fill the view, no need to fill the background.
+ if (rootFillsViewport && rendererObscuresBackground(firstChild()))
+ return;
+
+ // This code typically only executes if the root element's visibility has been set to hidden,
+ // or there is a transform on the <html>.
+ // Only fill with the base background color (typically white) if we're the root document,
+ // since iframes/frames with no background in the child document should show the parent's background.
+ if (view()->isTransparent()) // FIXME: This needs to be dynamic. We should be able to go back to blitting if we ever stop being transparent.
+ frameView()->setUseSlowRepaints(); // The parent must show behind the child.
+ else {
+ Color baseColor = frameView()->baseBackgroundColor();
+ if (baseColor.alpha() > 0) {
+ paintInfo.context->save();
+ paintInfo.context->setCompositeOperation(CompositeCopy);
+ paintInfo.context->fillRect(paintInfo.rect, baseColor, style()->colorSpace());
+ paintInfo.context->restore();
+ } else
+ paintInfo.context->clearRect(paintInfo.rect);
+ }
+}
+
+bool RenderView::shouldRepaint(const IntRect& r) const
+{
+ if (printing() || r.width() == 0 || r.height() == 0)
+ return false;
+
+ if (!m_frameView)
+ return false;
+
+ return true;
+}
+
+void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
+{
+ if (!shouldRepaint(ur))
+ return;
+
+ // We always just invalidate the root view, since we could be an iframe that is clipped out
+ // or even invisible.
+ Element* elt = document()->ownerElement();
+ if (!elt)
+ m_frameView->repaintContentRectangle(ur, immediate);
+ else if (RenderBox* obj = elt->renderBox()) {
+ IntRect vr = viewRect();
+ IntRect r = intersection(ur, vr);
+
+ // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
+ // rectangle.
+ r.move(-vr.x(), -vr.y());
+
+ // FIXME: Hardcoded offsets here are not good.
+ r.move(obj->borderLeft() + obj->paddingLeft(),
+ obj->borderTop() + obj->paddingTop());
+ obj->repaintRectangle(r, immediate);
+ }
+}
+
+void RenderView::repaintRectangleInViewAndCompositedLayers(const IntRect& ur, bool immediate)
+{
+ if (!shouldRepaint(ur))
+ return;
+
+ repaintViewRectangle(ur, immediate);
+
+#if USE(ACCELERATED_COMPOSITING)
+ // If we're a frame, repaintViewRectangle will have repainted via a RenderObject in the
+ // parent document.
+ if (document()->ownerElement())
+ return;
+
+ if (compositor()->inCompositingMode())
+ compositor()->repaintCompositedLayersAbsoluteRect(ur);
+#endif
+}
+
+void RenderView::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed)
+{
+ // If a container was specified, and was not 0 or the RenderView,
+ // then we should have found it by now.
+ ASSERT_UNUSED(repaintContainer, !repaintContainer || repaintContainer == this);
+
+ if (printing())
+ return;
+
+ if (fixed && m_frameView)
+ rect.move(m_frameView->scrollX(), m_frameView->scrollY());
+
+ // Apply our transform if we have one (because of full page zooming).
+ if (m_layer && m_layer->transform())
+ rect = m_layer->transform()->mapRect(rect);
+}
+
+void RenderView::absoluteRects(Vector<IntRect>& rects, int tx, int ty)
+{
+ rects.append(IntRect(tx, ty, m_layer->width(), m_layer->height()));
+}
+
+void RenderView::absoluteQuads(Vector<FloatQuad>& quads)
+{
+ quads.append(FloatRect(0, 0, m_layer->width(), m_layer->height()));
+}
+
+static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
+{
+ if (!object)
+ return 0;
+
+ RenderObject* child = object->childAt(offset);
+ return child ? child : object->nextInPreOrderAfterChildren();
+}
+
+IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
+{
+ document()->updateStyleIfNeeded();
+
+ typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectionMap;
+ SelectionMap selectedObjects;
+
+ RenderObject* os = m_selectionStart;
+ RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+ while (os && os != stop) {
+ if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+ // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+ selectedObjects.set(os, new RenderSelectionInfo(os, clipToVisibleContent));
+ RenderBlock* cb = os->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ RenderSelectionInfo* blockInfo = selectedObjects.get(cb);
+ if (blockInfo)
+ break;
+ selectedObjects.set(cb, new RenderSelectionInfo(cb, clipToVisibleContent));
+ cb = cb->containingBlock();
+ }
+ }
+
+ os = os->nextInPreOrder();
+ }
+
+ // Now create a single bounding box rect that encloses the whole selection.
+ IntRect selRect;
+ SelectionMap::iterator end = selectedObjects.end();
+ for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
+ RenderSelectionInfo* info = i->second;
+ // RenderSelectionInfo::rect() is in the coordinates of the repaintContainer, so map to page coordinates.
+ IntRect currRect = info->rect();
+ if (RenderBoxModelObject* repaintContainer = info->repaintContainer()) {
+ FloatQuad absQuad = repaintContainer->localToAbsoluteQuad(FloatRect(currRect));
+ currRect = absQuad.enclosingBoundingBox();
+ }
+ selRect.unite(currRect);
+ delete info;
+ }
+ return selRect;
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+// Compositing layer dimensions take outline size into account, so we have to recompute layer
+// bounds when it changes.
+// FIXME: This is ugly; it would be nice to have a better way to do this.
+void RenderView::setMaximalOutlineSize(int o)
+{
+ if (o != m_maximalOutlineSize) {
+ m_maximalOutlineSize = o;
+
+ // maximalOutlineSize affects compositing layer dimensions.
+ compositor()->setCompositingLayersNeedRebuild(); // FIXME: this really just needs to be a geometry update.
+ }
+}
+#endif
+
+void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionRepaintMode blockRepaintMode)
+{
+ // Make sure both our start and end objects are defined.
+ // Check www.msnbc.com and try clicking around to find the case where this happened.
+ if ((start && !end) || (end && !start))
+ return;
+
+ // Just return if the selection hasn't changed.
+ if (m_selectionStart == start && m_selectionStartPos == startPos &&
+ m_selectionEnd == end && m_selectionEndPos == endPos)
+ return;
+
+ // Record the old selected objects. These will be used later
+ // when we compare against the new selected objects.
+ int oldStartPos = m_selectionStartPos;
+ int oldEndPos = m_selectionEndPos;
+
+ // Objects each have a single selection rect to examine.
+ typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectedObjectMap;
+ SelectedObjectMap oldSelectedObjects;
+ SelectedObjectMap newSelectedObjects;
+
+ // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
+ // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
+ // the union of those rects might remain the same even when changes have occurred.
+ typedef HashMap<RenderBlock*, RenderBlockSelectionInfo*> SelectedBlockMap;
+ SelectedBlockMap oldSelectedBlocks;
+ SelectedBlockMap newSelectedBlocks;
+
+ RenderObject* os = m_selectionStart;
+ RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+ while (os && os != stop) {
+ if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
+ // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
+ oldSelectedObjects.set(os, new RenderSelectionInfo(os, true));
+ if (blockRepaintMode == RepaintNewXOROld) {
+ RenderBlock* cb = os->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ RenderBlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
+ if (blockInfo)
+ break;
+ oldSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
+ cb = cb->containingBlock();
+ }
+ }
+ }
+
+ os = os->nextInPreOrder();
+ }
+
+ // Now clear the selection.
+ SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
+ for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
+ i->first->setSelectionState(SelectionNone);
+
+ // set selection start and end
+ m_selectionStart = start;
+ m_selectionStartPos = startPos;
+ m_selectionEnd = end;
+ m_selectionEndPos = endPos;
+
+ // Update the selection status of all objects between m_selectionStart and m_selectionEnd
+ if (start && start == end)
+ start->setSelectionState(SelectionBoth);
+ else {
+ if (start)
+ start->setSelectionState(SelectionStart);
+ if (end)
+ end->setSelectionState(SelectionEnd);
+ }
+
+ RenderObject* o = start;
+ stop = rendererAfterPosition(end, endPos);
+
+ while (o && o != stop) {
+ if (o != start && o != end && o->canBeSelectionLeaf())
+ o->setSelectionState(SelectionInside);
+ o = o->nextInPreOrder();
+ }
+
+ m_layer->clearBlockSelectionGapsBounds();
+
+ // Now that the selection state has been updated for the new objects, walk them again and
+ // put them in the new objects list.
+ o = start;
+ while (o && o != stop) {
+ if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
+ newSelectedObjects.set(o, new RenderSelectionInfo(o, true));
+ RenderBlock* cb = o->containingBlock();
+ while (cb && !cb->isRenderView()) {
+ RenderBlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
+ if (blockInfo)
+ break;
+ newSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
+ cb = cb->containingBlock();
+ }
+ }
+
+ o = o->nextInPreOrder();
+ }
+
+ if (!m_frameView) {
+ // We built the maps, but we aren't going to use them.
+ // We need to delete the values, otherwise they'll all leak!
+ deleteAllValues(oldSelectedObjects);
+ deleteAllValues(newSelectedObjects);
+ deleteAllValues(oldSelectedBlocks);
+ deleteAllValues(newSelectedBlocks);
+ return;
+ }
+
+ m_frameView->beginDeferredRepaints();
+
+ // Have any of the old selected objects changed compared to the new selection?
+ for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
+ RenderObject* obj = i->first;
+ RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
+ RenderSelectionInfo* oldInfo = i->second;
+ if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
+ (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
+ (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
+ oldInfo->repaint();
+ if (newInfo) {
+ newInfo->repaint();
+ newSelectedObjects.remove(obj);
+ delete newInfo;
+ }
+ }
+ delete oldInfo;
+ }
+
+ // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
+ SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
+ for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
+ RenderSelectionInfo* newInfo = i->second;
+ newInfo->repaint();
+ delete newInfo;
+ }
+
+ // Have any of the old blocks changed?
+ SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
+ for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
+ RenderBlock* block = i->first;
+ RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
+ RenderBlockSelectionInfo* oldInfo = i->second;
+ if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
+ oldInfo->repaint();
+ if (newInfo) {
+ newInfo->repaint();
+ newSelectedBlocks.remove(block);
+ delete newInfo;
+ }
+ }
+ delete oldInfo;
+ }
+
+ // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
+ SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
+ for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
+ RenderBlockSelectionInfo* newInfo = i->second;
+ newInfo->repaint();
+ delete newInfo;
+ }
+
+ m_frameView->endDeferredRepaints();
+}
+
+void RenderView::clearSelection()
+{
+ m_layer->repaintBlockSelectionGaps();
+ setSelection(0, -1, 0, -1, RepaintNewMinusOld);
+}
+
+void RenderView::selectionStartEnd(int& startPos, int& endPos) const
+{
+ startPos = m_selectionStartPos;
+ endPos = m_selectionEndPos;
+}
+
+bool RenderView::printing() const
+{
+ return document()->printing();
+}
+
+void RenderView::updateWidgetPositions()
+{
+ // updateWidgetPosition() can possibly cause layout to be re-entered (via plug-ins running
+ // scripts in response to NPP_SetWindow, for example), so we need to keep the Widgets
+ // alive during enumeration.
+
+ size_t size = m_widgets.size();
+
+ Vector<RenderWidget*> renderWidgets;
+ renderWidgets.reserveCapacity(size);
+
+ RenderWidgetSet::const_iterator end = m_widgets.end();
+ for (RenderWidgetSet::const_iterator it = m_widgets.begin(); it != end; ++it) {
+ renderWidgets.uncheckedAppend(*it);
+ (*it)->ref();
+ }
+
+ for (size_t i = 0; i < size; ++i)
+ renderWidgets[i]->updateWidgetPosition();
+
+ for (size_t i = 0; i < size; ++i)
+ renderWidgets[i]->widgetPositionsUpdated();
+
+ for (size_t i = 0; i < size; ++i)
+ renderWidgets[i]->deref(renderArena());
+}
+
+void RenderView::addWidget(RenderWidget* o)
+{
+ m_widgets.add(o);
+}
+
+void RenderView::removeWidget(RenderWidget* o)
+{
+ m_widgets.remove(o);
+}
+
+IntRect RenderView::viewRect() const
+{
+ if (printing())
+ return IntRect(0, 0, width(), height());
+ if (m_frameView)
+ return m_frameView->visibleContentRect();
+ return IntRect();
+}
+
+int RenderView::docHeight() const
+{
+ int h = lowestPosition();
+
+ // FIXME: This doesn't do any margin collapsing.
+ // Instead of this dh computation we should keep the result
+ // when we call RenderBlock::layout.
+ int dh = 0;
+ for (RenderBox* c = firstChildBox(); c; c = c->nextSiblingBox())
+ dh += c->height() + c->marginTop() + c->marginBottom();
+
+ if (dh > h)
+ h = dh;
+
+ return h;
+}
+
+int RenderView::docWidth() const
+{
+ int w = rightmostPosition();
+
+ for (RenderBox* c = firstChildBox(); c; c = c->nextSiblingBox()) {
+ int dw = c->width() + c->marginLeft() + c->marginRight();
+ if (dw > w)
+ w = dw;
+ }
+
+ return w;
+}
+
+int RenderView::viewHeight() const
+{
+ int height = 0;
+ if (!printing() && m_frameView) {
+ height = m_frameView->layoutHeight();
+ height = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(height)) : height;
+ }
+ return height;
+}
+
+int RenderView::viewWidth() const
+{
+ int width = 0;
+ if (!printing() && m_frameView) {
+ width = m_frameView->layoutWidth();
+ width = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(width)) : width;
+ }
+ return width;
+}
+
+float RenderView::zoomFactor() const
+{
+ if (!m_frameView->shouldApplyPageZoom())
+ return 1;
+ return m_frameView->zoomFactor();
+}
+
+// The idea here is to take into account what object is moving the pagination point, and
+// thus choose the best place to chop it.
+void RenderView::setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak)
+{
+ // Nobody else can set a page break once we have a forced break.
+ if (m_forcedPageBreak)
+ return;
+
+ // Forced breaks always win over unforced breaks.
+ if (forcedBreak) {
+ m_forcedPageBreak = true;
+ m_bestTruncatedAt = y;
+ return;
+ }
+
+ // Prefer the widest object that tries to move the pagination point
+ IntRect boundingBox = forRenderer->borderBoundingBox();
+ if (boundingBox.width() > m_truncatorWidth) {
+ m_truncatorWidth = boundingBox.width();
+ m_bestTruncatedAt = y;
+ }
+}
+
+void RenderView::pushLayoutState(RenderObject* root)
+{
+ ASSERT(!doingFullRepaint());
+ ASSERT(m_layoutStateDisableCount == 0);
+ ASSERT(m_layoutState == 0);
+
+ m_layoutState = new (renderArena()) LayoutState(root);
+}
+
+bool RenderView::shouldDisableLayoutStateForSubtree(RenderObject* renderer) const
+{
+ RenderObject* o = renderer;
+ while (o) {
+ if (o->hasColumns() || o->hasTransform() || o->hasReflection())
+ return true;
+ o = o->container();
+ }
+ return false;
+}
+
+void RenderView::updateHitTestResult(HitTestResult& result, const IntPoint& point)
+{
+ if (result.innerNode())
+ return;
+
+ Node* node = document()->documentElement();
+ if (node) {
+ result.setInnerNode(node);
+ if (!result.innerNonSharedNode())
+ result.setInnerNonSharedNode(node);
+ result.setLocalPoint(point);
+ }
+}
+
+#if USE(ACCELERATED_COMPOSITING)
+bool RenderView::usesCompositing() const
+{
+ return m_compositor && m_compositor->inCompositingMode();
+}
+
+RenderLayerCompositor* RenderView::compositor()
+{
+ if (!m_compositor)
+ m_compositor.set(new RenderLayerCompositor(this));
+
+ return m_compositor.get();
+}
+#endif
+
+void RenderView::didMoveOnscreen()
+{
+#if USE(ACCELERATED_COMPOSITING)
+ if (m_compositor)
+ m_compositor->didMoveOnscreen();
+#endif
+}
+
+void RenderView::willMoveOffscreen()
+{
+#if USE(ACCELERATED_COMPOSITING)
+ if (m_compositor)
+ m_compositor->willMoveOffscreen();
+#endif
+}
+
+} // namespace WebCore