| /* |
| * 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 |
| |
| #if defined(ANDROID_LAYOUT) || defined(ANDROID_FIXED_ELEMENTS) |
| #include "Settings.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_maximalOutlineSize(0) |
| , m_pageLogicalHeight(0) |
| , m_pageLogicalHeightChanged(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_minPreferredLogicalWidth = 0; |
| m_maxPreferredLogicalWidth = 0; |
| |
| setPreferredLogicalWidthsDirty(true, false); |
| |
| setPositioned(true); // to 0,0 :) |
| } |
| |
| RenderView::~RenderView() |
| { |
| } |
| |
| void RenderView::computeLogicalHeight() |
| { |
| if (!printing() && m_frameView) |
| setLogicalHeight(viewLogicalHeight()); |
| } |
| |
| void RenderView::computeLogicalWidth() |
| { |
| if (!printing() && m_frameView) |
| setLogicalWidth(viewLogicalWidth()); |
| #ifdef ANDROID_LAYOUT |
| setVisibleWidth(m_frameView->textWrapWidth()); |
| #endif |
| } |
| |
| void RenderView::computePreferredLogicalWidths() |
| { |
| ASSERT(preferredLogicalWidthsDirty()); |
| |
| RenderBlock::computePreferredLogicalWidths(); |
| |
| m_maxPreferredLogicalWidth = m_minPreferredLogicalWidth; |
| } |
| |
| bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const |
| { |
| return child->isBox(); |
| } |
| |
| void RenderView::layout() |
| { |
| if (!document()->paginated()) |
| setPageLogicalHeight(0); |
| |
| if (printing()) |
| m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth(); |
| |
| // 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()->logicalHeight().isPercent() || child->style()->logicalMinHeight().isPercent() || child->style()->logicalMaxHeight().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; |
| state.m_pageLogicalHeight = m_pageLogicalHeight; |
| state.m_pageLogicalHeightChanged = m_pageLogicalHeightChanged; |
| m_pageLogicalHeightChanged = false; |
| m_layoutState = &state; |
| |
| if (needsLayout()) |
| RenderBlock::layout(); |
| |
| 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 (useTransforms && shouldUseTransformFromContainer(0)) { |
| TransformationMatrix t; |
| getTransformFromContainer(0, IntSize(), t); |
| transformState.applyTransform(t); |
| } |
| |
| if (fixed && m_frameView) |
| transformState.move(m_frameView->scrollOffsetForFixedPosition()); |
| } |
| |
| void RenderView::mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState& transformState) const |
| { |
| if (fixed && m_frameView) |
| transformState.move(-m_frameView->scrollOffsetForFixedPosition()); |
| |
| if (useTransforms && shouldUseTransformFromContainer(0)) { |
| TransformationMatrix t; |
| getTransformFromContainer(0, IntSize(), t); |
| transformState.applyTransform(t); |
| } |
| } |
| |
| 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()); |
| 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(); |
| } |
| |
| float pageScaleFactor = 1; |
| if (Frame* frame = m_frameView->frame()) |
| pageScaleFactor = frame->pageScaleFactor(); |
| |
| // If painting will entirely fill the view, no need to fill the background. |
| if (rootFillsViewport && rendererObscuresBackground(firstChild()) && pageScaleFactor >= 1) |
| return; |
| |
| // This code typically only executes if the root element's visibility has been set to hidden, |
| // if there is a transform on the <html>, or if there is a page scale factor less than 1. |
| // 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 (frameView()->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) { |
| CompositeOperator previousOperator = paintInfo.context->compositeOperation(); |
| paintInfo.context->setCompositeOperation(CompositeCopy); |
| paintInfo.context->fillRect(paintInfo.rect, baseColor, style()->colorSpace()); |
| paintInfo.context->setCompositeOperation(previousOperator); |
| } 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 (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 (style()->isFlippedBlocksWritingMode()) { |
| // We have to flip by hand since the view's logical height has not been determined. We |
| // can use the viewport width and height. |
| if (style()->isHorizontalWritingMode()) |
| rect.setY(viewHeight() - rect.maxY()); |
| else |
| rect.setX(viewWidth() - rect.maxX()); |
| } |
| |
| if (fixed && m_frameView) |
| rect.move(m_frameView->scrollXForFixedPosition(), m_frameView->scrollYForFixedPosition()); |
| |
| // 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(); |
| } |
| |
| size_t RenderView::getRetainedWidgets(Vector<RenderWidget*>& renderWidgets) |
| { |
| size_t size = m_widgets.size(); |
| |
| 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(); |
| } |
| |
| return size; |
| } |
| |
| void RenderView::releaseWidgets(Vector<RenderWidget*>& renderWidgets) |
| { |
| size_t size = renderWidgets.size(); |
| |
| for (size_t i = 0; i < size; ++i) |
| renderWidgets[i]->deref(renderArena()); |
| } |
| |
| 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. |
| |
| Vector<RenderWidget*> renderWidgets; |
| size_t size = getRetainedWidgets(renderWidgets); |
| |
| for (size_t i = 0; i < size; ++i) |
| renderWidgets[i]->updateWidgetPosition(); |
| |
| for (size_t i = 0; i < size; ++i) |
| renderWidgets[i]->widgetPositionsUpdated(); |
| |
| releaseWidgets(renderWidgets); |
| } |
| |
| void RenderView::addWidget(RenderWidget* o) |
| { |
| m_widgets.add(o); |
| } |
| |
| void RenderView::removeWidget(RenderWidget* o) |
| { |
| m_widgets.remove(o); |
| } |
| |
| void RenderView::notifyWidgets(WidgetNotification notification) |
| { |
| Vector<RenderWidget*> renderWidgets; |
| size_t size = getRetainedWidgets(renderWidgets); |
| |
| for (size_t i = 0; i < size; ++i) |
| renderWidgets[i]->notifyWidget(notification); |
| |
| releaseWidgets(renderWidgets); |
| } |
| |
| IntRect RenderView::viewRect() const |
| { |
| if (printing()) |
| return IntRect(0, 0, width(), height()); |
| if (m_frameView) |
| return m_frameView->visibleContentRect(); |
| return IntRect(); |
| } |
| |
| int RenderView::docTop() const |
| { |
| IntRect overflowRect(0, minYLayoutOverflow(), 0, maxYLayoutOverflow() - minYLayoutOverflow()); |
| flipForWritingMode(overflowRect); |
| if (hasTransform()) |
| overflowRect = layer()->currentTransform().mapRect(overflowRect); |
| return overflowRect.y(); |
| } |
| |
| int RenderView::docBottom() const |
| { |
| IntRect overflowRect(layoutOverflowRect()); |
| flipForWritingMode(overflowRect); |
| if (hasTransform()) |
| overflowRect = layer()->currentTransform().mapRect(overflowRect); |
| return overflowRect.maxY(); |
| } |
| |
| int RenderView::docLeft() const |
| { |
| IntRect overflowRect(layoutOverflowRect()); |
| flipForWritingMode(overflowRect); |
| if (hasTransform()) |
| overflowRect = layer()->currentTransform().mapRect(overflowRect); |
| return overflowRect.x(); |
| } |
| |
| int RenderView::docRight() const |
| { |
| IntRect overflowRect(layoutOverflowRect()); |
| flipForWritingMode(overflowRect); |
| if (hasTransform()) |
| overflowRect = layer()->currentTransform().mapRect(overflowRect); |
| return overflowRect.maxX(); |
| } |
| |
| 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 |
| { |
| Frame* frame = m_frameView->frame(); |
| return frame ? frame->pageZoomFactor() : 1; |
| } |
| |
| void RenderView::pushLayoutState(RenderObject* root) |
| { |
| 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); |
| } |
| } |
| |
| // FIXME: This function is obsolete and only used by embedded WebViews inside AppKit NSViews. |
| // Do not add callers of this function! |
| // 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_legacyPrinting.m_forcedPageBreak) |
| return; |
| |
| // Forced breaks always win over unforced breaks. |
| if (forcedBreak) { |
| m_legacyPrinting.m_forcedPageBreak = true; |
| m_legacyPrinting.m_bestTruncatedAt = y; |
| return; |
| } |
| |
| // Prefer the widest object that tries to move the pagination point |
| IntRect boundingBox = forRenderer->borderBoundingBox(); |
| if (boundingBox.width() > m_legacyPrinting.m_truncatorWidth) { |
| m_legacyPrinting.m_truncatorWidth = boundingBox.width(); |
| m_legacyPrinting.m_bestTruncatedAt = y; |
| } |
| } |
| |
| #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 |
