// If we have columns, then the available logical height is reduced to the column height.
if (hasColumns())
return columnInfo()->columnHeight();
- return RenderBlock::availableLogicalHeight(heightType);
+ return RenderBlockFlow::availableLogicalHeight(heightType);
}
bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const
return child->isBox();
}
-static bool dialogNeedsCentering(const RenderStyle* style)
+static bool canCenterDialog(const RenderStyle* style)
{
+ // FIXME: We must center for FixedPosition as well.
return style->position() == AbsolutePosition && style->hasAutoTopAndBottom();
}
if (dialog->centeringMode() == HTMLDialogElement::NotCentered)
return;
if (dialog->centeringMode() == HTMLDialogElement::Centered) {
- if (dialogNeedsCentering(box->style()))
+ if (canCenterDialog(box->style()))
box->setY(dialog->centeredPosition());
return;
}
- if (!dialogNeedsCentering(box->style())) {
+ ASSERT(dialog->centeringMode() == HTMLDialogElement::NeedsCentering);
+ if (!canCenterDialog(box->style())) {
dialog->setNotCentered();
return;
}
ASSERT(needsLayout());
LayoutRectRecorder recorder(*this);
- RenderBlock::layout();
+ RenderBlockFlow::layout();
if (RuntimeEnabledFeatures::dialogElementEnabled())
positionDialogs();
if (m_frameView->partialLayout().isStopping())
return;
- if (hasRenderNamedFlowThreads())
- flowThreadController()->layoutRenderNamedFlowThreads();
-
#ifndef NDEBUG
checkLayoutState(state);
#endif
}
#endif
-void RenderView::addChild(RenderObject* newChild, RenderObject* beforeChild)
-{
- RenderBlock::addChild(newChild, beforeChild);
-}
-
void RenderView::initializeLayoutState(LayoutState& state)
{
// FIXME: May be better to push a clip and avoid issuing offscreen repaints.
state.m_isPaginated = state.m_pageLogicalHeight;
}
-// The algorithm below assumes this is a full layout. In case there are previously computed values for regions, supplemental steps are taken
-// to ensure the results are the same as those obtained from a full layout (i.e. the auto-height regions from all the flows are marked as needing
-// layout).
-// 1. The flows are laid out from the outer flow to the inner flow. This successfully computes the outer non-auto-height regions size so the
-// inner flows have the necessary information to correctly fragment the content.
-// 2. The flows are laid out from the inner flow to the outer flow. After an inner flow is laid out it goes into the constrained layout phase
-// and marks the auto-height regions they need layout. This means the outer flows will relayout if they depend on regions with auto-height regions
-// belonging to inner flows. This step will correctly set the computedAutoHeight for the auto-height regions. It's possible for non-auto-height
-// regions to relayout if they depend on auto-height regions. This will invalidate the inner flow threads and mark them as needing layout.
-// 3. The last step is to do one last layout if there are pathological dependencies between non-auto-height regions and auto-height regions
-// as detected in the previous step.
-void RenderView::layoutContentInAutoLogicalHeightRegions(const LayoutState& state)
-{
- if (!m_frameView->partialLayout().isStopping()) {
- // Disable partial layout for any two-pass layout algorithm.
- m_frameView->partialLayout().reset();
- }
-
- // We need to invalidate all the flows with auto-height regions if one such flow needs layout.
- // If none is found we do a layout a check back again afterwards.
- if (!flowThreadController()->updateFlowThreadsNeedingLayout()) {
- // Do a first layout of the content. In some cases more layouts are not needed (e.g. only flows with non-auto-height regions have changed).
- layoutContent(state);
-
- // If we find no named flow needing a two step layout after the first layout, exit early.
- // Otherwise, initiate the two step layout algorithm and recompute all the flows.
- if (!flowThreadController()->updateFlowThreadsNeedingTwoStepLayout())
- return;
- }
-
- // Layout to recompute all the named flows with auto-height regions.
- layoutContent(state);
-
- // Propagate the computed auto-height values upwards.
- // Non-auto-height regions may invalidate the flow thread because they depended on auto-height regions, but that's ok.
- flowThreadController()->updateFlowThreadsIntoConstrainedPhase();
-
- // Do one last layout that should update the auto-height regions found in the main flow
- // and solve pathological dependencies between regions (e.g. a non-auto-height region depending
- // on an auto-height one).
- if (needsLayout())
- layoutContent(state);
-}
-
void RenderView::layout()
{
if (!document().paginated())
m_pageLogicalHeightChanged = false;
m_layoutState = &state;
- if (checkTwoPassLayoutForAutoHeightRegions())
- layoutContentInAutoLogicalHeightRegions(state);
- else
- layoutContent(state);
+ layoutContent(state);
if (m_frameView->partialLayout().isStopping()) {
m_layoutState = 0;
rects.append(LayoutRect(LayoutPoint::zero(), frameView()->contentsSize()));
}
-bool RenderView::requiresColumns(int desiredColumnCount) const
-{
- if (m_frameView)
- return m_frameView->pagination().mode != Pagination::Unpaginated;
-
- return RenderBlock::requiresColumns(desiredColumnCount);
-}
-
-void RenderView::calcColumnWidth()
-{
- int columnWidth = contentLogicalWidth();
- if (m_frameView && style()->hasInlineColumnAxis()) {
- if (int pageLength = m_frameView->pagination().pageLength)
- columnWidth = pageLength;
- }
- setDesiredColumnCountAndWidth(1, columnWidth);
-}
-
-ColumnInfo::PaginationUnit RenderView::paginationUnit() const
-{
- if (m_frameView)
- return m_frameView->pagination().behavesLikeColumns ? ColumnInfo::Column : ColumnInfo::Page;
-
- return ColumnInfo::Page;
-}
-
void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
// If we ever require layout but receive a paint anyway, something has gone horribly wrong.
ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
// This avoids painting garbage between columns if there is a column gap.
- if (m_frameView && m_frameView->pagination().mode != Pagination::Unpaginated)
+ if (m_frameView && style()->isOverflowPaged())
paintInfo.context->fillRect(paintInfo.rect, m_frameView->baseBackgroundColor());
paintObject(paintInfo, paintOffset);
}
-static inline bool rendererObscuresBackground(RenderObject* rootObject)
+static inline bool rendererObscuresBackground(RenderBox* rootBox)
{
- if (!rootObject)
- return false;
-
- RenderStyle* style = rootObject->style();
+ ASSERT(rootBox);
+ RenderStyle* style = rootBox->style();
if (style->visibility() != VISIBLE
|| style->opacity() != 1
|| style->hasTransform())
return false;
- if (rootObject->compositingState() == PaintsIntoOwnBacking)
+ if (rootBox->compositingState() == PaintsIntoOwnBacking)
return false;
- const RenderObject* rootRenderer = rootObject->rendererForRootBackground();
+ const RenderObject* rootRenderer = rootBox->rendererForRootBackground();
if (rootRenderer->style()->backgroundClip() == TextFillBox)
return false;
return true;
}
+bool RenderView::rootFillsViewportBackground(RenderBox* rootBox) const
+{
+ ASSERT(rootBox);
+ // CSS Boxes always fill the viewport background (see paintRootBoxFillLayers)
+ if (!rootBox->isSVG())
+ return true;
+
+ return rootBox->frameRect().contains(frameRect());
+}
+
void RenderView::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint&)
{
// Check to see if we are enclosed by a layer that requires complex painting rules. If so, we cannot blit
if (paintInfo.skipRootBackground())
return;
- bool rootFillsViewport = false;
- bool rootObscuresBackground = false;
+ bool shouldPaintBackground = true;
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();
- rootObscuresBackground = rendererObscuresBackground(rootRenderer);
- }
-
- Page* page = document().page();
- float pageScaleFactor = page ? page->pageScaleFactor() : 1;
+ if (RenderBox* rootBox = documentElement ? toRenderBox(documentElement->renderer()) : 0)
+ shouldPaintBackground = !rootFillsViewportBackground(rootBox) || !rendererObscuresBackground(rootBox);
// If painting will entirely fill the view, no need to fill the background.
- if (rootFillsViewport && rootObscuresBackground && pageScaleFactor >= 1)
+ if (!shouldPaintBackground)
return;
// This code typically only executes if the root element's visibility has been set to hidden,
repaintViewRectangle(ur);
+ // FIXME: We don't actually know how to hit these ASSERTS.
+ DisableCompositingQueryAsserts disabler;
+
if (compositor()->inCompositingMode()) {
IntRect repaintRect = pixelSnappedIntRect(ur);
compositor()->repaintCompositedLayers(&repaintRect);
{
repaint();
+ // The only way we know how to hit these ASSERTS below this point is via the Chromium OS login screen.
+ DisableCompositingQueryAsserts disabler;
+
if (compositor()->inCompositingMode())
compositor()->repaintCompositedLayers();
}
selectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, clipToVisibleContent)));
RenderBlock* cb = os->containingBlock();
while (cb && !cb->isRenderView()) {
- OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).iterator->value;
+ OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).storedValue->value;
if (blockInfo)
break;
blockInfo = adoptPtr(new RenderSelectionInfo(cb, clipToVisibleContent));
if (blockRepaintMode == RepaintNewXOROld) {
RenderBlock* cb = os->containingBlock();
while (cb && !cb->isRenderView()) {
- OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).iterator->value;
+ OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).storedValue->value;
if (blockInfo)
break;
blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
newSelectedObjects.set(o, adoptPtr(new RenderSelectionInfo(o, true)));
RenderBlock* cb = o->containingBlock();
while (cb && !cb->isRenderView()) {
- OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).iterator->value;
+ OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).storedValue->value;
if (blockInfo)
break;
blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
return width;
}
-int RenderView::viewLogicalHeight(ScrollableArea::IncludeScrollbarsInRect scrollbarInclusion) const
+int RenderView::viewLogicalHeight() const
{
- int height = style()->isHorizontalWritingMode() ? viewHeight(scrollbarInclusion) : viewWidth(scrollbarInclusion);
-
- if (hasColumns() && !style()->hasInlineColumnAxis()) {
- if (int pageLength = m_frameView->pagination().pageLength)
- height = pageLength;
- }
-
- return height;
+ return style()->isHorizontalWritingMode() ? viewHeight(ScrollableArea::ExcludeScrollbars) : viewWidth(ScrollableArea::ExcludeScrollbars);
}
float RenderView::zoomFactor() const
m_compositor->setIsInWindow(isInWindow);
}
-void RenderView::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
-{
- RenderBlock::styleDidChange(diff, oldStyle);
- if (hasRenderNamedFlowThreads())
- flowThreadController()->styleDidChange();
-}
-
-bool RenderView::hasRenderNamedFlowThreads() const
-{
- return m_flowThreadController && m_flowThreadController->hasRenderNamedFlowThreads();
-}
-
-bool RenderView::checkTwoPassLayoutForAutoHeightRegions() const
-{
- return hasRenderNamedFlowThreads() && m_flowThreadController->hasFlowThreadsWithAutoLogicalHeightRegions();
-}
-
FlowThreadController* RenderView::flowThreadController()
{
if (!m_flowThreadController)
- m_flowThreadController = FlowThreadController::create(this);
+ m_flowThreadController = FlowThreadController::create();
return m_flowThreadController.get();
}
projects / platform / framework / web / crosswalk.git / blobdiff