void RenderView::paintBoxDecorationBackground(PaintInfo& paintInfo, const LayoutPoint&)
{
if (!view())
return;
if (paintInfo.skipRootBackground())
return;
bool shouldPaintBackground = true;
Node* documentElement = document().documentElement();
if (RenderBox* rootBox = documentElement ? toRenderBox(documentElement->renderer()) : 0)
shouldPaintBackground = !rendererObscuresBackground(rootBox);
// If painting will entirely fill the view, no need to fill the background.
if (!shouldPaintBackground)
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()) {
Color baseColor = frameView()->baseBackgroundColor();
if (baseColor.alpha()) {
CompositeOperator previousOperator = paintInfo.context->compositeOperation();
paintInfo.context->setCompositeOperation(CompositeCopy);
paintInfo.context->fillRect(paintInfo.rect, baseColor);
paintInfo.context->setCompositeOperation(previousOperator);
} else {
paintInfo.context->clearRect(paintInfo.rect);
}
}
}
void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
{
// 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 (elt || (firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
return;
// This code typically only executes if the root element's visibility has been set to hidden.
// 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);
paintInfo.context->restore();
} else
paintInfo.context->clearRect(paintInfo.rect);
}
}
LayoutUnit RenderView::availableLogicalHeight(AvailableLogicalHeightType) const
{
// If we have columns, then the available logical height is reduced to the column height.
if (hasColumns())
return columnInfo()->columnHeight();
return isHorizontalWritingMode() ? frameView().visibleHeight() : frameView().visibleWidth();
}
void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
{
// Check to see if we are enclosed by a transparent layer. If so, we cannot blit
// when scrolling, and we need to use slow repaints.
Element* elt;
for (elt = document()->ownerElement(); view() && elt && elt->renderer(); elt = elt->document()->ownerElement()) {
RenderLayer* layer = elt->renderer()->enclosingLayer();
if (layer->isTransparent() || layer->transparentAncestor()) {
frameView()->setUseSlowRepaints();
break;
}
}
if (elt || (firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
return;
// This code typically only executes if the root element's visibility has been set to hidden.
// 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())
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);
paintInfo.context->restore();
} else
paintInfo.context->clearRect(paintInfo.rect);
}
}
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
// 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->cannotBlitToWindow()) {
frameView()->setCannotBlitToWindow();
break;
}
#if USE(ACCELERATED_COMPOSITING)
if (RenderLayer* compositingLayer = layer->enclosingCompositingLayerForRepaint()) {
if (!compositingLayer->backing()->paintsIntoWindow()) {
frameView()->setCannotBlitToWindow();
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();
}
Page* page = document()->page();
float pageScaleFactor = page ? page->pageScaleFactor() : 1;
// 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()->setCannotBlitToWindow(); // 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);
}
}
int RenderView::viewWidth() const
{
int width = 0;
if (!shouldUsePrintingLayout()) {
width = frameView().layoutWidth();
width = frameView().useFixedLayout() ? ceilf(style()->effectiveZoom() * float(width)) : width;
}
return width;
}
int RenderView::viewHeight() const
{
int height = 0;
if (!shouldUsePrintingLayout()) {
height = frameView().layoutHeight();
height = frameView().useFixedLayout() ? ceilf(style()->effectiveZoom() * float(height)) : height;
}
return height;
}
void FramePainter::paintScrollbar(GraphicsContext& context, Scrollbar& bar, const IntRect& rect)
{
bool needsBackground = bar.isCustomScrollbar() && frameView().frame().isMainFrame();
if (needsBackground) {
IntRect toFill = bar.frameRect();
toFill.intersect(rect);
context.fillRect(toFill, frameView().baseBackgroundColor());
}
bar.paint(context, CullRect(rect));
}
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
// 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->cannotBlitToWindow()) {
frameView()->setCannotBlitToWindow();
break;
}
if (layer->enclosingCompositingLayerForRepaint()) {
frameView()->setCannotBlitToWindow();
break;
}
}
if (document().ownerElement() || !view())
return;
if (paintInfo.skipRootBackground())
return;
bool shouldPaintBackground = true;
Node* documentElement = document().documentElement();
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 (!shouldPaintBackground)
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()->setCannotBlitToWindow(); // The parent must show behind the child.
else {
Color baseColor = frameView()->baseBackgroundColor();
if (baseColor.alpha()) {
CompositeOperator previousOperator = paintInfo.context->compositeOperation();
paintInfo.context->setCompositeOperation(CompositeCopy);
paintInfo.context->fillRect(paintInfo.rect, baseColor);
paintInfo.context->setCompositeOperation(previousOperator);
} else {
paintInfo.context->clearRect(paintInfo.rect);
}
}
}
void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
// If we ever require layout but receive a paint anyway, something has gone horribly wrong.
ASSERT(!needsLayout());
// RenderViews should never be called to paint with an offset not on device pixels.
ASSERT(LayoutPoint(IntPoint(paintOffset.x(), paintOffset.y())) == paintOffset);
// This avoids painting garbage between columns if there is a column gap.
if (frameView().pagination().mode != Pagination::Unpaginated && paintInfo.shouldPaintWithinRoot(*this))
paintInfo.context->fillRect(paintInfo.rect, frameView().baseBackgroundColor(), ColorSpaceDeviceRGB);
paintObject(paintInfo, paintOffset);
}
void RenderView::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint&) const
{
// Record the entire size of the contents of the frame. Note that we don't just
// use the viewport size (containing block) here because we want to ensure this includes
// all children (so we can avoid walking them explicitly).
rects.append(LayoutRect(LayoutPoint::zero(), frameView()->contentsSize()));
}
void RenderWidget::setWidget(PassRefPtr<Widget> widget)
{
if (widget == m_widget)
return;
if (m_widget) {
moveWidgetToParentSoon(m_widget.get(), 0);
clearWidget();
}
m_widget = widget;
if (m_widget) {
// If we've already received a layout, apply the calculated space to the
// widget immediately, but we have to have really been fully constructed (with a non-null
// style pointer).
if (style()) {
if (!needsLayout())
updateWidgetGeometry();
if (style()->visibility() != VISIBLE)
m_widget->hide();
else {
m_widget->show();
repaint();
}
}
moveWidgetToParentSoon(m_widget.get(), frameView());
}
if (AXObjectCache* cache = document().existingAXObjectCache())
cache->childrenChanged(this);
}
void RenderView::computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect& rect, bool fixed) const
{
// If a container was specified, and was not 0 or the RenderView,
// then we should have found it by now.
ASSERT_ARG(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)
rect.move(frameView().scrollOffsetForFixedPosition());
// Apply our transform if we have one (because of full page zooming).
if (!repaintContainer && layer() && layer()->transform())
rect = layer()->transform()->mapRect(rect);
}
LayoutRect RenderView::visualOverflowRect() const
{
if (frameView().paintsEntireContents())
return layoutOverflowRect();
return RenderBlock::visualOverflowRect();
}
void Editor::newLevel( vec2f size )
{
delete m_level;
m_level = new Cavern();
m_level->m_mapSize = size;
frameView();
}
void applySizeOverrideIfNecessary()
{
FrameView* view = frameView();
if (!view)
return;
applySizeOverrideInternal(view, FitWindowAllowed);
}
void PtexViewer::goToFace(int i)
{
if (i>=0 && _displayFace<0) _mainCam = _cam;
else if (i<0) _cam = _mainCam;
_displayFace = i;
if (_displayFace>=0 || (i<0&&_mainCam.getDistance()==0)) frameView();
}
void RenderView::calcColumnWidth()
{
int columnWidth = contentLogicalWidth();
if (style()->hasInlineColumnAxis()) {
if (int pageLength = frameView().pagination().pageLength)
columnWidth = pageLength;
}
setDesiredColumnCountAndWidth(1, columnWidth);
}
bool RenderView::hitTest(const HitTestRequest& request, const HitTestLocation& location, HitTestResult& result)
{
// We have to recursively update layout/style here because otherwise, when the hit test recurses
// into a child document, it could trigger a layout on the parent document, which can destroy RenderLayers
// that are higher up in the call stack, leading to crashes.
// Note that Document::updateLayout calls its parent's updateLayout.
// FIXME: It should be the caller's responsibility to ensure an up-to-date layout.
frameView()->updateLayoutAndStyleIfNeededRecursive();
return layer()->hitTest(request, location, result);
}
RenderWidget::RenderWidget(Element* element)
: RenderReplaced(element)
// Reference counting is used to prevent the widget from being
// destroyed while inside the Widget code, which might not be
// able to handle that.
, m_refCount(1)
{
ASSERT(element);
frameView()->addWidget(this);
}
LayoutPart::LayoutPart(Element* element)
: LayoutReplaced(element)
// Reference counting is used to prevent the part from being destroyed
// while inside the Widget code, which might not be able to handle that.
, m_refCount(1)
{
ASSERT(element);
frameView()->addPart(this);
setInline(false);
}
void FramePainter::paintScrollbars(GraphicsContext& context, const IntRect& rect)
{
if (frameView().horizontalScrollbar() && !frameView().layerForHorizontalScrollbar())
paintScrollbar(context, *frameView().horizontalScrollbar(), rect);
if (frameView().verticalScrollbar() && !frameView().layerForVerticalScrollbar())
paintScrollbar(context, *frameView().verticalScrollbar(), rect);
if (frameView().layerForScrollCorner())
return;
paintScrollCorner(context, frameView().scrollCornerRect());
}
void RenderImage::paintInvalidationOrMarkForLayout(const IntRect* rect)
{
ASSERT(isRooted());
LayoutSize oldIntrinsicSize = intrinsicSize();
LayoutSize newIntrinsicSize = m_imageResource->intrinsicSize();
updateIntrinsicSizeIfNeeded(newIntrinsicSize);
bool imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize;
if (imageSourceHasChangedSize)
setPreferredLogicalWidthsDirty();
// If the actual area occupied by the image has changed and it is not constrained by style then a layout is required.
bool imageSizeIsConstrained = style()->logicalWidth().isSpecified() && style()->logicalHeight().isSpecified();
// FIXME: We only need to recompute the containing block's preferred size if the containing block's size
// depends on the image's size (i.e., the container uses shrink-to-fit sizing).
// There's no easy way to detect that shrink-to-fit is needed, always force a layout.
bool containingBlockNeedsToRecomputePreferredSize = style()->logicalWidth().isPercent() || style()->logicalMaxWidth().isPercent() || style()->logicalMinWidth().isPercent();
if (imageSourceHasChangedSize && (!imageSizeIsConstrained || containingBlockNeedsToRecomputePreferredSize)) {
setNeedsLayoutAndFullPaintInvalidation();
return;
}
// The image hasn't changed in size or its style constrains its size, so a paint invalidation will suffice.
if (everHadLayout() && !selfNeedsLayout()) {
// The inner content rectangle is calculated during layout, but may need an update now
// (unless the box has already been scheduled for layout). In order to calculate it, we
// may need values from the containing block, though, so make sure that we're not too
// early. It may be that layout hasn't even taken place once yet.
updateInnerContentRect();
}
LayoutRect paintInvalidationRect;
if (rect) {
// The image changed rect is in source image coordinates,
// so map from the bounds of the image to the contentsBox.
paintInvalidationRect = enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), m_imageResource->imageSize()), contentBoxRect()));
// Guard against too-large changed rects.
paintInvalidationRect.intersect(contentBoxRect());
} else {
paintInvalidationRect = contentBoxRect();
}
{
// FIXME: We should not be allowing paint invalidations during layout. crbug.com/339584
AllowPaintInvalidationScope scoper(frameView());
DisableCompositingQueryAsserts disabler;
invalidatePaintRectangle(paintInvalidationRect);
}
// Tell any potential compositing layers that the image needs updating.
contentChanged(ImageChanged);
}
void RenderView::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
{
if (mode & IsFixed)
transformState.move(frameView().scrollOffsetForFixedPosition());
if (mode & UseTransforms && shouldUseTransformFromContainer(0)) {
TransformationMatrix t;
getTransformFromContainer(0, LayoutSize(), t);
transformState.applyTransform(t);
}
}
LayoutUnit RenderView::pageOrViewLogicalHeight() const
{
if (document().printing())
return pageLogicalHeight();
if (hasColumns() && !style()->hasInlineColumnAxis()) {
if (int pageLength = frameView().pagination().pageLength)
return pageLength;
}
return viewLogicalHeight();
}
void RenderWidget::willBeDestroyed()
{
frameView()->removeWidget(this);
if (AXObjectCache* cache = document().existingAXObjectCache()) {
cache->childrenChanged(this->parent());
cache->remove(this);
}
setWidget(0);
RenderReplaced::willBeDestroyed();
}
void RenderView::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
{
// Check to see if we are enclosed by a transparent layer. If so, we cannot blit
// when scrolling, and we need to use slow repaints.
Element* elt = element()->document()->ownerElement();
if (view() && elt) {
RenderLayer* layer = elt->renderer()->enclosingLayer();
if (layer->isTransparent() || layer->transparentAncestor())
frameView()->useSlowRepaints();
}
if ((firstChild() && firstChild()->style()->visibility() == VISIBLE) || !view())
return;
// This code typically only executes if the root element's visibility has been set to hidden.
// Only fill with white if we're the root document, since iframes/frames with
// no background in the child document should show the parent's background.
if (elt || view()->isTransparent())
frameView()->useSlowRepaints(); // The parent must show behind the child.
else
i.p->fillRect(i.r, Color(Color::white));
}
void RenderView::paintBoxDecorationBackground(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (!view())
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()) {
Color baseColor = frameView()->baseBackgroundColor();
if (baseColor.alpha()) {
CompositeOperator previousOperator = paintInfo.context->compositeOperation();
paintInfo.context->setCompositeOperation(CompositeCopy);
paintInfo.context->fillRect(paintInfo.rect, baseColor);
paintInfo.context->setCompositeOperation(previousOperator);
} else {
paintInfo.context->clearRect(paintInfo.rect);
}
}
paintCustomPainting(paintInfo, paintOffset);
}
bool PtexViewer::load(std::string s, int faceid, bool flat)
{
bool success = true;
_enable3D = !flat;
success = loadFile(s, faceid);
if (success && faceid>=0) _displayFace = faceid;
_filename = s;
frameView(true);
return success;
}
void restore()
{
WebCore::FrameView* view = frameView();
if (!view)
return;
m_webView->setZoomLevel(false, 0);
m_webView->setEmulatedTextZoomFactor(1);
view->setHorizontalScrollbarLock(false);
view->setVerticalScrollbarLock(false);
view->setScrollbarModes(ScrollbarAuto, ScrollbarAuto, false, false);
view->resize(IntSize(m_webView->size()));
m_webView->sendResizeEventAndRepaint();
}
