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