void DrawLooperBuilder::addShadow(const FloatSize& offset, float blur, const Color& color,
ShadowTransformMode shadowTransformMode, ShadowAlphaMode shadowAlphaMode)
{
// Detect when there's no effective shadow.
if (!color.alpha())
return;
SkColor skColor = color.rgb();
SkLayerDrawLooper::LayerInfo info;
switch (shadowAlphaMode) {
case ShadowRespectsAlpha:
info.fColorMode = SkBlendMode::kDst;
break;
case ShadowIgnoresAlpha:
info.fColorMode = SkBlendMode::kSrc;
break;
default:
ASSERT_NOT_REACHED();
}
if (blur)
info.fPaintBits |= SkLayerDrawLooper::kMaskFilter_Bit; // our blur
info.fPaintBits |= SkLayerDrawLooper::kColorFilter_Bit;
info.fOffset.set(offset.width(), offset.height());
info.fPostTranslate = (shadowTransformMode == ShadowIgnoresTransforms);
SkPaint* paint = m_skDrawLooperBuilder.addLayerOnTop(info);
if (blur) {
const SkScalar sigma = RadiusToSigma(blur / 2);
uint32_t mfFlags = SkBlurMaskFilter::kHighQuality_BlurFlag;
if (shadowTransformMode == ShadowIgnoresTransforms)
mfFlags |= SkBlurMaskFilter::kIgnoreTransform_BlurFlag;
paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma, mfFlags));
}
paint->setColorFilter(SkColorFilter::MakeModeFilter(skColor, SkBlendMode::kSrcIn));
}
AffineTransform SVGSVGElement::localCoordinateSpaceTransform(SVGLocatable::CTMScope mode) const
{
AffineTransform viewBoxTransform;
if (hasAttribute(SVGNames::viewBoxAttr)) {
FloatSize size = currentViewportSize();
viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
}
AffineTransform transform;
if (!isOutermostSVGSVGElement()) {
SVGLengthContext lengthContext(this);
transform.translate(x().value(lengthContext), y().value(lengthContext));
} else if (mode == SVGLocatable::ScreenScope) {
if (RenderObject* renderer = this->renderer()) {
FloatPoint location;
// At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
// to map an element from SVG viewport coordinates to CSS box coordinates.
// RenderSVGRoot's localToAbsolute method expects CSS box coordinates.
if (renderer->isSVGRoot())
location = toRenderSVGRoot(renderer)->localToBorderBoxTransform().mapPoint(location);
// Translate in our CSS parent coordinate space
// FIXME: This doesn't work correctly with CSS transforms.
location = renderer->localToAbsolute(location, false, true);
// Be careful here! localToBorderBoxTransform() included the x/y offset coming from the viewBoxToViewTransform(),
// so we have to subtract it here (original cause of bug #27183)
transform.translate(location.x() - viewBoxTransform.e(), location.y() - viewBoxTransform.f());
// Respect scroll offset.
if (FrameView* view = document()->view()) {
LayoutSize scrollOffset = view->scrollOffset();
transform.translate(-scrollOffset.width(), -scrollOffset.height());
}
}
}
return transform.multiply(viewBoxTransform);
}
SVGTransform SVGTransformDistance::addToSVGTransform(const SVGTransform& transform) const
{
ASSERT(m_type == transform.type() || transform == SVGTransform());
SVGTransform newTransform(transform);
switch (m_type) {
case SVGTransform::SVG_TRANSFORM_MATRIX:
ASSERT_NOT_REACHED();
case SVGTransform::SVG_TRANSFORM_UNKNOWN:
return SVGTransform();
case SVGTransform::SVG_TRANSFORM_TRANSLATE: {
FloatPoint translation = transform.translate();
translation += FloatSize::narrowPrecision(m_transform.e(), m_transform.f());
newTransform.setTranslate(translation.x(), translation.y());
return newTransform;
}
case SVGTransform::SVG_TRANSFORM_SCALE: {
FloatSize scale = transform.scale();
scale += FloatSize::narrowPrecision(m_transform.a(), m_transform.d());
newTransform.setScale(scale.width(), scale.height());
return newTransform;
}
case SVGTransform::SVG_TRANSFORM_ROTATE: {
FloatPoint center = transform.rotationCenter();
newTransform.setRotate(transform.angle() + m_angle, center.x() + m_cx, center.y() + m_cy);
return newTransform;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
newTransform.setSkewX(transform.angle() + m_angle);
return newTransform;
case SVGTransform::SVG_TRANSFORM_SKEWY:
newTransform.setSkewY(transform.angle() + m_angle);
return newTransform;
}
ASSERT_NOT_REACHED();
return SVGTransform();
}
static inline FloatPoint rightMostCornerToVector(const FloatRect& rect, const FloatSize& vector)
{
// Return the corner of the rectangle that if it is to the left of the vector
// would mean all of the rectangle is to the left of the vector.
// The vector here represents the side between two points in a clockwise convex polygon.
//
// Q XXX
// QQQ XXX If the lower left corner of X is left of the vector that goes from the top corner of Q to
// QQQ the right corner of Q, then all of X is left of the vector, and intersection impossible.
// Q
//
FloatPoint point;
if (vector.width() >= 0)
point.setY(rect.maxY());
else
point.setY(rect.y());
if (vector.height() >= 0)
point.setX(rect.x());
else
point.setX(rect.maxX());
return point;
}
void SVGAnimateMotionElement::calculateAnimatedValue(float percentage, unsigned, SVGSMILElement*)
{
SVGElement* targetElement = this->targetElement();
if (!targetElement)
return;
AffineTransform* transform = targetElement->supplementalTransform();
if (!transform)
return;
if (RenderObject* targetRenderer = targetElement->renderer())
targetRenderer->setNeedsTransformUpdate();
if (!isAdditive())
transform->makeIdentity();
// FIXME: Implement accumulate.
if (animationMode() == PathAnimation) {
ASSERT(!animationPath().isEmpty());
Path path = animationPath();
float positionOnPath = path.length() * percentage;
bool ok;
FloatPoint position = path.pointAtLength(positionOnPath, ok);
if (ok) {
transform->translate(position.x(), position.y());
RotateMode rotateMode = this->rotateMode();
if (rotateMode == RotateAuto || rotateMode == RotateAutoReverse) {
float angle = path.normalAngleAtLength(positionOnPath, ok);
if (rotateMode == RotateAutoReverse)
angle += 180;
transform->rotate(angle);
}
}
return;
}
FloatSize diff = m_toPoint - m_fromPoint;
transform->translate(diff.width() * percentage + m_fromPoint.x(), diff.height() * percentage + m_fromPoint.y());
}
FloatRect FilterEffect::determineFilterPrimitiveSubregion()
{
ASSERT(filter());
// FETile, FETurbulence, FEFlood don't have input effects, take the filter region as unite rect.
FloatRect subregion;
if (unsigned numberOfInputEffects = inputEffects().size()) {
subregion = inputEffect(0)->determineFilterPrimitiveSubregion();
for (unsigned i = 1; i < numberOfInputEffects; ++i)
subregion.unite(inputEffect(i)->determineFilterPrimitiveSubregion());
} else
subregion = filter()->filterRegion();
// After calling determineFilterPrimitiveSubregion on the target effect, reset the subregion again for <feTile>.
if (filterEffectType() == FilterEffectTypeTile)
subregion = filter()->filterRegion();
subregion = mapRect(subregion);
FloatRect boundaries = effectBoundaries();
if (hasX())
subregion.setX(boundaries.x());
if (hasY())
subregion.setY(boundaries.y());
if (hasWidth())
subregion.setWidth(boundaries.width());
if (hasHeight())
subregion.setHeight(boundaries.height());
setFilterPrimitiveSubregion(subregion);
FloatRect absoluteSubregion = filter()->absoluteTransform().mapRect(subregion);
FloatSize filterResolution = filter()->filterResolution();
absoluteSubregion.scale(filterResolution.width(), filterResolution.height());
setMaxEffectRect(absoluteSubregion);
return subregion;
}
SVGTransform SVGTransformDistance::addSVGTransforms(const SVGTransform& first, const SVGTransform& second, unsigned repeatCount)
{
ASSERT(first.type() == second.type());
SVGTransform transform;
switch (first.type()) {
case SVGTransform::SVG_TRANSFORM_MATRIX:
ASSERT_NOT_REACHED();
case SVGTransform::SVG_TRANSFORM_UNKNOWN:
return SVGTransform();
case SVGTransform::SVG_TRANSFORM_ROTATE: {
transform.setRotate(first.angle() + second.angle() * repeatCount, first.rotationCenter().x() + second.rotationCenter().x() * repeatCount, first.rotationCenter().y() + second.rotationCenter().y() * repeatCount);
return transform;
}
case SVGTransform::SVG_TRANSFORM_TRANSLATE: {
float dx = first.translate().x() + second.translate().x() * repeatCount;
float dy = first.translate().y() + second.translate().y() * repeatCount;
transform.setTranslate(dx, dy);
return transform;
}
case SVGTransform::SVG_TRANSFORM_SCALE: {
FloatSize scale = second.scale();
scale.scale(repeatCount);
scale += first.scale();
transform.setScale(scale.width(), scale.height());
return transform;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
transform.setSkewX(first.angle() + second.angle() * repeatCount);
return transform;
case SVGTransform::SVG_TRANSFORM_SKEWY:
transform.setSkewY(first.angle() + second.angle() * repeatCount);
return transform;
}
ASSERT_NOT_REACHED();
return SVGTransform();
}
IntSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
{
#if PLATFORM(ANDROID)
/* In Android we capture the drawing into a displayList, and then
replay that list at various scale factors (sometimes zoomed out, other
times zoomed in for "normal" reading, yet other times at arbitrary
zoom values based on the user's choice). In all of these cases, we do
not re-record the displayList, hence it is usually harmful to perform
any pre-rounding, since we just don't know the actual drawing resolution
at record time.
*/
float pageScaleFactor = 1.0f;
#else
float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
#endif
float wf = ceilf(logicalSize.width() * pageScaleFactor);
float hf = ceilf(logicalSize.height() * pageScaleFactor);
if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
return IntSize();
return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
}
static void drawCrossfadeSubimage(GraphicsContext& context, Image* image, CompositeOperator operation, float opacity, const FloatSize& targetSize)
{
FloatSize imageSize = image->size();
// SVGImage resets the opacity when painting, so we have to use transparency layers to accurately paint one at a given opacity.
bool useTransparencyLayer = image->isSVGImage();
GraphicsContextStateSaver stateSaver(context);
context.setCompositeOperation(operation);
if (useTransparencyLayer)
context.beginTransparencyLayer(opacity);
else
context.setAlpha(opacity);
if (targetSize != imageSize)
context.scale(FloatSize(targetSize.width() / imageSize.width(), targetSize.height() / imageSize.height()));
context.drawImage(image, ColorSpaceDeviceRGB, IntPoint());
if (useTransparencyLayer)
context.endTransparencyLayer();
}
int TextFinder::nearestFindMatch(const FloatPoint& point,
float* distanceSquared) {
updateFindMatchRects();
int nearest = -1;
float nearestDistanceSquared = FLT_MAX;
for (size_t i = 0; i < m_findMatchesCache.size(); ++i) {
DCHECK(!m_findMatchesCache[i].m_rect.isEmpty());
FloatSize offset = point - m_findMatchesCache[i].m_rect.center();
float width = offset.width();
float height = offset.height();
float currentDistanceSquared = width * width + height * height;
if (currentDistanceSquared < nearestDistanceSquared) {
nearest = i;
nearestDistanceSquared = currentDistanceSquared;
}
}
if (distanceSquared)
*distanceSquared = nearestDistanceSquared;
return nearest;
}
void PrintContext::computePageRects(const FloatRect& printRect,
float headerHeight,
float footerHeight,
float userScaleFactor,
float& outPageHeight) {
m_pageRects.clear();
outPageHeight = 0;
if (!m_frame->document() || !m_frame->view() ||
m_frame->document()->layoutViewItem().isNull())
return;
if (userScaleFactor <= 0) {
DLOG(ERROR) << "userScaleFactor has bad value " << userScaleFactor;
return;
}
LayoutViewItem view = m_frame->document()->layoutViewItem();
const IntRect& documentRect = view.documentRect();
FloatSize pageSize = m_frame->resizePageRectsKeepingRatio(
FloatSize(printRect.width(), printRect.height()),
FloatSize(documentRect.width(), documentRect.height()));
float pageWidth = pageSize.width();
float pageHeight = pageSize.height();
outPageHeight =
pageHeight; // this is the height of the page adjusted by margins
pageHeight -= headerHeight + footerHeight;
if (pageHeight <= 0) {
DLOG(ERROR) << "pageHeight has bad value " << pageHeight;
return;
}
computePageRectsWithPageSizeInternal(
FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor));
}
float SVGLengthContext::valueForLength(const Length& length, SVGLengthMode mode)
{
if (length.isPercent()) {
auto result = convertValueFromPercentageToUserUnits(length.value() / 100, mode);
if (result.hasException())
return 0;
return result.releaseReturnValue();
}
if (length.isAuto() || !length.isSpecified())
return 0;
FloatSize viewportSize;
determineViewport(viewportSize);
switch (mode) {
case LengthModeWidth:
return floatValueForLength(length, viewportSize.width());
case LengthModeHeight:
return floatValueForLength(length, viewportSize.height());
case LengthModeOther:
return floatValueForLength(length, std::sqrt(viewportSize.diagonalLengthSquared() / 2));
};
return 0;
}
void SVGImage::drawPatternForContainer(GraphicsContext& context, const FloatSize containerSize,
float zoom, const FloatRect& srcRect, const FloatSize& tileScale, const FloatPoint& phase,
SkXfermode::Mode compositeOp, const FloatRect& dstRect,
const FloatSize& repeatSpacing, const KURL& url)
{
// Tile adjusted for scaling/stretch.
FloatRect tile(srcRect);
tile.scale(tileScale.width(), tileScale.height());
// Expand the tile to account for repeat spacing.
FloatRect spacedTile(tile);
spacedTile.expand(FloatSize(repeatSpacing));
SkPictureBuilder patternPicture(spacedTile, nullptr, &context);
if (!DrawingRecorder::useCachedDrawingIfPossible(patternPicture.context(), *this, DisplayItem::Type::SVGImage)) {
DrawingRecorder patternPictureRecorder(patternPicture.context(), *this, DisplayItem::Type::SVGImage, spacedTile);
// When generating an expanded tile, make sure we don't draw into the spacing area.
if (tile != spacedTile)
patternPicture.context().clip(tile);
SkPaint paint;
drawForContainer(patternPicture.context().canvas(), paint, containerSize, zoom, tile, srcRect, url);
}
RefPtr<const SkPicture> tilePicture = patternPicture.endRecording();
SkMatrix patternTransform;
patternTransform.setTranslate(phase.x() + spacedTile.x(), phase.y() + spacedTile.y());
RefPtr<SkShader> patternShader = adoptRef(SkShader::CreatePictureShader(
tilePicture.get(), SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
&patternTransform, nullptr));
SkPaint paint;
paint.setShader(patternShader.get());
paint.setXfermodeMode(compositeOp);
paint.setColorFilter(context.colorFilter());
context.drawRect(dstRect, paint);
}
void Path::addBeziersForRoundedRect(const FloatRect& rect, const FloatSize& topLeftRadius, const FloatSize& topRightRadius, const FloatSize& bottomLeftRadius, const FloatSize& bottomRightRadius)
{
moveTo(FloatPoint(rect.x() + topLeftRadius.width(), rect.y()));
addLineTo(FloatPoint(rect.maxX() - topRightRadius.width(), rect.y()));
addBezierCurveTo(FloatPoint(rect.maxX() - topRightRadius.width() * gCircleControlPoint, rect.y()),
FloatPoint(rect.maxX(), rect.y() + topRightRadius.height() * gCircleControlPoint),
FloatPoint(rect.maxX(), rect.y() + topRightRadius.height()));
addLineTo(FloatPoint(rect.maxX(), rect.maxY() - bottomRightRadius.height()));
addBezierCurveTo(FloatPoint(rect.maxX(), rect.maxY() - bottomRightRadius.height() * gCircleControlPoint),
FloatPoint(rect.maxX() - bottomRightRadius.width() * gCircleControlPoint, rect.maxY()),
FloatPoint(rect.maxX() - bottomRightRadius.width(), rect.maxY()));
addLineTo(FloatPoint(rect.x() + bottomLeftRadius.width(), rect.maxY()));
addBezierCurveTo(FloatPoint(rect.x() + bottomLeftRadius.width() * gCircleControlPoint, rect.maxY()),
FloatPoint(rect.x(), rect.maxY() - bottomLeftRadius.height() * gCircleControlPoint),
FloatPoint(rect.x(), rect.maxY() - bottomLeftRadius.height()));
addLineTo(FloatPoint(rect.x(), rect.y() + topLeftRadius.height()));
addBezierCurveTo(FloatPoint(rect.x(), rect.y() + topLeftRadius.height() * gCircleControlPoint),
FloatPoint(rect.x() + topLeftRadius.width() * gCircleControlPoint, rect.y()),
FloatPoint(rect.x() + topLeftRadius.width(), rect.y()));
closeSubpath();
}
void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowInlineDirectionTiling)
{
if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderView())
return;
RenderView* view = m_frame->document()->renderView();
IntRect docRect = view->documentRect();
int pageWidth = pageSizeInPixels.width();
int pageHeight = pageSizeInPixels.height();
bool isHorizontal = view->style()->isHorizontalWritingMode();
int docLogicalHeight = isHorizontal ? docRect.height() : docRect.width();
int pageLogicalHeight = isHorizontal ? pageHeight : pageWidth;
int pageLogicalWidth = isHorizontal ? pageWidth : pageHeight;
int inlineDirectionStart;
int inlineDirectionEnd;
int blockDirectionStart;
int blockDirectionEnd;
if (isHorizontal) {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxY();
blockDirectionEnd = docRect.y();
} else {
blockDirectionStart = docRect.y();
blockDirectionEnd = docRect.maxY();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.x() : docRect.maxX();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxX() : docRect.x();
} else {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxX();
blockDirectionEnd = docRect.x();
} else {
blockDirectionStart = docRect.x();
blockDirectionEnd = docRect.maxX();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.y() : docRect.maxY();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxY() : docRect.y();
}
unsigned pageCount = ceilf((float)docLogicalHeight / pageLogicalHeight);
for (unsigned i = 0; i < pageCount; ++i) {
int pageLogicalTop = blockDirectionEnd > blockDirectionStart ?
blockDirectionStart + i * pageLogicalHeight :
blockDirectionStart - (i + 1) * pageLogicalHeight;
if (allowInlineDirectionTiling) {
for (int currentInlinePosition = inlineDirectionStart;
inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition < inlineDirectionEnd : currentInlinePosition > inlineDirectionEnd;
currentInlinePosition += (inlineDirectionEnd > inlineDirectionStart ? pageLogicalWidth : -pageLogicalWidth)) {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition : currentInlinePosition - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
} else {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? inlineDirectionStart : inlineDirectionStart - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
}
}
PassOwnPtr<WebTransformOperations> toWebTransformOperations(const TransformOperations& transformOperations, const FloatSize& boxSize)
{
// We need to do a deep copy the transformOperations may contain ref pointers to TransformOperation objects.
OwnPtr<WebTransformOperations> webTransformOperations = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());
if (!webTransformOperations)
return nullptr;
for (size_t j = 0; j < transformOperations.size(); ++j) {
TransformOperation::OperationType operationType = transformOperations.operations()[j]->getOperationType();
switch (operationType) {
case TransformOperation::SCALE_X:
case TransformOperation::SCALE_Y:
case TransformOperation::SCALE_Z:
case TransformOperation::SCALE_3D:
case TransformOperation::SCALE: {
ScaleTransformOperation* transform = static_cast<ScaleTransformOperation*>(transformOperations.operations()[j].get());
webTransformOperations->appendScale(transform->x(), transform->y(), transform->z());
break;
}
case TransformOperation::TRANSLATE_X:
case TransformOperation::TRANSLATE_Y:
case TransformOperation::TRANSLATE_Z:
case TransformOperation::TRANSLATE_3D:
case TransformOperation::TRANSLATE: {
TranslateTransformOperation* transform = static_cast<TranslateTransformOperation*>(transformOperations.operations()[j].get());
webTransformOperations->appendTranslate(floatValueForLength(transform->x(), boxSize.width()), floatValueForLength(transform->y(), boxSize.height()), floatValueForLength(transform->z(), 1));
break;
}
case TransformOperation::ROTATE_X:
case TransformOperation::ROTATE_Y:
case TransformOperation::ROTATE_3D:
case TransformOperation::ROTATE: {
RotateTransformOperation* transform = static_cast<RotateTransformOperation*>(transformOperations.operations()[j].get());
webTransformOperations->appendRotate(transform->x(), transform->y(), transform->z(), transform->angle());
break;
}
case TransformOperation::SKEW_X:
case TransformOperation::SKEW_Y:
case TransformOperation::SKEW: {
SkewTransformOperation* transform = static_cast<SkewTransformOperation*>(transformOperations.operations()[j].get());
webTransformOperations->appendSkew(transform->angleX(), transform->angleY());
break;
}
case TransformOperation::MATRIX: {
MatrixTransformOperation* transform = static_cast<MatrixTransformOperation*>(transformOperations.operations()[j].get());
TransformationMatrix m = transform->matrix();
webTransformOperations->appendMatrix(TransformSkMatrix44Conversions::convert(m));
break;
}
case TransformOperation::MATRIX_3D: {
Matrix3DTransformOperation* transform = static_cast<Matrix3DTransformOperation*>(transformOperations.operations()[j].get());
TransformationMatrix m = transform->matrix();
webTransformOperations->appendMatrix(TransformSkMatrix44Conversions::convert(m));
break;
}
case TransformOperation::PERSPECTIVE: {
PerspectiveTransformOperation* transform = static_cast<PerspectiveTransformOperation*>(transformOperations.operations()[j].get());
webTransformOperations->appendPerspective(floatValueForLength(transform->perspective(), 0));
break;
}
case TransformOperation::IDENTITY:
webTransformOperations->appendIdentity();
break;
case TransformOperation::NONE:
// Do nothing.
break;
} // switch
} // for each operation
return webTransformOperations.release();
}
void SVGRenderingContext::prepareToRenderSVGContent(RenderElement& renderer, PaintInfo& paintInfo, NeedsGraphicsContextSave needsGraphicsContextSave)
{
#ifndef NDEBUG
// This function must not be called twice!
ASSERT(!(m_renderingFlags & PrepareToRenderSVGContentWasCalled));
m_renderingFlags |= PrepareToRenderSVGContentWasCalled;
#endif
m_renderer = &renderer;
m_paintInfo = &paintInfo;
m_filter = 0;
// We need to save / restore the context even if the initialization failed.
if (needsGraphicsContextSave == SaveGraphicsContext) {
m_paintInfo->context().save();
m_renderingFlags |= RestoreGraphicsContext;
}
auto& style = m_renderer->style();
const SVGRenderStyle& svgStyle = style.svgStyle();
// Setup transparency layers before setting up SVG resources!
bool isRenderingMask = isRenderingMaskImage(*m_renderer);
// RenderLayer takes care of root opacity.
float opacity = (renderer.isSVGRoot() || isRenderingMask) ? 1 : style.opacity();
const ShadowData* shadow = svgStyle.shadow();
bool hasBlendMode = style.hasBlendMode();
bool hasIsolation = style.hasIsolation();
bool isolateMaskForBlending = false;
#if ENABLE(CSS_COMPOSITING)
if (svgStyle.hasMasker() && is<SVGGraphicsElement>(downcast<SVGElement>(*renderer.element()))) {
SVGGraphicsElement& graphicsElement = downcast<SVGGraphicsElement>(*renderer.element());
isolateMaskForBlending = graphicsElement.shouldIsolateBlending();
}
#endif
if (opacity < 1 || shadow || hasBlendMode || isolateMaskForBlending || hasIsolation) {
FloatRect repaintRect = m_renderer->repaintRectInLocalCoordinates();
m_paintInfo->context().clip(repaintRect);
if (opacity < 1 || hasBlendMode || isolateMaskForBlending || hasIsolation) {
if (hasBlendMode)
m_paintInfo->context().setCompositeOperation(m_paintInfo->context().compositeOperation(), style.blendMode());
m_paintInfo->context().beginTransparencyLayer(opacity);
if (hasBlendMode)
m_paintInfo->context().setCompositeOperation(m_paintInfo->context().compositeOperation(), BlendModeNormal);
m_renderingFlags |= EndOpacityLayer;
}
if (shadow) {
m_paintInfo->context().setShadow(IntSize(roundToInt(shadow->x()), roundToInt(shadow->y())), shadow->radius(), shadow->color());
m_paintInfo->context().beginTransparencyLayer(1);
m_renderingFlags |= EndShadowLayer;
}
}
ClipPathOperation* clipPathOperation = style.clipPath();
if (is<ShapeClipPathOperation>(clipPathOperation)) {
auto& clipPath = downcast<ShapeClipPathOperation>(*clipPathOperation);
FloatRect referenceBox;
if (clipPath.referenceBox() == Stroke)
// FIXME: strokeBoundingBox() takes dasharray into account but shouldn't.
referenceBox = renderer.strokeBoundingBox();
else if (clipPath.referenceBox() == ViewBox && renderer.element()) {
FloatSize viewportSize;
SVGLengthContext(downcast<SVGElement>(renderer.element())).determineViewport(viewportSize);
referenceBox.setWidth(viewportSize.width());
referenceBox.setHeight(viewportSize.height());
} else
referenceBox = renderer.objectBoundingBox();
m_paintInfo->context().clipPath(clipPath.pathForReferenceRect(referenceBox), clipPath.windRule());
}
auto* resources = SVGResourcesCache::cachedResourcesForRenderer(*m_renderer);
if (!resources) {
if (style.hasReferenceFilterOnly())
return;
m_renderingFlags |= RenderingPrepared;
return;
}
if (!isRenderingMask) {
if (RenderSVGResourceMasker* masker = resources->masker()) {
GraphicsContext* contextPtr = &m_paintInfo->context();
bool result = masker->applyResource(*m_renderer, style, contextPtr, ApplyToDefaultMode);
m_paintInfo->setContext(*contextPtr);
if (!result)
return;
}
}
RenderSVGResourceClipper* clipper = resources->clipper();
if (!clipPathOperation && clipper) {
GraphicsContext* contextPtr = &m_paintInfo->context();
bool result = clipper->applyResource(*m_renderer, style, contextPtr, ApplyToDefaultMode);
m_paintInfo->setContext(*contextPtr);
if (!result)
return;
}
if (!isRenderingMask) {
m_filter = resources->filter();
if (m_filter) {
m_savedContext = &m_paintInfo->context();
m_savedPaintRect = m_paintInfo->rect;
// Return with false here may mean that we don't need to draw the content
// (because it was either drawn before or empty) but we still need to apply the filter.
m_renderingFlags |= EndFilterLayer;
GraphicsContext* contextPtr = &m_paintInfo->context();
bool result = m_filter->applyResource(*m_renderer, style, contextPtr, ApplyToDefaultMode);
m_paintInfo->setContext(*contextPtr);
if (!result)
return;
// Since we're caching the resulting bitmap and do not invalidate it on repaint rect
// changes, we need to paint the whole filter region. Otherwise, elements not visible
// at the time of the initial paint (due to scrolling, window size, etc.) will never
// be drawn.
m_paintInfo->rect = IntRect(m_filter->drawingRegion(m_renderer));
}
}
m_renderingFlags |= RenderingPrepared;
}
FloatRect RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(FilterEffect* effect, SVGFilter* filter)
{
FloatRect uniteRect;
FloatRect subregionBoundingBox = effect->effectBoundaries();
FloatRect subregion = subregionBoundingBox;
if (effect->filterEffectType() != FilterEffectTypeTile) {
// FETurbulence, FEImage and FEFlood don't have input effects, take the filter region as unite rect.
if (unsigned numberOfInputEffects = effect->inputEffects().size()) {
for (unsigned i = 0; i < numberOfInputEffects; ++i)
uniteRect.unite(determineFilterPrimitiveSubregion(effect->inputEffect(i), filter));
} else
uniteRect = filter->filterRegionInUserSpace();
} else {
determineFilterPrimitiveSubregion(effect->inputEffect(0), filter);
uniteRect = filter->filterRegionInUserSpace();
}
if (filter->effectBoundingBoxMode()) {
subregion = uniteRect;
// Avoid the calling of a virtual method several times.
FloatRect targetBoundingBox = filter->targetBoundingBox();
if (effect->hasX())
subregion.setX(targetBoundingBox.x() + subregionBoundingBox.x() * targetBoundingBox.width());
if (effect->hasY())
subregion.setY(targetBoundingBox.y() + subregionBoundingBox.y() * targetBoundingBox.height());
if (effect->hasWidth())
subregion.setWidth(subregionBoundingBox.width() * targetBoundingBox.width());
if (effect->hasHeight())
subregion.setHeight(subregionBoundingBox.height() * targetBoundingBox.height());
} else {
if (!effect->hasX())
subregion.setX(uniteRect.x());
if (!effect->hasY())
subregion.setY(uniteRect.y());
if (!effect->hasWidth())
subregion.setWidth(uniteRect.width());
if (!effect->hasHeight())
subregion.setHeight(uniteRect.height());
}
effect->setFilterPrimitiveSubregion(subregion);
FloatRect absoluteSubregion = filter->mapLocalRectToAbsoluteRect(subregion);
FloatSize filterResolution = filter->filterResolution();
absoluteSubregion.scale(filterResolution.width(), filterResolution.height());
// FEImage needs the unclipped subregion in absolute coordinates to determine the correct
// destination rect in combination with preserveAspectRatio.
if (effect->filterEffectType() == FilterEffectTypeImage)
reinterpret_cast<FEImage*>(effect)->setAbsoluteSubregion(absoluteSubregion);
// Clip every filter effect to the filter region.
FloatRect absoluteScaledFilterRegion = filter->filterRegion();
absoluteScaledFilterRegion.scale(filterResolution.width(), filterResolution.height());
absoluteSubregion.intersect(absoluteScaledFilterRegion);
effect->setMaxEffectRect(enclosingIntRect(absoluteSubregion));
return subregion;
}
FloatSize HTMLCanvasElement::convertDeviceToLogical(const FloatSize& deviceSize) const
{
float width = ceilf(deviceSize.width() / m_deviceScaleFactor);
float height = ceilf(deviceSize.height() / m_deviceScaleFactor);
return FloatSize(width, height);
}
FloatSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
{
float width = ceilf(logicalSize.width() * m_deviceScaleFactor);
float height = ceilf(logicalSize.height() * m_deviceScaleFactor);
return FloatSize(width, height);
}
IntSize SVGImage::containerSize() const
{
SVGSVGElement* rootElement = this->rootElement();
if (!rootElement)
return IntSize();
auto* renderer = downcast<RenderSVGRoot>(rootElement->renderer());
if (!renderer)
return IntSize();
// If a container size is available it has precedence.
IntSize containerSize = renderer->containerSize();
if (!containerSize.isEmpty())
return containerSize;
// Assure that a container size is always given for a non-identity zoom level.
ASSERT(renderer->style().effectiveZoom() == 1);
FloatSize currentSize;
if (rootElement->hasIntrinsicWidth() && rootElement->hasIntrinsicHeight())
currentSize = rootElement->currentViewportSize();
else
currentSize = rootElement->currentViewBoxRect().size();
if (!currentSize.isEmpty())
return IntSize(static_cast<int>(ceilf(currentSize.width())), static_cast<int>(ceilf(currentSize.height())));
// As last resort, use CSS default intrinsic size.
return IntSize(300, 150);
}
static PassOwnPtr<Shape> createEllipseShape(const FloatPoint& center, const FloatSize& radii)
{
ASSERT(radii.width() >= 0 && radii.height() >= 0);
return adoptPtr(new RectangleShape(FloatRect(center.x() - radii.width(), center.y() - radii.height(), radii.width()*2, radii.height()*2), radii));
}
void MediaPlayerPrivateAVFoundation::setNaturalSize(FloatSize size)
{
LOG(Media, "MediaPlayerPrivateAVFoundation:setNaturalSize(%p) - size = %f x %f", this, size.width(), size.height());
FloatSize oldSize = m_cachedNaturalSize;
m_cachedNaturalSize = size;
if (oldSize != m_cachedNaturalSize)
m_player->sizeChanged();
}
void SVGImage::drawForContainer(GraphicsContext* context, const FloatSize containerSize, float zoom, const FloatRect& dstRect,
const FloatRect& srcRect, ColorSpace colorSpace, CompositeOperator compositeOp, BlendMode blendMode)
{
if (!m_page)
return;
ImageObserver* observer = imageObserver();
ASSERT(observer);
// Temporarily reset image observer, we don't want to receive any changeInRect() calls due to this relayout.
setImageObserver(0);
IntSize roundedContainerSize = roundedIntSize(containerSize);
setContainerSize(roundedContainerSize);
FloatRect scaledSrc = srcRect;
scaledSrc.scale(1 / zoom);
// Compensate for the container size rounding by adjusting the source rect.
FloatSize adjustedSrcSize = scaledSrc.size();
adjustedSrcSize.scale(roundedContainerSize.width() / containerSize.width(), roundedContainerSize.height() / containerSize.height());
scaledSrc.setSize(adjustedSrcSize);
draw(context, dstRect, scaledSrc, colorSpace, compositeOp, blendMode);
setImageObserver(observer);
}
IntSize SVGImage::containerSize() const
{
if (!m_page)
return IntSize();
Frame* frame = m_page->mainFrame();
SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
if (!rootElement)
return IntSize();
RenderSVGRoot* renderer = toRenderSVGRoot(rootElement->renderer());
if (!renderer)
return IntSize();
// If a container size is available it has precedence.
IntSize containerSize = renderer->containerSize();
if (!containerSize.isEmpty())
return containerSize;
// Assure that a container size is always given for a non-identity zoom level.
ASSERT(renderer->style()->effectiveZoom() == 1);
FloatSize currentSize;
if (rootElement->intrinsicWidth().isFixed() && rootElement->intrinsicHeight().isFixed())
currentSize = rootElement->currentViewportSize();
else
currentSize = rootElement->currentViewBoxRect().size();
if (!currentSize.isEmpty())
return IntSize(static_cast<int>(ceilf(currentSize.width())), static_cast<int>(ceilf(currentSize.height())));
// As last resort, use CSS default intrinsic size.
return IntSize(300, 150);
}
ImageBuffer::ImageBuffer(const FloatSize& size, float /* resolutionScale */, ColorSpace, RenderingMode renderingMode, bool& success)
: m_data(IntSize(size))
, m_size(size)
, m_logicalSize(size)
{
success = false; // Make early return mean error.
#if ENABLE(ACCELERATED_2D_CANVAS)
if (renderingMode == Accelerated)
m_data.m_surface = createCairoGLSurface(size, m_data.m_texture);
else
#else
ASSERT_UNUSED(renderingMode, renderingMode != Accelerated);
#endif
m_data.m_surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size.width(), size.height()));
if (cairo_surface_status(m_data.m_surface.get()) != CAIRO_STATUS_SUCCESS)
return; // create will notice we didn't set m_initialized and fail.
RefPtr<cairo_t> cr = adoptRef(cairo_create(m_data.m_surface.get()));
m_data.m_platformContext.setCr(cr.get());
m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
success = true;
}
LayoutUnit RenderReplaced::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
{
if (style().logicalWidth().isSpecified() || style().logicalWidth().isIntrinsic())
return computeReplacedLogicalWidthRespectingMinMaxWidth(computeReplacedLogicalWidthUsing(MainOrPreferredSize, style().logicalWidth()), shouldComputePreferred);
RenderBox* contentRenderer = embeddedContentBox();
// 10.3.2 Inline, replaced elements: http://www.w3.org/TR/CSS21/visudet.html#inline-replaced-width
double intrinsicRatio = 0;
FloatSize constrainedSize;
computeAspectRatioInformationForRenderBox(contentRenderer, constrainedSize, intrinsicRatio);
if (style().logicalWidth().isAuto()) {
bool computedHeightIsAuto = hasAutoHeightOrContainingBlockWithAutoHeight();
bool hasIntrinsicWidth = constrainedSize.width() > 0;
// If 'height' and 'width' both have computed values of 'auto' and the element also has an intrinsic width, then that intrinsic width is the used value of 'width'.
if (computedHeightIsAuto && hasIntrinsicWidth)
return computeReplacedLogicalWidthRespectingMinMaxWidth(constrainedSize.width(), shouldComputePreferred);
bool hasIntrinsicHeight = constrainedSize.height() > 0;
if (intrinsicRatio) {
// If 'height' and 'width' both have computed values of 'auto' and the element has no intrinsic width, but does have an intrinsic height and intrinsic ratio;
// or if 'width' has a computed value of 'auto', 'height' has some other computed value, and the element does have an intrinsic ratio; then the used value
// of 'width' is: (used height) * (intrinsic ratio)
if (intrinsicRatio && ((computedHeightIsAuto && !hasIntrinsicWidth && hasIntrinsicHeight) || !computedHeightIsAuto)) {
LayoutUnit logicalHeight = computeReplacedLogicalHeight();
return computeReplacedLogicalWidthRespectingMinMaxWidth(roundToInt(round(logicalHeight * intrinsicRatio)), shouldComputePreferred);
}
// If 'height' and 'width' both have computed values of 'auto' and the element has an intrinsic ratio but no intrinsic height or width, then the used value of
// 'width' is undefined in CSS 2.1. However, it is suggested that, if the containing block's width does not itself depend on the replaced element's width, then
// the used value of 'width' is calculated from the constraint equation used for block-level, non-replaced elements in normal flow.
if (computedHeightIsAuto && !hasIntrinsicWidth && !hasIntrinsicHeight) {
// The aforementioned 'constraint equation' used for block-level, non-replaced elements in normal flow:
// 'margin-left' + 'border-left-width' + 'padding-left' + 'width' + 'padding-right' + 'border-right-width' + 'margin-right' = width of containing block
LayoutUnit logicalWidth;
if (auto* blockWithWidth = firstContainingBlockWithLogicalWidth(this)) {
logicalWidth = blockWithWidth->computeReplacedLogicalWidthUsing(MainOrPreferredSize, blockWithWidth->style().logicalWidth());
if (!blockWithWidth->style().logicalMaxWidth().isMaxContent() && !blockWithWidth->style().logicalMinWidth().isMinContent())
logicalWidth = blockWithWidth->computeReplacedLogicalWidthRespectingMinMaxWidth(logicalWidth, shouldComputePreferred);
} else
logicalWidth = containingBlock()->availableLogicalWidth();
// This solves above equation for 'width' (== logicalWidth).
LayoutUnit marginStart = minimumValueForLength(style().marginStart(), logicalWidth);
LayoutUnit marginEnd = minimumValueForLength(style().marginEnd(), logicalWidth);
logicalWidth = std::max<LayoutUnit>(0, logicalWidth - (marginStart + marginEnd + (width() - clientWidth())));
return computeReplacedLogicalWidthRespectingMinMaxWidth(logicalWidth, shouldComputePreferred);
}
}
// Otherwise, if 'width' has a computed value of 'auto', and the element has an intrinsic width, then that intrinsic width is the used value of 'width'.
if (hasIntrinsicWidth)
return computeReplacedLogicalWidthRespectingMinMaxWidth(constrainedSize.width(), shouldComputePreferred);
// Otherwise, if 'width' has a computed value of 'auto', but none of the conditions above are met, then the used value of 'width' becomes 300px. If 300px is too
// wide to fit the device, UAs should use the width of the largest rectangle that has a 2:1 ratio and fits the device instead.
// Note: We fall through and instead return intrinsicLogicalWidth() here - to preserve existing WebKit behavior, which might or might not be correct, or desired.
// Changing this to return cDefaultWidth, will affect lots of test results. Eg. some tests assume that a blank <img> tag (which implies width/height=auto)
// has no intrinsic size, which is wrong per CSS 2.1, but matches our behavior since a long time.
}
return computeReplacedLogicalWidthRespectingMinMaxWidth(intrinsicLogicalWidth(), shouldComputePreferred);
}
static float computeHeightByAspectRatio(float width, const FloatSize& deviceSize)
{
return width * (deviceSize.height() / deviceSize.width());
}
void Path::translate(const FloatSize& size) {
m_path.offset(WebCoreFloatToSkScalar(size.width()),
WebCoreFloatToSkScalar(size.height()));
}
void SVGPreserveAspectRatio::transformRect(FloatRect& destRect, FloatRect& srcRect)
{
if (m_align == SVG_PRESERVEASPECTRATIO_NONE)
return;
FloatSize imageSize = srcRect.size();
float origDestWidth = destRect.width();
float origDestHeight = destRect.height();
switch (m_meetOrSlice) {
case SVGPreserveAspectRatio::SVG_MEETORSLICE_UNKNOWN:
break;
case SVGPreserveAspectRatio::SVG_MEETORSLICE_MEET: {
float widthToHeightMultiplier = srcRect.height() / srcRect.width();
if (origDestHeight > origDestWidth * widthToHeightMultiplier) {
destRect.setHeight(origDestWidth * widthToHeightMultiplier);
switch (m_align) {
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMINYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMID:
destRect.setY(destRect.y() + origDestHeight / 2 - destRect.height() / 2);
break;
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMINYMAX:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMAX:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMAX:
destRect.setY(destRect.y() + origDestHeight - destRect.height());
break;
default:
break;
}
}
if (origDestWidth > origDestHeight / widthToHeightMultiplier) {
destRect.setWidth(origDestHeight / widthToHeightMultiplier);
switch (m_align) {
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMIN:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMAX:
destRect.setX(destRect.x() + origDestWidth / 2 - destRect.width() / 2);
break;
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMIN:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMAX:
destRect.setX(destRect.x() + origDestWidth - destRect.width());
break;
default:
break;
}
}
break;
}
case SVGPreserveAspectRatio::SVG_MEETORSLICE_SLICE: {
float widthToHeightMultiplier = srcRect.height() / srcRect.width();
// if the destination height is less than the height of the image we'll be drawing
if (origDestHeight < origDestWidth * widthToHeightMultiplier) {
float destToSrcMultiplier = srcRect.width() / destRect.width();
srcRect.setHeight(destRect.height() * destToSrcMultiplier);
switch (m_align) {
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMINYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMID:
srcRect.setY(srcRect.y() + imageSize.height() / 2 - srcRect.height() / 2);
break;
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMINYMAX:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMAX:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMAX:
srcRect.setY(srcRect.y() + imageSize.height() - srcRect.height());
break;
default:
break;
}
}
// if the destination width is less than the width of the image we'll be drawing
if (origDestWidth < origDestHeight / widthToHeightMultiplier) {
float destToSrcMultiplier = srcRect.height() / destRect.height();
srcRect.setWidth(destRect.width() * destToSrcMultiplier);
switch (m_align) {
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMIN:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMIDYMAX:
srcRect.setX(srcRect.x() + imageSize.width() / 2 - srcRect.width() / 2);
break;
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMIN:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMID:
case SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_XMAXYMAX:
srcRect.setX(srcRect.x() + imageSize.width() - srcRect.width());
break;
default:
break;
}
}
break;
}
}
}