--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -5365,19 +5365,17 @@ CanvasRenderingContext2D::DrawDirectlyTo
AdjustedTarget tempTarget(this, aBounds->IsEmpty() ? nullptr: aBounds);
if (!tempTarget) {
return;
}
// Get any existing transforms on the context, including transformations used
// for context shadow.
Matrix matrix = tempTarget->GetTransform();
- gfxMatrix contextMatrix;
- contextMatrix = gfxMatrix(matrix._11, matrix._12, matrix._21,
- matrix._22, matrix._31, matrix._32);
+ gfxMatrix contextMatrix = ThebesMatrix(matrix);
gfxSize contextScale(contextMatrix.ScaleFactors(true));
// Scale the dest rect to include the context scale.
aDest.Scale(contextScale.width, contextScale.height);
// Scale the image size to the dest rect, and adjust the source rect to match.
gfxSize scale(aDest.width / aSrc.width, aDest.height / aSrc.height);
IntSize scaledImageSize = IntSize::Ceil(aImgSize.width * scale.width,
@@ -5388,20 +5386,20 @@ CanvasRenderingContext2D::DrawDirectlyTo
// the matrix even though this is a temp gfxContext.
AutoRestoreTransform autoRestoreTransform(mTarget);
RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempTarget);
if (!context) {
gfxDevCrash(LogReason::InvalidContext) << "Canvas context problem";
return;
}
- context->SetMatrix(contextMatrix.
- PreScale(1.0 / contextScale.width,
- 1.0 / contextScale.height).
- PreTranslate(aDest.x - aSrc.x, aDest.y - aSrc.y));
+ context->SetMatrixDouble(contextMatrix.
+ PreScale(1.0 / contextScale.width,
+ 1.0 / contextScale.height).
+ PreTranslate(aDest.x - aSrc.x, aDest.y - aSrc.y));
// FLAG_CLAMP is added for increased performance, since we never tile here.
uint32_t modifiedFlags = aImage.mDrawingFlags | imgIContainer::FLAG_CLAMP;
CSSIntSize sz(scaledImageSize.width, scaledImageSize.height); // XXX hmm is scaledImageSize really in CSS pixels?
SVGImageContext svgContext(Some(sz));
auto result = aImage.mImgContainer->
@@ -5598,35 +5596,34 @@ CanvasRenderingContext2D::DrawWindow(nsG
}
}
if (op == CompositionOp::OP_OVER &&
(!mBufferProvider || mBufferProvider->GetType() != LayersBackend::LAYERS_CLIENT))
{
thebes = gfxContext::CreateOrNull(mTarget);
MOZ_ASSERT(thebes); // already checked the draw target above
// (in SupportsAzureContentForDrawTarget)
- thebes->SetMatrix(gfxMatrix(matrix._11, matrix._12, matrix._21,
- matrix._22, matrix._31, matrix._32));
+ thebes->SetMatrix(matrix);
} else {
IntSize dtSize = IntSize::Ceil(sw, sh);
if (!Factory::AllowedSurfaceSize(dtSize)) {
aError.Throw(NS_ERROR_FAILURE);
return;
}
drawDT =
gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(dtSize,
SurfaceFormat::B8G8R8A8);
if (!drawDT || !drawDT->IsValid()) {
aError.Throw(NS_ERROR_FAILURE);
return;
}
thebes = gfxContext::CreateOrNull(drawDT);
MOZ_ASSERT(thebes); // alrady checked the draw target above
- thebes->SetMatrix(gfxMatrix::Scaling(matrix._11, matrix._22));
+ thebes->SetMatrix(Matrix::Scaling(matrix._11, matrix._22));
}
nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
Unused << shell->RenderDocument(r, renderDocFlags, backgroundColor, thebes);
// If this canvas was contained in the drawn window, the pre-transaction callback
// may have returned its DT. If so, we must reacquire it here.
EnsureTarget(discardContent ? &drawRect : nullptr);
--- a/dom/canvas/DocumentRendererChild.cpp
+++ b/dom/canvas/DocumentRendererChild.cpp
@@ -90,15 +90,15 @@ DocumentRendererChild::RenderDocument(ns
4 * renderSize.width,
SurfaceFormat::B8G8R8A8);
if (!dt || !dt->IsValid()) {
gfxWarning() << "DocumentRendererChild::RenderDocument failed to Factory::CreateDrawTargetForData";
return false;
}
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(ctx); // already checked the draw target above
- ctx->SetMatrix(mozilla::gfx::ThebesMatrix(transform));
+ ctx->SetMatrix(transform);
nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
shell->RenderDocument(documentRect, renderFlags, bgColor, ctx);
return true;
}
--- a/dom/plugins/base/nsPluginInstanceOwner.cpp
+++ b/dom/plugins/base/nsPluginInstanceOwner.cpp
@@ -2639,18 +2639,18 @@ void nsPluginInstanceOwner::Paint(gfxCon
bool transparent;
mInstance->IsTransparent(&transparent);
if (!transparent)
rendererFlags |= Renderer::DRAW_IS_OPAQUE;
// Renderer::Draw() draws a rectangle with top-left at the aContext origin.
gfxContextAutoSaveRestore autoSR(aContext);
- aContext->SetMatrix(
- aContext->CurrentMatrix().PreTranslate(pluginRect.TopLeft()));
+ aContext->SetMatrixDouble(
+ aContext->CurrentMatrixDouble().PreTranslate(pluginRect.TopLeft()));
Renderer renderer(window, this, pluginSize, pluginDirtyRect);
Display* dpy = mozilla::DefaultXDisplay();
Screen* screen = DefaultScreenOfDisplay(dpy);
Visual* visual = DefaultVisualOfScreen(screen);
renderer.Draw(aContext, nsIntSize(window->width, window->height),
--- a/gfx/layers/basic/BasicDisplayItemLayer.cpp
+++ b/gfx/layers/basic/BasicDisplayItemLayer.cpp
@@ -55,17 +55,17 @@ public:
{
if (IsHidden() || !mItem || !mBuilder) {
return;
}
AutoRestoreTransform autoRestoreTransform(aDT);
Matrix transform = aDT->GetTransform();
RefPtr<gfxContext> context = gfxContext::CreateOrNull(aDT, aDeviceOffset);
- context->SetMatrix(ThebesMatrix(transform));
+ context->SetMatrix(transform);
mItem->Paint(mBuilder, context);
}
protected:
BasicLayerManager* BasicManager()
{
return static_cast<BasicLayerManager*>(mManager);
--- a/gfx/layers/basic/BasicLayerManager.cpp
+++ b/gfx/layers/basic/BasicLayerManager.cpp
@@ -62,18 +62,18 @@ using namespace mozilla::gfx;
*/
static bool
ClipToContain(gfxContext* aContext, const IntRect& aRect)
{
gfxRect userRect(aRect.x, aRect.y, aRect.Width(), aRect.Height());
gfxRect deviceRect = aContext->UserToDevice(userRect);
deviceRect.RoundOut();
- gfxMatrix currentMatrix = aContext->CurrentMatrix();
- aContext->SetMatrix(gfxMatrix());
+ Matrix currentMatrix = aContext->CurrentMatrix();
+ aContext->SetMatrix(Matrix());
aContext->NewPath();
aContext->Rectangle(deviceRect);
aContext->Clip();
aContext->SetMatrix(currentMatrix);
return aContext->DeviceToUser(deviceRect).IsEqualInterior(userRect);
}
@@ -125,17 +125,17 @@ BasicLayerManager::PushGroupForLayer(gfx
Matrix maskTransform;
RefPtr<SourceSurface> maskSurf = GetMaskForLayer(aLayer, &maskTransform);
if (maskSurf) {
// The returned transform will transform the mask to device space on the
// destination. Since the User->Device space transform will be applied
// to the mask by PopGroupAndBlend we need to adjust the transform to
// transform the mask to user space.
- Matrix currentTransform = ToMatrix(aGroupResult.mFinalTarget->CurrentMatrix());
+ Matrix currentTransform = aGroupResult.mFinalTarget->CurrentMatrix();
currentTransform.Invert();
maskTransform = maskTransform * currentTransform;
}
if (aLayer->CanUseOpaqueSurface() &&
((didCompleteClip && aRegion.GetNumRects() == 1) ||
!aContext->CurrentMatrix().HasNonIntegerTranslation())) {
// If the layer is opaque in its visible region we can push a gfxContentType::COLOR
@@ -244,17 +244,17 @@ public:
// Will return an identity matrix for 3d transforms.
return mLayer->GetEffectiveTransformForBuffer().CanDraw2D(&mTransform);
}
// Applies the effective transform if it's 2D. If it's a 3D transform then
// it applies an identity.
void Apply2DTransform()
{
- mTarget->SetMatrix(ThebesMatrix(mTransform));
+ mTarget->SetMatrix(mTransform);
}
// Set the opaque rect to match the bounds of the visible region.
void AnnotateOpaqueRect()
{
const nsIntRegion visibleRegion = mLayer->GetLocalVisibleRegion().ToUnknownRegion();
const IntRect& bounds = visibleRegion.GetBounds();
@@ -586,17 +586,17 @@ BasicLayerManager::EndTransactionInterna
// Need to do this before we call ApplyDoubleBuffering,
// which depends on correct effective transforms
if (mTarget) {
mSnapEffectiveTransforms =
!mTarget->GetDrawTarget()->GetUserData(&sDisablePixelSnapping);
} else {
mSnapEffectiveTransforms = true;
}
- mRoot->ComputeEffectiveTransforms(mTarget ? Matrix4x4::From2D(ToMatrix(mTarget->CurrentMatrix())) : Matrix4x4());
+ mRoot->ComputeEffectiveTransforms(mTarget ? Matrix4x4::From2D(mTarget->CurrentMatrix()) : Matrix4x4());
ToData(mRoot)->Validate(aCallback, aCallbackData, nullptr);
if (mRoot->GetMaskLayer()) {
ToData(mRoot->GetMaskLayer())->Validate(aCallback, aCallbackData, nullptr);
}
}
if (mTarget && mRoot &&
@@ -783,19 +783,19 @@ InstallLayerClipPreserves3D(gfxContext*
Matrix4x4 transform3d =
parent && parent->Extend3DContext() ?
parent->GetEffectiveTransform() :
Matrix4x4();
Matrix transform;
if (!transform3d.CanDraw2D(&transform)) {
gfxDevCrash(LogReason::CannotDraw3D) << "GFX: We should not have a 3D transform that CanDraw2D() is false!";
}
- gfxMatrix oldTransform = aTarget->CurrentMatrix();
- transform *= ToMatrix(oldTransform);
- aTarget->SetMatrix(ThebesMatrix(transform));
+ Matrix oldTransform = aTarget->CurrentMatrix();
+ transform *= oldTransform;
+ aTarget->SetMatrix(transform);
aTarget->NewPath();
aTarget->SnappedRectangle(gfxRect(clipRect->x, clipRect->y,
clipRect->Width(), clipRect->Height()));
aTarget->Clip();
aTarget->SetMatrix(oldTransform);
}
--- a/gfx/layers/basic/BasicLayersImpl.cpp
+++ b/gfx/layers/basic/BasicLayersImpl.cpp
@@ -59,17 +59,17 @@ GetMaskForLayer(Layer* aLayer, Matrix* a
return nullptr;
}
void
PaintWithMask(gfxContext* aContext, float aOpacity, Layer* aMaskLayer)
{
AutoMoz2DMaskData mask;
if (GetMaskData(aMaskLayer, Point(), &mask)) {
- aContext->SetMatrix(ThebesMatrix(mask.GetTransform()));
+ aContext->SetMatrix(mask.GetTransform());
aContext->Mask(mask.GetSurface(), aOpacity);
return;
}
// if there is no mask, just paint normally
aContext->Paint(aOpacity);
}
--- a/gfx/layers/client/TiledContentClient.cpp
+++ b/gfx/layers/client/TiledContentClient.cpp
@@ -986,17 +986,17 @@ void ClientMultiTiledLayerBuffer::Update
gfxDevCrash(LogReason::InvalidContext) << "Invalid tiled draw target";
return;
}
drawTarget->SetTransform(Matrix());
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(drawTarget);
MOZ_ASSERT(ctx); // already checked the draw target above
ctx->SetMatrix(
- ctx->CurrentMatrix().PreScale(mResolution, mResolution).PreTranslate(ThebesPoint(-mTilingOrigin)));
+ ctx->CurrentMatrix().PreScale(mResolution, mResolution).PreTranslate(-mTilingOrigin));
mCallback(&mPaintedLayer, ctx, paintRegion, dirtyRegion,
DrawRegionClip::DRAW, nsIntRegion(), mCallbackData);
mMoz2DTiles.clear();
// Reset:
mTilingOrigin = IntPoint(std::numeric_limits<int32_t>::max(),
std::numeric_limits<int32_t>::max());
}
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -421,17 +421,17 @@ nsDeviceContext::CreateRenderingContextC
transform.PreTranslate(gfxPoint(0, size.width));
gfxMatrix rotate(0, -1,
1, 0,
0, 0);
transform = rotate * transform;
}
transform.PreScale(mPrintingScale, mPrintingScale);
- pContext->SetMatrix(transform);
+ pContext->SetMatrixDouble(transform);
return pContext.forget();
}
nsresult
nsDeviceContext::GetDepth(uint32_t& aDepth)
{
nsCOMPtr<nsIScreen> screen;
FindScreen(getter_AddRefs(screen));
--- a/gfx/thebes/gfxBlur.cpp
+++ b/gfx/thebes/gfxBlur.cpp
@@ -47,17 +47,17 @@ gfxAlphaBoxBlur::Init(gfxContext* aDesti
dirtyRect.ptrOr(nullptr), skipRect.ptrOr(nullptr),
aUseHardwareAccel);
if (!dt) {
return nullptr;
}
RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(context); // already checked for target above
- context->SetMatrix(gfxMatrix::Translation(-mBlur.GetRect().TopLeft()));
+ context->SetMatrix(Matrix::Translation(-mBlur.GetRect().TopLeft()));
return context.forget();
}
already_AddRefed<DrawTarget>
gfxAlphaBoxBlur::InitDrawTarget(const DrawTarget* aReferenceDT,
const Rect& aRect,
const IntSize& aSpreadRadius,
const IntSize& aBlurRadius,
@@ -583,17 +583,17 @@ GetBlur(gfxContext* aDestinationCtx,
// We can get seams using the min size rect when drawing to the destination rect
// if we have a non-pixel aligned destination transformation. In those cases,
// fallback to just rendering the destination rect.
// During printing, we record all the Moz 2d commands and replay them on the parent side
// with Cairo. Cairo printing uses StretchDIBits to stretch the surface. However,
// since our source image is only 1px for some parts, we make thousands of calls.
// Instead just render the blur ourself here as one image and send it over for printing.
// TODO: May need to change this with the blob renderer in WR since it also records.
- Matrix destMatrix = ToMatrix(aDestinationCtx->CurrentMatrix());
+ Matrix destMatrix = aDestinationCtx->CurrentMatrix();
bool useDestRect = !destMatrix.IsRectilinear() || destMatrix.HasNonIntegerTranslation() ||
aDestinationCtx->GetDrawTarget()->IsRecording();
if (useDestRect) {
minSize = aRectSize;
}
aOutMinSize = minSize;
DrawTarget* destDT = aDestinationCtx->GetDrawTarget();
--- a/gfx/thebes/gfxContext.cpp
+++ b/gfx/thebes/gfxContext.cpp
@@ -107,17 +107,17 @@ gfxContext::CreatePreservingTransformOrN
{
if (!aTarget || !aTarget->IsValid()) {
gfxCriticalNote << "Invalid target in gfxContext::CreatePreservingTransformOrNull " << hexa(aTarget);
return nullptr;
}
Matrix transform = aTarget->GetTransform();
RefPtr<gfxContext> result = new gfxContext(aTarget);
- result->SetMatrix(ThebesMatrix(transform));
+ result->SetMatrix(transform);
return result.forget();
}
gfxContext::~gfxContext()
{
for (int i = mStateStack.Length() - 1; i >= 0; i--) {
for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {
mStateStack[i].drawTarget->PopClip();
@@ -313,26 +313,38 @@ gfxContext::Rectangle(const gfxRect& rec
void
gfxContext::Multiply(const gfxMatrix& matrix)
{
CURRENTSTATE_CHANGED()
ChangeTransform(ToMatrix(matrix) * mTransform);
}
void
-gfxContext::SetMatrix(const gfxMatrix& matrix)
+gfxContext::SetMatrix(const gfx::Matrix& matrix)
{
CURRENTSTATE_CHANGED()
- ChangeTransform(ToMatrix(matrix));
+ ChangeTransform(matrix);
+}
+
+void
+gfxContext::SetMatrixDouble(const gfxMatrix& matrix)
+{
+ SetMatrix(ToMatrix(matrix));
+}
+
+gfx::Matrix
+gfxContext::CurrentMatrix() const
+{
+ return mTransform;
}
gfxMatrix
-gfxContext::CurrentMatrix() const
+gfxContext::CurrentMatrixDouble() const
{
- return ThebesMatrix(mTransform);
+ return ThebesMatrix(CurrentMatrix());
}
gfxPoint
gfxContext::DeviceToUser(const gfxPoint& point) const
{
return ThebesPoint(mTransform.Inverse().TransformPoint(ToPoint(point)));
}
--- a/gfx/thebes/gfxContext.h
+++ b/gfx/thebes/gfxContext.h
@@ -167,22 +167,24 @@ public:
* matrix's transformation will take place before the previously set
* transformations.
*/
void Multiply(const gfxMatrix& other);
/**
* Replaces the current transformation matrix with matrix.
*/
- void SetMatrix(const gfxMatrix& matrix);
+ void SetMatrix(const mozilla::gfx::Matrix& matrix);
+ void SetMatrixDouble(const gfxMatrix& matrix);
/**
* Returns the current transformation matrix.
*/
- gfxMatrix CurrentMatrix() const;
+ mozilla::gfx::Matrix CurrentMatrix() const;
+ gfxMatrix CurrentMatrixDouble() const;
/**
* Converts a point from device to user coordinates using the inverse
* transformation matrix.
*/
gfxPoint DeviceToUser(const gfxPoint& point) const;
/**
@@ -623,27 +625,27 @@ public:
void Restore()
{
if (mContext) {
mContext->SetMatrix(mMatrix);
mContext = nullptr;
}
}
- const gfxMatrix& Matrix()
+ const mozilla::gfx::Matrix& Matrix()
{
MOZ_ASSERT(mContext, "mMatrix doesn't contain a useful matrix");
return mMatrix;
}
bool HasMatrix() const { return !!mContext; }
private:
gfxContext *mContext;
- gfxMatrix mMatrix;
+ mozilla::gfx::Matrix mMatrix;
};
class DrawTargetAutoDisableSubpixelAntialiasing {
public:
typedef mozilla::gfx::DrawTarget DrawTarget;
DrawTargetAutoDisableSubpixelAntialiasing(DrawTarget *aDT, bool aDisable)
--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -1674,17 +1674,17 @@ private:
Pattern *pat;
RefPtr<gfxPattern> fillPattern;
if (mFontParams.contextPaint) {
imgDrawingParams imgParams;
fillPattern =
mFontParams.contextPaint->GetFillPattern(
mRunParams.context->GetDrawTarget(),
- mRunParams.context->CurrentMatrix(),
+ mRunParams.context->CurrentMatrixDouble(),
imgParams);
}
if (!fillPattern) {
if (state.pattern) {
RefPtr<gfxPattern> statePattern =
mRunParams.context->CurrentState().pattern;
pat = statePattern->GetPattern(mRunParams.dt,
state.patternTransformChanged ?
@@ -2158,17 +2158,17 @@ gfxFont::Draw(const gfxTextRun *aTextRun
const Metrics& metrics = GetMetrics(eHorizontal);
// Get a matrix we can use to draw the (horizontally-shaped) textrun
// with 90-degree CW rotation.
const gfxFloat
rotation = (aOrientation ==
gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT)
? -M_PI / 2.0 : M_PI / 2.0;
gfxMatrix mat =
- aRunParams.context->CurrentMatrix().
+ aRunParams.context->CurrentMatrixDouble().
PreTranslate(p). // translate origin for rotation
PreRotate(rotation). // turn 90deg CCW (sideways-left) or CW (*-right)
PreTranslate(-p); // undo the translation
// If we're drawing rotated horizontal text for an element styled
// text-orientation:mixed, the dominant baseline will be vertical-
// centered. So in this case, we need to adjust the position so that
// the rotated horizontal text (which uses an alphabetic baseline) will
@@ -2177,28 +2177,28 @@ gfxFont::Draw(const gfxTextRun *aTextRun
// should eventually look for baseline tables[1] in the fonts and use
// those if available.
// [1] See http://www.microsoft.com/typography/otspec/base.htm
if (aTextRun->UseCenterBaseline()) {
gfxPoint baseAdj(0, (metrics.emAscent - metrics.emDescent) / 2);
mat.PreTranslate(baseAdj);
}
- aRunParams.context->SetMatrix(mat);
+ aRunParams.context->SetMatrixDouble(mat);
}
RefPtr<SVGContextPaint> contextPaint;
if (fontParams.haveSVGGlyphs && !fontParams.contextPaint) {
// If no pattern is specified for fill, use the current pattern
NS_ASSERTION((int(aRunParams.drawMode) & int(DrawMode::GLYPH_STROKE)) == 0,
"no pattern supplied for stroking text");
RefPtr<gfxPattern> fillPattern = aRunParams.context->GetPattern();
contextPaint =
new SimpleTextContextPaint(fillPattern, nullptr,
- aRunParams.context->CurrentMatrix());
+ aRunParams.context->CurrentMatrixDouble());
fontParams.contextPaint = contextPaint.get();
}
// Synthetic-bold strikes are each offset one device pixel in run direction.
// (these values are only needed if IsSyntheticBold() is true)
if (IsSyntheticBold()) {
gfx::Float xscale = CalcXScale(aRunParams.context->GetDrawTarget());
fontParams.synBoldOnePixelOffset = aRunParams.direction * xscale;
--- a/gfx/thebes/gfxUtils.cpp
+++ b/gfx/thebes/gfxUtils.cpp
@@ -433,41 +433,41 @@ PrescaleAndTileDrawable(gfxDrawable* aDr
gfxContext* aContext,
const ImageRegion& aRegion,
Rect aImageRect,
const SamplingFilter aSamplingFilter,
const SurfaceFormat aFormat,
gfxFloat aOpacity,
ExtendMode aExtendMode)
{
- gfxSize scaleFactor = aContext->CurrentMatrix().ScaleFactors(true);
- gfxMatrix scaleMatrix = gfxMatrix::Scaling(scaleFactor.width, scaleFactor.height);
+ Size scaleFactor = aContext->CurrentMatrix().ScaleFactors(true);
+ Matrix scaleMatrix = Matrix::Scaling(scaleFactor.width, scaleFactor.height);
const float fuzzFactor = 0.01;
// If we aren't scaling or translating, don't go down this path
if ((FuzzyEqual(scaleFactor.width, 1.0, fuzzFactor) &&
FuzzyEqual(scaleFactor.width, 1.0, fuzzFactor)) ||
aContext->CurrentMatrix().HasNonAxisAlignedTransform()) {
return false;
}
gfxRect clipExtents = aContext->GetClipExtents();
// Inflate by one pixel because bilinear filtering will sample at most
// one pixel beyond the computed image pixel coordinate.
clipExtents.Inflate(1.0);
gfxRect needed = aRegion.IntersectAndRestrict(clipExtents);
- Rect scaledNeededRect = ToMatrix(scaleMatrix).TransformBounds(ToRect(needed));
+ Rect scaledNeededRect = scaleMatrix.TransformBounds(ToRect(needed));
scaledNeededRect.RoundOut();
if (scaledNeededRect.IsEmpty()) {
return false;
}
- Rect scaledImageRect = ToMatrix(scaleMatrix).TransformBounds(aImageRect);
+ Rect scaledImageRect = scaleMatrix.TransformBounds(aImageRect);
if (!ShouldUseTempSurface(scaledImageRect, scaledNeededRect)) {
return false;
}
IntSize scaledImageSize((int32_t)scaledImageRect.width,
(int32_t)scaledImageRect.height);
if (scaledImageSize.width != scaledImageRect.width ||
scaledImageSize.height != scaledImageRect.height) {
@@ -480,32 +480,32 @@ PrescaleAndTileDrawable(gfxDrawable* aDr
gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(scaledImageSize, aFormat);
if (!scaledDT || !scaledDT->IsValid()) {
return false;
}
RefPtr<gfxContext> tmpCtx = gfxContext::CreateOrNull(scaledDT);
MOZ_ASSERT(tmpCtx); // already checked the target above
- scaledDT->SetTransform(ToMatrix(scaleMatrix));
+ scaledDT->SetTransform(scaleMatrix);
gfxRect gfxImageRect(aImageRect.x, aImageRect.y, aImageRect.width, aImageRect.height);
// Since this is just the scaled image, we don't want to repeat anything yet.
aDrawable->Draw(tmpCtx, gfxImageRect, ExtendMode::CLAMP, aSamplingFilter, 1.0, gfxMatrix());
RefPtr<SourceSurface> scaledImage = scaledDT->Snapshot();
{
gfxContextMatrixAutoSaveRestore autoSR(aContext);
- Matrix withoutScale = ToMatrix(aContext->CurrentMatrix());
+ Matrix withoutScale = aContext->CurrentMatrix();
DrawTarget* destDrawTarget = aContext->GetDrawTarget();
// The translation still is in scaled units
withoutScale.PreScale(1.0 / scaleFactor.width, 1.0 / scaleFactor.height);
- aContext->SetMatrix(ThebesMatrix(withoutScale));
+ aContext->SetMatrix(withoutScale);
DrawOptions drawOptions(aOpacity, aContext->CurrentOp(),
aContext->CurrentAntialiasMode());
SurfacePattern scaledImagePattern(scaledImage, aExtendMode,
Matrix(), aSamplingFilter);
destDrawTarget->FillRect(scaledNeededRect, scaledImagePattern, drawOptions);
}
--- a/gfx/thebes/gfxWindowsNativeDrawing.cpp
+++ b/gfx/thebes/gfxWindowsNativeDrawing.cpp
@@ -63,17 +63,17 @@ gfxWindowsNativeDrawing::BeginNativeDraw
surf = gfxASurface::Wrap(s);
}
}
}
if (surf && surf->CairoStatus() != 0)
return nullptr;
- gfxMatrix m = mContext->CurrentMatrix();
+ gfxMatrix m = mContext->CurrentMatrixDouble();
if (!m.HasNonTranslation())
mTransformType = TRANSLATION_ONLY;
else if (m.HasNonAxisAlignedTransform())
mTransformType = COMPLEX;
else
mTransformType = AXIS_ALIGNED_SCALE;
// if this is a native win32 surface, we don't have to
--- a/gfx/thebes/gfxXlibNativeRenderer.cpp
+++ b/gfx/thebes/gfxXlibNativeRenderer.cpp
@@ -462,17 +462,17 @@ CopyXlibSurfaceToImage(cairo_surface_t *
return result.forget();
}
void
gfxXlibNativeRenderer::Draw(gfxContext* ctx, IntSize size,
uint32_t flags, Screen *screen, Visual *visual)
{
- gfxMatrix matrix = ctx->CurrentMatrix();
+ Matrix matrix = ctx->CurrentMatrix();
// We can only draw direct or onto a copied background if pixels align and
// native drawing is compatible with the current operator. (The matrix is
// actually also pixel-exact for flips and right-angle rotations, which
// would permit copying the background but not drawing direct.)
bool matrixIsIntegerTranslation = !matrix.HasNonIntegerTranslation();
bool canDrawOverBackground = matrixIsIntegerTranslation &&
ctx->CurrentOp() == CompositionOp::OP_OVER;
--- a/image/VectorImage.cpp
+++ b/image/VectorImage.cpp
@@ -297,20 +297,20 @@ SVGDrawingCallback::operator()(gfxContex
aContext->NewPath();
aContext->Rectangle(aFillRect);
aContext->Clip();
gfxMatrix matrix = aTransform;
if (!matrix.Invert()) {
return false;
}
- aContext->SetMatrix(
- aContext->CurrentMatrix().PreMultiply(matrix).
- PreScale(double(mSize.width) / mViewportSize.width,
- double(mSize.height) / mViewportSize.height));
+ aContext->SetMatrixDouble(
+ aContext->CurrentMatrixDouble().PreMultiply(matrix).
+ PreScale(double(mSize.width) / mViewportSize.width,
+ double(mSize.height) / mViewportSize.height));
nsPresContext* presContext = presShell->GetPresContext();
MOZ_ASSERT(presContext, "pres shell w/out pres context");
nsRect svgRect(0, 0,
presContext->DevPixelsToAppUnits(mViewportSize.width),
presContext->DevPixelsToAppUnits(mViewportSize.height));
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -4680,20 +4680,20 @@ PresShell::RenderDocument(const nsRect&
gfxPoint offset(-nsPresContext::AppUnitsToFloatCSSPixels(aRect.x),
-nsPresContext::AppUnitsToFloatCSSPixels(aRect.y));
gfxFloat scale = gfxFloat(devCtx->AppUnitsPerDevPixel())/nsPresContext::AppUnitsPerCSSPixel();
// Since canvas APIs use floats to set up their matrices, we may have some
// slight rounding errors here. We use NudgeToIntegers() here to adjust
// matrix components that are integers up to the accuracy of floats to be
// those integers.
- gfxMatrix newTM = aThebesContext->CurrentMatrix().PreTranslate(offset).
- PreScale(scale, scale).
- NudgeToIntegers();
- aThebesContext->SetMatrix(newTM);
+ gfxMatrix newTM = aThebesContext->CurrentMatrixDouble().PreTranslate(offset).
+ PreScale(scale, scale).
+ NudgeToIntegers();
+ aThebesContext->SetMatrixDouble(newTM);
AutoSaveRestoreRenderingState _(this);
bool wouldFlushRetainedLayers = false;
PaintFrameFlags flags = PaintFrameFlags::PAINT_IGNORE_SUPPRESSION;
if (aThebesContext->CurrentMatrix().HasNonIntegerTranslation()) {
flags |= PaintFrameFlags::PAINT_IN_TRANSFORM;
}
@@ -5083,17 +5083,17 @@ PresShell::PaintRangePaintInfo(const nsT
builder->LineTo(rect.BottomLeft());
builder->LineTo(rect.TopLeft());
}
RefPtr<Path> path = builder->Finish();
ctx->Clip(path);
}
- gfxMatrix initialTM = ctx->CurrentMatrix();
+ gfxMatrix initialTM = ctx->CurrentMatrixDouble();
if (resize)
initialTM.PreScale(scale, scale);
// translate so that points are relative to the surface area
gfxPoint surfaceOffset =
nsLayoutUtils::PointToGfxPoint(-aArea.TopLeft(), pc->AppUnitsPerDevPixel());
initialTM.PreTranslate(surfaceOffset);
@@ -5113,17 +5113,17 @@ PresShell::PaintRangePaintInfo(const nsT
// next, paint each range in the selection
for (const UniquePtr<RangePaintInfo>& rangeInfo : aItems) {
// the display lists paint relative to the offset from the reference
// frame, so account for that translation too:
gfxPoint rootOffset =
nsLayoutUtils::PointToGfxPoint(rangeInfo->mRootOffset,
pc->AppUnitsPerDevPixel());
- ctx->SetMatrix(gfxMatrix(initialTM).PreTranslate(rootOffset));
+ ctx->SetMatrixDouble(initialTM.PreTranslate(rootOffset));
aArea.MoveBy(-rangeInfo->mRootOffset.x, -rangeInfo->mRootOffset.y);
nsRegion visible(aArea);
RefPtr<LayerManager> layerManager =
rangeInfo->mList.PaintRoot(&rangeInfo->mBuilder, ctx,
nsDisplayList::PAINT_DEFAULT);
aArea.MoveBy(rangeInfo->mRootOffset.x, rangeInfo->mRootOffset.y);
}
@@ -10139,18 +10139,18 @@ void ReflowCountMgr::PaintCount(const ch
(IndiReflowCounter *)PL_HashTableLookup(mIndiFrameCounts, key);
if (counter != nullptr && counter->mName.EqualsASCII(aName)) {
DrawTarget* drawTarget = aRenderingContext->GetDrawTarget();
int32_t appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();
aRenderingContext->Save();
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(aOffset, appUnitsPerDevPixel);
- aRenderingContext->SetMatrix(
- aRenderingContext->CurrentMatrix().PreTranslate(devPixelOffset));
+ aRenderingContext->SetMatrixDouble(
+ aRenderingContext->CurrentMatrixDouble().PreTranslate(devPixelOffset));
// We don't care about the document language or user fonts here;
// just get a default Latin font.
nsFont font(eFamily_serif, nsPresContext::CSSPixelsToAppUnits(11));
nsFontMetrics::Params params;
params.language = nsGkAtoms::x_western;
params.textPerf = aPresContext->GetTextPerfMetrics();
RefPtr<nsFontMetrics> fm =
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -3723,18 +3723,18 @@ nsLayoutUtils::PaintFrame(gfxContext* aR
// Make visibleRegion and aRenderingContext relative to the
// scrolled frame instead of the root frame.
nsPoint pos = rootScrollableFrame->GetScrollPosition();
visibleRegion.MoveBy(-pos);
if (aRenderingContext) {
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(pos,
presContext->AppUnitsPerDevPixel());
- aRenderingContext->SetMatrix(
- aRenderingContext->CurrentMatrix().PreTranslate(devPixelOffset));
+ aRenderingContext->SetMatrixDouble(
+ aRenderingContext->CurrentMatrixDouble().PreTranslate(devPixelOffset));
}
}
builder.SetIgnoreScrollFrame(rootScrollFrame);
nsCanvasFrame* canvasFrame =
do_QueryFrame(rootScrollableFrame->GetScrolledFrame());
if (canvasFrame) {
// Use UnionRect here to ensure that areas where the scrollbars
@@ -6669,17 +6669,17 @@ ComputeSnappedImageDrawingParameters(gfx
gfxRect devPixelDest =
nsLayoutUtils::RectToGfxRect(appUnitDest, aAppUnitsPerDevPixel);
gfxRect devPixelFill =
nsLayoutUtils::RectToGfxRect(aFill, aAppUnitsPerDevPixel);
gfxRect devPixelDirty =
nsLayoutUtils::RectToGfxRect(aDirty, aAppUnitsPerDevPixel);
- gfxMatrix currentMatrix = aCtx->CurrentMatrix();
+ gfxMatrix currentMatrix = aCtx->CurrentMatrixDouble();
gfxRect fill = devPixelFill;
gfxRect dest = devPixelDest;
bool didSnap;
// Snap even if we have a scale in the context. But don't snap if
// we have something that's not translation+scale, or if the scale flips in
// the X or Y direction, because snapped image drawing can't handle that yet.
if (!currentMatrix.HasNonAxisAlignedTransform() &&
currentMatrix._11 > 0.0 && currentMatrix._22 > 0.0 &&
@@ -6896,17 +6896,17 @@ DrawImageInternal(gfxContext&
if (!params.shouldDraw) {
return result;
}
{
gfxContextMatrixAutoSaveRestore contextMatrixRestorer(&aContext);
- aContext.SetMatrix(params.imageSpaceToDeviceSpace);
+ aContext.SetMatrixDouble(params.imageSpaceToDeviceSpace);
Maybe<SVGImageContext> fallbackContext;
if (!aSVGContext) {
// Use the default viewport.
fallbackContext.emplace(Some(params.svgViewportSize));
}
result = aImage->Draw(&aContext, params.size, params.region,
--- a/layout/generic/nsPluginFrame.cpp
+++ b/layout/generic/nsPluginFrame.cpp
@@ -866,17 +866,17 @@ nsPluginFrame::PaintPrintPlugin(nsIFrame
const nsRect& aDirtyRect, nsPoint aPt)
{
// Translate the context:
nsPoint pt = aPt + aFrame->GetContentRectRelativeToSelf().TopLeft();
gfxPoint devPixelPt =
nsLayoutUtils::PointToGfxPoint(pt, aFrame->PresContext()->AppUnitsPerDevPixel());
gfxContextMatrixAutoSaveRestore autoSR(aCtx);
- aCtx->SetMatrix(aCtx->CurrentMatrix().PreTranslate(devPixelPt));
+ aCtx->SetMatrixDouble(aCtx->CurrentMatrixDouble().PreTranslate(devPixelPt));
// FIXME - Bug 385435: Doesn't aDirtyRect need translating too?
static_cast<nsPluginFrame*>(aFrame)->PrintPlugin(*aCtx, aDirtyRect);
}
/**
* nsDisplayPluginReadback creates an active ReadbackLayer. The ReadbackLayer
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -5185,19 +5185,19 @@ nsDisplayText::RenderToContext(gfxContex
if (f->StyleContext()->IsTextCombined()) {
float scaleFactor = GetTextCombineScaleFactor(f);
if (scaleFactor != 1.0f) {
matrixSR.SetContext(aCtx);
// Setup matrix to compress text for text-combine-upright if
// necessary. This is done here because we want selection be
// compressed at the same time as text.
gfxPoint pt = nsLayoutUtils::PointToGfxPoint(framePt, A2D);
- gfxMatrix mat = aCtx->CurrentMatrix()
+ gfxMatrix mat = aCtx->CurrentMatrixDouble()
.PreTranslate(pt).PreScale(scaleFactor, 1.0).PreTranslate(-pt);
- aCtx->SetMatrix (mat);
+ aCtx->SetMatrixDouble(mat);
}
}
nsTextFrame::PaintTextParams params(aCtx);
params.framePt = gfx::Point(framePt.x, framePt.y);
params.dirtyRect = extraVisible;
if (aBuilder->IsForGenerateGlyphMask()) {
MOZ_ASSERT(!aBuilder->IsForPaintingSelectionBG());
@@ -7235,20 +7235,20 @@ nsTextFrame::DrawTextRunAndDecorations(R
// The matrix of the context may have been altered for text-combine-
// upright. However, we want to draw decoration lines unscaled, thus
// we need to revert the scaling here.
gfxContextMatrixAutoSaveRestore scaledRestorer;
if (StyleContext()->IsTextCombined()) {
float scaleFactor = GetTextCombineScaleFactor(this);
if (scaleFactor != 1.0f) {
scaledRestorer.SetContext(aParams.context);
- gfxMatrix unscaled = aParams.context->CurrentMatrix();
+ gfxMatrix unscaled = aParams.context->CurrentMatrixDouble();
gfxPoint pt(x / app, y / app);
unscaled.PreTranslate(pt).PreScale(1.0f / scaleFactor, 1.0f).PreTranslate(-pt);
- aParams.context->SetMatrix(unscaled);
+ aParams.context->SetMatrixDouble(unscaled);
}
}
typedef gfxFont::Metrics Metrics;
auto paintDecorationLine = [&](const LineDecoration& dec,
gfxFloat Metrics::* lineSize,
gfxFloat Metrics::* lineOffset) {
if (dec.mStyle == NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
--- a/layout/mathml/nsMathMLChar.cpp
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -2020,26 +2020,26 @@ nsMathMLChar::ApplyTransforms(gfxContext
int32_t aAppUnitsPerGfxUnit,
nsRect &r)
{
// apply the transforms
if (mMirrored) {
nsPoint pt = r.TopRight();
gfxPoint devPixelOffset(NSAppUnitsToFloatPixels(pt.x, aAppUnitsPerGfxUnit),
NSAppUnitsToFloatPixels(pt.y, aAppUnitsPerGfxUnit));
- aThebesContext->SetMatrix(
- aThebesContext->CurrentMatrix().PreTranslate(devPixelOffset).
- PreScale(-mScaleX, mScaleY));
+ aThebesContext->SetMatrixDouble(
+ aThebesContext->CurrentMatrixDouble().PreTranslate(devPixelOffset).
+ PreScale(-mScaleX, mScaleY));
} else {
nsPoint pt = r.TopLeft();
gfxPoint devPixelOffset(NSAppUnitsToFloatPixels(pt.x, aAppUnitsPerGfxUnit),
NSAppUnitsToFloatPixels(pt.y, aAppUnitsPerGfxUnit));
- aThebesContext->SetMatrix(
- aThebesContext->CurrentMatrix().PreTranslate(devPixelOffset).
- PreScale(mScaleX, mScaleY));
+ aThebesContext->SetMatrixDouble(
+ aThebesContext->CurrentMatrixDouble().PreTranslate(devPixelOffset).
+ PreScale(mScaleX, mScaleY));
}
// update the bounding rectangle.
r.x = r.y = 0;
r.width /= mScaleX;
r.height /= mScaleY;
}
--- a/layout/painting/FrameLayerBuilder.cpp
+++ b/layout/painting/FrameLayerBuilder.cpp
@@ -3679,18 +3679,18 @@ PaintInactiveLayer(nsDisplayListBuilder*
SurfaceFormat::B8G8R8A8);
if (tempDT) {
context = gfxContext::CreateOrNull(tempDT);
if (!context) {
// Leave this as crash, it's in the debugging code, we want to know
gfxDevCrash(LogReason::InvalidContext) << "PaintInactive context problem " << gfx::hexa(tempDT);
return;
}
- context->SetMatrix(gfxMatrix::Translation(-itemVisibleRect.x,
- -itemVisibleRect.y));
+ context->SetMatrix(Matrix::Translation(-itemVisibleRect.x,
+ -itemVisibleRect.y));
}
}
#endif
basic->BeginTransaction();
basic->SetTarget(context);
if (aItem->GetType() == DisplayItemType::TYPE_MASK) {
static_cast<nsDisplayMask*>(aItem)->PaintAsLayer(aBuilder, aCtx, basic);
@@ -3909,17 +3909,17 @@ ContainerState::SetupMaskLayerForCSSMask
MaskImageData imageData(surfaceSize, mManager);
RefPtr<DrawTarget> dt = imageData.CreateDrawTarget();
if (!dt || !dt->IsValid()) {
NS_WARNING("Could not create DrawTarget for mask layer.");
return;
}
RefPtr<gfxContext> maskCtx = gfxContext::CreateOrNull(dt);
- maskCtx->SetMatrix(gfxMatrix::Translation(-itemRect.TopLeft()));
+ maskCtx->SetMatrix(Matrix::Translation(-itemRect.TopLeft()));
maskCtx->Multiply(gfxMatrix::Scaling(mParameters.mXScale, mParameters.mYScale));
bool isPaintFinished = aMaskItem->PaintMask(mBuilder, maskCtx);
RefPtr<ImageContainer> imgContainer =
imageData.CreateImageAndImageContainer();
if (!imgContainer) {
return;
@@ -5884,17 +5884,17 @@ static void DebugPaintItem(DrawTarget& a
aDrawTarget.CreateSimilarDrawTarget(IntSize::Truncate(bounds.width, bounds.height),
SurfaceFormat::B8G8R8A8);
RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempDT);
if (!context) {
// Leave this as crash, it's in the debugging code, we want to know
gfxDevCrash(LogReason::InvalidContext) << "DebugPaintItem context problem " << gfx::hexa(tempDT);
return;
}
- context->SetMatrix(gfxMatrix::Translation(-bounds.x, -bounds.y));
+ context->SetMatrix(Matrix::Translation(-bounds.x, -bounds.y));
aItem->Paint(aBuilder, context);
RefPtr<SourceSurface> surface = tempDT->Snapshot();
DumpPaintedImage(aItem, surface);
aDrawTarget.DrawSurface(surface, bounds, Rect(Point(0,0), bounds.Size()));
aItem->SetPainted();
@@ -6172,35 +6172,35 @@ FrameLayerBuilder::DrawPaintedLayer(Pain
aContext->Clip();
DrawForcedBackgroundColor(aDrawTarget, iterRect,
userData->mForcedBackgroundColor);
// Apply the residual transform if it has been enabled, to ensure that
// snapping when we draw into aContext exactly matches the ideal transform.
// See above for why this is OK.
- aContext->SetMatrix(
- aContext->CurrentMatrix().PreTranslate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
- PreScale(userData->mXScale, userData->mYScale));
+ aContext->SetMatrixDouble(
+ aContext->CurrentMatrixDouble().PreTranslate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
+ PreScale(userData->mXScale, userData->mYScale));
layerBuilder->PaintItems(entry->mItems, iterRect, aContext,
builder, presContext,
offset, userData->mXScale, userData->mYScale,
entry->mCommonClipCount);
if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
aLayer->Manager()->AddPaintedPixelCount(iterRect.Area());
}
}
} else {
// Apply the residual transform if it has been enabled, to ensure that
// snapping when we draw into aContext exactly matches the ideal transform.
// See above for why this is OK.
- aContext->SetMatrix(
- aContext->CurrentMatrix().PreTranslate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
- PreScale(userData->mXScale,userData->mYScale));
+ aContext->SetMatrixDouble(
+ aContext->CurrentMatrixDouble().PreTranslate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
+ PreScale(userData->mXScale,userData->mYScale));
layerBuilder->PaintItems(entry->mItems, aRegionToDraw.GetBounds(), aContext,
builder, presContext,
offset, userData->mXScale, userData->mYScale,
entry->mCommonClipCount);
if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
aLayer->Manager()->AddPaintedPixelCount(
aRegionToDraw.GetBounds().Area());
--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -1680,18 +1680,18 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
// We assume that the native theme is going to paint over the shadow.
// Draw the widget shape
gfxContextMatrixAutoSaveRestore save(shadowContext);
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(nsPoint(shadowItem->mXOffset,
shadowItem->mYOffset),
aPresContext->AppUnitsPerDevPixel());
- shadowContext->SetMatrix(
- shadowContext->CurrentMatrix().PreTranslate(devPixelOffset));
+ shadowContext->SetMatrixDouble(
+ shadowContext->CurrentMatrixDouble().PreTranslate(devPixelOffset));
nsRect nativeRect = aDirtyRect;
nativeRect.MoveBy(-nsPoint(shadowItem->mXOffset, shadowItem->mYOffset));
nativeRect.IntersectRect(frameRect, nativeRect);
aPresContext->GetTheme()->DrawWidgetBackground(shadowContext, aForFrame,
styleDisplay->mAppearance, aFrameArea, nativeRect);
blurringArea.DoPaint();
@@ -4474,17 +4474,17 @@ nsContextBoxBlur::Init(const nsRect& aRe
// Convert from app units to device pixels
gfxRect rect = nsLayoutUtils::RectToGfxRect(aRect, aAppUnitsPerDevPixel);
gfxRect dirtyRect =
nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel);
dirtyRect.RoundOut();
- gfxMatrix transform = aDestinationCtx->CurrentMatrix();
+ gfxMatrix transform = aDestinationCtx->CurrentMatrixDouble();
rect = transform.TransformBounds(rect);
mPreTransformed = !transform.IsIdentity();
// Create the temporary surface for blurring
dirtyRect = transform.TransformBounds(dirtyRect);
bool useHardwareAccel = !(aFlags & DISABLE_HARDWARE_ACCELERATION_BLUR);
if (aSkipRect) {
@@ -4511,17 +4511,17 @@ nsContextBoxBlur::DoPaint()
{
if (mContext == mDestinationCtx) {
return;
}
gfxContextMatrixAutoSaveRestore saveMatrix(mDestinationCtx);
if (mPreTransformed) {
- mDestinationCtx->SetMatrix(gfxMatrix());
+ mDestinationCtx->SetMatrix(Matrix());
}
mAlphaBoxBlur.Paint(mDestinationCtx);
}
gfxContext*
nsContextBoxBlur::GetContext()
{
@@ -4572,22 +4572,22 @@ nsContextBoxBlur::BlurRectangle(gfxConte
}
gfxFloat scaleX = 1;
gfxFloat scaleY = 1;
// Do blurs in device space when possible.
// Chrome/Skia always does the blurs in device space
// and will sometimes get incorrect results (e.g. rotated blurs)
- gfxMatrix transform = aDestinationCtx->CurrentMatrix();
+ gfxMatrix transform = aDestinationCtx->CurrentMatrixDouble();
// XXX: we could probably handle negative scales but for now it's easier just to fallback
if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && transform._22 > 0.0) {
scaleX = transform._11;
scaleY = transform._22;
- aDestinationCtx->SetMatrix(gfxMatrix());
+ aDestinationCtx->SetMatrix(Matrix());
} else {
transform = gfxMatrix();
}
gfxPoint blurStdDev = ComputeBlurStdDev(aBlurRadius, aAppUnitsPerDevPixel, scaleX, scaleY);
gfxRect dirtyRect =
nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel);
@@ -4672,23 +4672,23 @@ nsContextBoxBlur::InsetBoxBlur(gfxContex
GetBlurAndSpreadRadius(aDestinationCtx->GetDrawTarget(), aAppUnitsPerDevPixel,
aBlurRadiusAppUnits, aSpreadDistanceAppUnits,
blurRadius, spreadRadius, constrainSpreadRadius);
// The blur and spread radius are scaled already, so scale all
// input data to the blur. This way, we don't have to scale the min
// inset blur to the invert of the dest context, then rescale it back
// when we draw to the destination surface.
- gfxSize scale = aDestinationCtx->CurrentMatrix().ScaleFactors(true);
- Matrix transform = ToMatrix(aDestinationCtx->CurrentMatrix());
+ gfx::Size scale = aDestinationCtx->CurrentMatrix().ScaleFactors(true);
+ Matrix transform = aDestinationCtx->CurrentMatrix();
// XXX: we could probably handle negative scales but for now it's easier just to fallback
if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && transform._22 > 0.0) {
// If we don't have a rotation, we're pre-transforming all the rects.
- aDestinationCtx->SetMatrix(gfxMatrix());
+ aDestinationCtx->SetMatrix(Matrix());
} else {
// Don't touch anything, we have a rotation.
transform = Matrix();
}
Rect transformedDestRect = transform.TransformBounds(aDestinationRect);
Rect transformedShadowClipRect = transform.TransformBounds(aShadowClipRect);
Rect transformedSkipRect = transform.TransformBounds(aSkipRect);
--- a/layout/painting/nsCSSRenderingGradients.cpp
+++ b/layout/painting/nsCSSRenderingGradients.cpp
@@ -927,17 +927,17 @@ nsCSSGradientRenderer::Paint(gfxContext&
if (!dirty.IntersectRect(aDirtyRect, aFillArea))
return;
gfxRect areaToFill =
nsLayoutUtils::RectToGfxRect(aFillArea, appUnitsPerDevPixel);
gfxRect dirtyAreaToFill = nsLayoutUtils::RectToGfxRect(dirty, appUnitsPerDevPixel);
dirtyAreaToFill.RoundOut();
- gfxMatrix ctm = aContext.CurrentMatrix();
+ Matrix ctm = aContext.CurrentMatrix();
bool isCTMPreservingAxisAlignedRectangles = ctm.PreservesAxisAlignedRectangles();
// xStart/yStart are the top-left corner of the top-left tile.
nscoord xStart = FindTileStart(dirty.x, aDest.x, aRepeatSize.width);
nscoord yStart = FindTileStart(dirty.y, aDest.y, aRepeatSize.height);
nscoord xEnd = forceRepeatToCoverTiles ? xStart + aDest.width : dirty.XMost();
nscoord yEnd = forceRepeatToCoverTiles ? yStart + aDest.height : dirty.YMost();
@@ -970,32 +970,32 @@ nsCSSGradientRenderer::Paint(gfxContext&
continue;
}
// Set the context's transform to the transform that maps fillRect to
// snappedFillRect. The part of the gradient that was going to
// exactly fill fillRect will fill snappedFillRect instead.
gfxMatrix transform = gfxUtils::TransformRectToRect(fillRect,
snappedFillRectTopLeft, snappedFillRectTopRight,
snappedFillRectBottomRight);
- aContext.SetMatrix(transform);
+ aContext.SetMatrixDouble(transform);
}
aContext.NewPath();
aContext.Rectangle(fillRect);
gfxRect dirtyFillRect = fillRect.Intersect(dirtyAreaToFill);
gfxRect fillRectRelativeToTile = dirtyFillRect - tileRect.TopLeft();
Color edgeColor;
if (mGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR && !isRepeat &&
RectIsBeyondLinearGradientEdge(fillRectRelativeToTile, matrix, mStops,
gradientStart, gradientEnd, &edgeColor)) {
edgeColor.a *= aOpacity;
aContext.SetColor(edgeColor);
} else {
- aContext.SetMatrix(
- aContext.CurrentMatrix().Copy().PreTranslate(tileRect.TopLeft()));
+ aContext.SetMatrixDouble(
+ aContext.CurrentMatrixDouble().Copy().PreTranslate(tileRect.TopLeft()));
aContext.SetPattern(gradientPattern);
}
aContext.Fill();
aContext.SetMatrix(ctm);
}
}
}
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -766,17 +766,17 @@ GenerateAndPushTextMask(nsIFrame* aFrame
gfxContext* sourceCtx = aContext;
gfxRect bounds =
nsLayoutUtils::RectToGfxRect(aFillRect,
aFrame->PresContext()->AppUnitsPerDevPixel());
{
// Paint text selection background into sourceCtx.
gfxContextMatrixAutoSaveRestore save(sourceCtx);
- sourceCtx->SetMatrix(sourceCtx->CurrentMatrix().PreTranslate(bounds.TopLeft()));
+ sourceCtx->SetMatrixDouble(sourceCtx->CurrentMatrixDouble().PreTranslate(bounds.TopLeft()));
nsLayoutUtils::PaintFrame(aContext, aFrame,
nsRect(nsPoint(0, 0), aFrame->GetSize()),
NS_RGB(255, 255, 255),
nsDisplayListBuilderMode::PAINTING_SELECTION_BACKGROUND);
}
// Evaluate required surface size.
@@ -788,20 +788,20 @@ GenerateAndPushTextMask(nsIFrame* aFrame
RefPtr<DrawTarget> maskDT =
sourceTarget->CreateSimilarDrawTarget(drawRect.Size(),
SurfaceFormat::A8);
if (!maskDT || !maskDT->IsValid()) {
return false;
}
RefPtr<gfxContext> maskCtx = gfxContext::CreatePreservingTransformOrNull(maskDT);
MOZ_ASSERT(maskCtx);
- gfxMatrix currentMatrix = sourceCtx->CurrentMatrix();
- maskCtx->SetMatrix(gfxMatrix::Translation(bounds.TopLeft()) *
- currentMatrix *
- gfxMatrix::Translation(-drawRect.TopLeft()));
+ gfxMatrix currentMatrix = sourceCtx->CurrentMatrixDouble();
+ maskCtx->SetMatrixDouble(gfxMatrix::Translation(bounds.TopLeft()) *
+ currentMatrix *
+ gfxMatrix::Translation(-drawRect.TopLeft()));
// Shade text shape into mask A8 surface.
nsLayoutUtils::PaintFrame(maskCtx, aFrame,
nsRect(nsPoint(0, 0), aFrame->GetSize()),
NS_RGB(255, 255, 255),
nsDisplayListBuilderMode::GENERATE_GLYPH);
// Push the generated mask into aContext, so that the caller can pop and
@@ -9166,17 +9166,17 @@ ComputeMaskGeometry(PaintFramesParams& a
nsPoint offsetToUserSpace =
nsLayoutUtils::ComputeOffsetToUserSpace(aParams.builder, aParams.frame);
gfxPoint devPixelOffsetToUserSpace =
nsLayoutUtils::PointToGfxPoint(offsetToUserSpace,
frame->PresContext()->AppUnitsPerDevPixel());
gfxContextMatrixAutoSaveRestore matSR(&ctx);
- ctx.SetMatrix(ctx.CurrentMatrix().PreTranslate(devPixelOffsetToUserSpace));
+ ctx.SetMatrixDouble(ctx.CurrentMatrixDouble().PreTranslate(devPixelOffsetToUserSpace));
// Convert boaderArea and dirtyRect to user space.
int32_t appUnitsPerDevPixel = frame->PresContext()->AppUnitsPerDevPixel();
nsRect userSpaceBorderArea = aParams.borderArea - offsetToUserSpace;
nsRect userSpaceDirtyRect = aParams.dirtyRect - offsetToUserSpace;
// Union all mask layer rectangles in user space.
gfxRect maskInUserSpace;
--- a/layout/painting/nsImageRenderer.cpp
+++ b/layout/painting/nsImageRenderer.cpp
@@ -693,17 +693,17 @@ nsImageRenderer::DrawableForElement(cons
int32_t appUnitsPerDevPixel = mForFrame->PresContext()->AppUnitsPerDevPixel();
nsRect destRect = aImageRect - aImageRect.TopLeft();
nsIntSize roundedOut = destRect.ToOutsidePixels(appUnitsPerDevPixel).Size();
IntSize imageSize(roundedOut.width, roundedOut.height);
RefPtr<gfxDrawable> drawable =
nsSVGIntegrationUtils::DrawableFromPaintServer(
mPaintServerFrame, mForFrame, mSize, imageSize,
aContext.GetDrawTarget(),
- aContext.CurrentMatrix(),
+ aContext.CurrentMatrixDouble(),
nsSVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES);
return drawable.forget();
}
NS_ASSERTION(mImageElementSurface.GetSourceSurface(), "Surface should be ready.");
RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable(
mImageElementSurface.GetSourceSurface().get(),
mImageElementSurface.mSize);
--- a/layout/svg/SVGGeometryFrame.cpp
+++ b/layout/svg/SVGGeometryFrame.cpp
@@ -272,17 +272,17 @@ SVGGeometryFrame::PaintSVG(gfxContext& a
imgDrawingParams& aImgParams,
const nsIntRect* aDirtyRect)
{
if (!StyleVisibility()->IsVisible())
return;
// Matrix to the geometry's user space:
gfxMatrix newMatrix =
- aContext.CurrentMatrix().PreMultiply(aTransform).NudgeToIntegers();
+ aContext.CurrentMatrixDouble().PreMultiply(aTransform).NudgeToIntegers();
if (newMatrix.IsSingular()) {
return;
}
uint32_t paintOrder = StyleSVG()->mPaintOrder;
if (paintOrder == NS_STYLE_PAINT_ORDER_NORMAL) {
Render(&aContext, eRenderFill | eRenderStroke, newMatrix, aImgParams);
@@ -762,17 +762,17 @@ SVGGeometryFrame::Render(gfxContext* aCo
(StyleSVG()->mShapeRendering == NS_STYLE_SHAPE_RENDERING_OPTIMIZESPEED ||
StyleSVG()->mShapeRendering == NS_STYLE_SHAPE_RENDERING_CRISPEDGES) ?
AntialiasMode::NONE : AntialiasMode::SUBPIXEL;
// We wait as late as possible before setting the transform so that we don't
// set it unnecessarily if we return early (it's an expensive operation for
// some backends).
gfxContextMatrixAutoSaveRestore autoRestoreTransform(aContext);
- aContext->SetMatrix(aNewTransform);
+ aContext->SetMatrixDouble(aNewTransform);
if (GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD) {
// We don't complicate this code with GetAsSimplePath since the cost of
// masking will dwarf Path creation overhead anyway.
RefPtr<Path> path = element->GetOrBuildPath(*drawTarget, fillRule);
if (path) {
ColorPattern white(ToDeviceColor(Color(1.0f, 1.0f, 1.0f, 1.0f)));
drawTarget->Fill(path, white,
--- a/layout/svg/SVGTextFrame.cpp
+++ b/layout/svg/SVGTextFrame.cpp
@@ -2938,17 +2938,17 @@ SVGTextDrawPathCallbacks::HandleTextGeom
{
if (IsClipPathChild()) {
RefPtr<Path> path = mContext.GetPath();
ColorPattern white(Color(1.f, 1.f, 1.f, 1.f)); // for masking, so no ToDeviceColor
mContext.GetDrawTarget()->Fill(path, white);
} else {
// Normal painting.
gfxContextMatrixAutoSaveRestore saveMatrix(&mContext);
- mContext.SetMatrix(mCanvasTM);
+ mContext.SetMatrixDouble(mCanvasTM);
FillAndStrokeGeometry();
}
}
void
SVGTextDrawPathCallbacks::MakeFillPattern(GeneralPattern* aOutPattern,
imgDrawingParams& aImgParams)
@@ -3584,17 +3584,17 @@ SVGTextFrame::PaintSVG(gfxContext& aCont
DrawTarget& aDrawTarget = *aContext.GetDrawTarget();
nsIFrame* kid = PrincipalChildList().FirstChild();
if (!kid) {
return;
}
nsPresContext* presContext = PresContext();
- gfxMatrix initialMatrix = aContext.CurrentMatrix();
+ gfxMatrix initialMatrix = aContext.CurrentMatrixDouble();
if (mState & NS_FRAME_IS_NONDISPLAY) {
// If we are in a canvas DrawWindow call that used the
// DRAWWINDOW_DO_NOT_FLUSH flag, then we may still have out
// of date frames. Just don't paint anything if they are
// dirty.
if (presContext->PresShell()->InDrawWindowNotFlushing() &&
NS_SUBTREE_DIRTY(this)) {
@@ -3645,17 +3645,17 @@ SVGTextFrame::PaintSVG(gfxContext& aCont
float cssPxPerDevPx = presContext->AppUnitsToFloatCSSPixels(auPerDevPx);
gfxMatrix canvasTMForChildren = aTransform;
canvasTMForChildren.PreScale(cssPxPerDevPx, cssPxPerDevPx);
initialMatrix.PreScale(1 / cssPxPerDevPx, 1 / cssPxPerDevPx);
gfxContextMatrixAutoSaveRestore matSR(&aContext);
aContext.NewPath();
aContext.Multiply(canvasTMForChildren);
- gfxMatrix currentMatrix = aContext.CurrentMatrix();
+ gfxMatrix currentMatrix = aContext.CurrentMatrixDouble();
RefPtr<nsCaret> caret = presContext->PresShell()->GetCaret();
nsRect caretRect;
nsIFrame* caretFrame = caret->GetPaintGeometry(&caretRect);
gfxContextAutoSaveRestore ctxSR;
TextRenderedRunIterator it(this, TextRenderedRunIterator::eVisibleFrames);
TextRenderedRun run = it.Current();
@@ -3682,17 +3682,17 @@ SVGTextFrame::PaintSVG(gfxContext& aCont
nsSVGUtils::SetupStrokeGeometry(frame, &aContext, outerContextPaint);
}
// Set up the transform for painting the text frame for the substring
// indicated by the run.
gfxMatrix runTransform =
run.GetTransformFromUserSpaceForPainting(presContext, item) *
currentMatrix;
- aContext.SetMatrix(runTransform);
+ aContext.SetMatrixDouble(runTransform);
if (drawMode != DrawMode(0)) {
bool paintSVGGlyphs;
nsTextFrame::PaintTextParams params(&aContext);
params.framePt = gfx::Point();
params.dirtyRect = LayoutDevicePixel::
FromAppUnits(frame->GetVisualOverflowRect(), auPerDevPx);
params.contextPaint = contextPaint;
--- a/layout/svg/nsFilterInstance.cpp
+++ b/layout/svg/nsFilterInstance.cpp
@@ -66,31 +66,31 @@ nsFilterInstance::PaintFilteredFrame(nsI
nsSVGFilterPaintCallback *aPaintCallback,
const nsRegion *aDirtyArea,
imgDrawingParams& aImgParams)
{
auto& filterChain = aFilteredFrame->StyleEffects()->mFilters;
UniquePtr<UserSpaceMetrics> metrics = UserSpaceMetricsForFrame(aFilteredFrame);
gfxContextMatrixAutoSaveRestore autoSR(aCtx);
- gfxSize scaleFactors = aCtx->CurrentMatrix().ScaleFactors(true);
+ gfxSize scaleFactors = aCtx->CurrentMatrixDouble().ScaleFactors(true);
if (scaleFactors.IsEmpty()) {
return;
}
gfxMatrix scaleMatrix(scaleFactors.width, 0.0f,
0.0f, scaleFactors.height,
0.0f, 0.0f);
gfxMatrix reverseScaleMatrix = scaleMatrix;
DebugOnly<bool> invertible = reverseScaleMatrix.Invert();
MOZ_ASSERT(invertible);
// Pull scale vector out of aCtx's transform, put all scale factors, which
// includes css and css-to-dev-px scale, into scaleMatrixInDevUnits.
- aCtx->SetMatrix(reverseScaleMatrix * aCtx->CurrentMatrix());
+ aCtx->SetMatrixDouble(reverseScaleMatrix * aCtx->CurrentMatrixDouble());
gfxMatrix scaleMatrixInDevUnits =
scaleMatrix * nsSVGUtils::GetCSSPxToDevPxMatrix(aFilteredFrame);
// Hardcode InputIsTainted to true because we don't want JS to be able to
// read the rendered contents of aFilteredFrame.
nsFilterInstance instance(aFilteredFrame, aFilteredFrame->GetContent(),
*metrics, filterChain, /* InputIsTainted */ true,
@@ -409,18 +409,18 @@ nsFilterInstance::BuildSourcePaint(Sourc
if (!offscreenDT || !offscreenDT->IsValid()) {
return;
}
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(offscreenDT);
MOZ_ASSERT(ctx); // already checked the draw target above
gfxContextAutoSaveRestore saver(ctx);
- ctx->SetMatrix(mPaintTransform *
- gfxMatrix::Translation(-neededRect.TopLeft()));
+ ctx->SetMatrixDouble(mPaintTransform *
+ gfxMatrix::Translation(-neededRect.TopLeft()));
GeneralPattern pattern;
if (aSource == &mFillPaint) {
nsSVGUtils::MakeFillPatternFor(mTargetFrame, ctx, &pattern, aImgParams);
} else if (aSource == &mStrokePaint) {
nsSVGUtils::MakeStrokePatternFor(mTargetFrame, ctx, &pattern, aImgParams);
}
if (pattern.GetPattern()) {
@@ -478,18 +478,18 @@ nsFilterInstance::BuildSourceImage(DrawT
// space to device space and back again). However, that would make the
// code more complex while being hard to get right without introducing
// subtle bugs, and in practice it probably makes no real difference.)
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(offscreenDT);
MOZ_ASSERT(ctx); // already checked the draw target above
gfxMatrix devPxToCssPxTM = nsSVGUtils::GetCSSPxToDevPxMatrix(mTargetFrame);
DebugOnly<bool> invertible = devPxToCssPxTM.Invert();
MOZ_ASSERT(invertible);
- ctx->SetMatrix(devPxToCssPxTM * mPaintTransform *
- gfxMatrix::Translation(-neededRect.TopLeft()));
+ ctx->SetMatrixDouble(devPxToCssPxTM * mPaintTransform *
+ gfxMatrix::Translation(-neededRect.TopLeft()));
mPaintCallback->Paint(*ctx, mTargetFrame, mPaintTransform, &dirty, aImgParams);
mSourceGraphic.mSourceSurface = offscreenDT->Snapshot();
mSourceGraphic.mSurfaceRect = neededRect;
}
void
--- a/layout/svg/nsSVGClipPathFrame.cpp
+++ b/layout/svg/nsSVGClipPathFrame.cpp
@@ -58,19 +58,19 @@ nsSVGClipPathFrame::ApplyClipPath(gfxCon
SVGGeometryFrame* pathFrame = do_QueryFrame(singleClipPathChild);
if (pathFrame) {
SVGGeometryElement* pathElement =
static_cast<SVGGeometryElement*>(pathFrame->GetContent());
gfxMatrix toChildsUserSpace = pathElement->
PrependLocalTransformsTo(GetClipPathTransform(aClippedFrame) * aMatrix,
eUserSpaceToParent);
gfxMatrix newMatrix =
- aContext.CurrentMatrix().PreMultiply(toChildsUserSpace).NudgeToIntegers();
+ aContext.CurrentMatrixDouble().PreMultiply(toChildsUserSpace).NudgeToIntegers();
if (!newMatrix.IsSingular()) {
- aContext.SetMatrix(newMatrix);
+ aContext.SetMatrixDouble(newMatrix);
FillRule clipRule =
nsSVGUtils::ToFillRule(pathFrame->StyleSVG()->mClipRule);
clipPath = pathElement->GetOrBuildPath(aDrawTarget, clipRule);
}
}
}
if (clipPath) {
@@ -98,17 +98,17 @@ nsSVGClipPathFrame::CreateClipMask(gfxCo
referenceDT->CreateSimilarDrawTarget(bounds.Size(), SurfaceFormat::A8);
aOffset = bounds.TopLeft();
return maskDT.forget();
}
static void
-ComposeExtraMask(DrawTarget* aTarget, const gfxMatrix& aMaskTransfrom,
+ComposeExtraMask(DrawTarget* aTarget,
SourceSurface* aExtraMask, const Matrix& aExtraMasksTransform)
{
MOZ_ASSERT(aExtraMask);
Matrix origin = aTarget->GetTransform();
aTarget->SetTransform(aExtraMasksTransform * aTarget->GetTransform());
aTarget->MaskSurface(ColorPattern(Color(0.0, 0.0, 0.0, 1.0)),
aExtraMask,
@@ -173,24 +173,24 @@ nsSVGClipPathFrame::PaintClipMask(gfxCon
if (maskUsage.shouldGenerateClipMaskLayer) {
aMaskContext.PopGroupAndBlend();
} else if (maskUsage.shouldApplyClipPath) {
aMaskContext.PopClip();
}
// Moz2D transforms in the opposite direction to Thebes
- gfxMatrix maskTransfrom = aMaskContext.CurrentMatrix();
+ Matrix maskTransfrom = aMaskContext.CurrentMatrix();
maskTransfrom.Invert();
if (aExtraMask) {
- ComposeExtraMask(maskDT, maskTransfrom, aExtraMask, aExtraMasksTransform);
+ ComposeExtraMask(maskDT, aExtraMask, aExtraMasksTransform);
}
- *aMaskTransform = ToMatrix(maskTransfrom);
+ *aMaskTransform = maskTransfrom;
}
void
nsSVGClipPathFrame::PaintFrameIntoMask(nsIFrame *aFrame,
nsIFrame* aClippedFrame,
gfxContext& aTarget,
const gfxMatrix& aMatrix)
{
@@ -266,17 +266,17 @@ nsSVGClipPathFrame::GetClipMask(gfxConte
}
RefPtr<gfxContext> maskContext = gfxContext::CreateOrNull(maskDT);
if (!maskContext) {
gfxCriticalError() << "SVGClipPath context problem " << gfx::hexa(maskDT);
return nullptr;
}
maskContext->SetMatrix(aReferenceContext.CurrentMatrix() *
- gfxMatrix::Translation(-offset));
+ Matrix::Translation(-offset));
PaintClipMask(*maskContext, aClippedFrame, aMatrix, aMaskTransform,
aExtraMask, aExtraMasksTransform);
RefPtr<SourceSurface> surface = maskDT->Snapshot();
return surface.forget();
}
--- a/layout/svg/nsSVGIntegrationUtils.cpp
+++ b/layout/svg/nsSVGIntegrationUtils.cpp
@@ -414,17 +414,17 @@ public:
const nsIntRect* aDirtyRect,
imgDrawingParams& aImgParams) override
{
BasicLayerManager* basic = mLayerManager->AsBasicLayerManager();
RefPtr<gfxContext> oldCtx = basic->GetTarget();
basic->SetTarget(&aContext);
gfxContextMatrixAutoSaveRestore autoSR(&aContext);
- aContext.SetMatrix(aContext.CurrentMatrix().PreTranslate(-mUserSpaceToFrameSpaceOffset));
+ aContext.SetMatrixDouble(aContext.CurrentMatrixDouble().PreTranslate(-mUserSpaceToFrameSpaceOffset));
mLayerManager->EndTransaction(FrameLayerBuilder::DrawPaintedLayer, mBuilder);
basic->SetTarget(oldCtx);
}
private:
nsDisplayListBuilder* mBuilder;
LayerManager* mLayerManager;
@@ -435,17 +435,17 @@ typedef nsSVGIntegrationUtils::PaintFram
/**
* Paint css-positioned-mask onto a given target(aMaskDT).
*/
static void
PaintMaskSurface(const PaintFramesParams& aParams,
DrawTarget* aMaskDT, float aOpacity, nsStyleContext* aSC,
const nsTArray<nsSVGMaskFrame*>& aMaskFrames,
- const gfxMatrix& aMaskSurfaceMatrix,
+ const Matrix& aMaskSurfaceMatrix,
const nsPoint& aOffsetToUserSpace)
{
MOZ_ASSERT(aMaskFrames.Length() > 0);
MOZ_ASSERT(aMaskDT->GetFormat() == SurfaceFormat::A8);
MOZ_ASSERT(aOpacity == 1.0 || aMaskFrames.Length() == 1);
const nsStyleSVGReset *svgReset = aSC->StyleSVGReset();
gfxMatrix cssPxToDevPxMatrix =
@@ -568,18 +568,18 @@ CreateAndPaintMaskSurface(const PaintFra
// We can paint mask along with opacity only if
// 1. There is only one mask, or
// 2. No overlap among masks.
// Collision detect in #2 is not that trivial, we only accept #1 here.
paintResult.opacityApplied = (aMaskFrames.Length() == 1);
// Set context's matrix on maskContext, offset by the maskSurfaceRect's
// position. This makes sure that we combine the masks in device space.
- gfxMatrix maskSurfaceMatrix =
- ctx.CurrentMatrix() * gfxMatrix::Translation(-aParams.maskRect.TopLeft());
+ Matrix maskSurfaceMatrix =
+ ctx.CurrentMatrix() * Matrix::Translation(-aParams.maskRect.TopLeft());
PaintMaskSurface(aParams, maskDT,
paintResult.opacityApplied ? aOpacity : 1.0,
aSC, aMaskFrames, maskSurfaceMatrix,
aOffsetToUserSpace);
if (aParams.imgParams.result != DrawResult::SUCCESS) {
// Now we know the status of mask resource since we used it while painting.
@@ -599,17 +599,17 @@ CreateAndPaintMaskSurface(const PaintFra
// masked content as if this mask is an opaque white one(no mask).
paintResult.transparentBlackMask =
!(aParams.frame->GetStateBits() & NS_FRAME_SVG_LAYOUT);
MOZ_ASSERT(!paintResult.maskSurface);
return paintResult;
}
- paintResult.maskTransform = ToMatrix(maskSurfaceMatrix);
+ paintResult.maskTransform = maskSurfaceMatrix;
if (!paintResult.maskTransform.Invert()) {
return paintResult;
}
paintResult.maskSurface = maskDT->Snapshot();
return paintResult;
}
@@ -706,18 +706,18 @@ ComputeEffectOffset(nsIFrame* aFrame, co
* Setup transform matrix of a gfx context by a specific frame. Move the
* origin of aParams.ctx to the user space of aFrame.
*/
static EffectOffsets
MoveContextOriginToUserSpace(nsIFrame* aFrame, const PaintFramesParams& aParams)
{
EffectOffsets offset = ComputeEffectOffset(aFrame, aParams);
- aParams.ctx.SetMatrix(
- aParams.ctx.CurrentMatrix().PreTranslate(offset.offsetToUserSpaceInDevPx));
+ aParams.ctx.SetMatrixDouble(
+ aParams.ctx.CurrentMatrixDouble().PreTranslate(offset.offsetToUserSpaceInDevPx));
return offset;
}
bool
nsSVGIntegrationUtils::IsMaskResourceReady(nsIFrame* aFrame)
{
nsIFrame* firstFrame =
@@ -847,17 +847,17 @@ nsSVGIntegrationUtils::PaintMask(const P
Matrix clipMaskTransform;
gfxMatrix cssPxToDevPxMatrix = nsSVGUtils::GetCSSPxToDevPxMatrix(frame);
nsSVGClipPathFrame *clipPathFrame = effectProperties.GetClipPathFrame();
RefPtr<SourceSurface> maskSurface =
maskUsage.shouldGenerateMaskLayer ? maskTarget->Snapshot() : nullptr;
clipPathFrame->PaintClipMask(ctx, frame, cssPxToDevPxMatrix,
&clipMaskTransform, maskSurface,
- ToMatrix(ctx.CurrentMatrix()));
+ ctx.CurrentMatrix());
}
}
void
nsSVGIntegrationUtils::PaintMaskAndClipPath(const PaintFramesParams& aParams)
{
MOZ_ASSERT(UsingMaskOrClipPathForFrame(aParams.frame),
"Should not use this method when no mask or clipPath effect"
--- a/layout/svg/nsSVGMaskFrame.cpp
+++ b/layout/svg/nsSVGMaskFrame.cpp
@@ -94,18 +94,18 @@ nsSVGMaskFrame::GetMaskForMaskedFrame(Ma
maskDT = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
maskSurfaceSize, SurfaceFormat::A8);
}
if (!maskDT || !maskDT->IsValid()) {
return nullptr;
}
- gfxMatrix maskSurfaceMatrix =
- context->CurrentMatrix() * gfxMatrix::Translation(-maskSurfaceRect.TopLeft());
+ Matrix maskSurfaceMatrix =
+ context->CurrentMatrix() * ToMatrix(gfxMatrix::Translation(-maskSurfaceRect.TopLeft()));
RefPtr<gfxContext> tmpCtx = gfxContext::CreateOrNull(maskDT);
MOZ_ASSERT(tmpCtx); // already checked the draw target above
tmpCtx->SetMatrix(maskSurfaceMatrix);
mMatrixForChildren = GetMaskTransform(aParams.maskedFrame) *
aParams.toUserSpace;
@@ -148,17 +148,17 @@ nsSVGMaskFrame::GetMaskForMaskedFrame(Ma
surface = maskSnapshot.forget();
}
// Moz2D transforms in the opposite direction to Thebes
if (!maskSurfaceMatrix.Invert()) {
return nullptr;
}
- *aParams.maskTransform = ToMatrix(maskSurfaceMatrix);
+ *aParams.maskTransform = maskSurfaceMatrix;
return surface.forget();
}
gfxRect
nsSVGMaskFrame::GetMaskArea(nsIFrame* aMaskedFrame)
{
SVGMaskElement *maskElem = static_cast<SVGMaskElement*>(GetContent());
--- a/layout/svg/nsSVGUtils.cpp
+++ b/layout/svg/nsSVGUtils.cpp
@@ -574,33 +574,33 @@ public:
}
MOZ_ASSERT(!mTargetCtx,
"CreateBlendTarget is designed to be used once only.");
mTargetCtx = gfxContext::CreateOrNull(targetDT);
MOZ_ASSERT(mTargetCtx); // already checked the draw target above
mTargetCtx->SetMatrix(mSourceCtx->CurrentMatrix() *
- gfxMatrix::Translation(-drawRect.TopLeft()));
+ Matrix::Translation(-drawRect.TopLeft()));
mTargetOffset = drawRect.TopLeft();
return mTargetCtx;
}
void BlendToTarget()
{
MOZ_ASSERT(ShouldCreateDrawTargetForBlend());
MOZ_ASSERT(mTargetCtx,
"BlendToTarget should be used after CreateBlendTarget.");
RefPtr<SourceSurface> targetSurf = mTargetCtx->GetDrawTarget()->Snapshot();
gfxContextAutoSaveRestore save(mSourceCtx);
- mSourceCtx->SetMatrix(gfxMatrix()); // This will be restored right after.
+ mSourceCtx->SetMatrix(Matrix()); // This will be restored right after.
RefPtr<gfxPattern> pattern =
new gfxPattern(targetSurf,
Matrix::Translation(mTargetOffset.x, mTargetOffset.y));
mSourceCtx->SetPattern(pattern);
mSourceCtx->Paint();
}
private:
@@ -849,18 +849,18 @@ nsSVGUtils::PaintFrameWithEffects(nsIFra
gfxContextMatrixAutoSaveRestore autoSR(target);
// 'target' is currently scaled such that its user space units are CSS
// pixels (SVG user space units). But PaintFilteredFrame expects it to be
// scaled in such a way that its user space units are device pixels. So we
// have to adjust the scale.
gfxMatrix reverseScaleMatrix = nsSVGUtils::GetCSSPxToDevPxMatrix(aFrame);
DebugOnly<bool> invertible = reverseScaleMatrix.Invert();
- target->SetMatrix(reverseScaleMatrix * aTransform *
- target->CurrentMatrix());
+ target->SetMatrixDouble(reverseScaleMatrix * aTransform *
+ target->CurrentMatrixDouble());
SVGPaintCallback paintCallback;
nsFilterInstance::PaintFilteredFrame(aFrame, target, &paintCallback,
dirtyRegion, aImgParams);
} else {
svgFrame->PaintSVG(*target, aTransform, aImgParams, aDirtyRect);
}
@@ -1504,37 +1504,37 @@ nsSVGUtils::MakeFillPatternFor(nsIFrame*
const DrawTarget* dt = aContext->GetDrawTarget();
nsSVGPaintServerFrame *ps =
SVGObserverUtils::GetPaintServer(aFrame, &nsStyleSVG::mFill,
SVGObserverUtils::FillProperty());
if (ps) {
RefPtr<gfxPattern> pattern =
- ps->GetPaintServerPattern(aFrame, dt, aContext->CurrentMatrix(),
+ ps->GetPaintServerPattern(aFrame, dt, aContext->CurrentMatrixDouble(),
&nsStyleSVG::mFill, fillOpacity, aImgParams);
if (pattern) {
pattern->CacheColorStops(dt);
aOutPattern->Init(*pattern->GetPattern(dt));
return;
}
}
if (aContextPaint) {
RefPtr<gfxPattern> pattern;
switch (style->mFill.Type()) {
case eStyleSVGPaintType_ContextFill:
pattern =
aContextPaint->GetFillPattern(dt, fillOpacity,
- aContext->CurrentMatrix(), aImgParams);
+ aContext->CurrentMatrixDouble(), aImgParams);
break;
case eStyleSVGPaintType_ContextStroke:
pattern =
aContextPaint->GetStrokePattern(dt, fillOpacity,
- aContext->CurrentMatrix(), aImgParams);
+ aContext->CurrentMatrixDouble(), aImgParams);
break;
default:
;
}
if (pattern) {
aOutPattern->Init(*pattern->GetPattern(dt));
return;
}
@@ -1580,37 +1580,37 @@ nsSVGUtils::MakeStrokePatternFor(nsIFram
const DrawTarget* dt = aContext->GetDrawTarget();
nsSVGPaintServerFrame *ps =
SVGObserverUtils::GetPaintServer(aFrame, &nsStyleSVG::mStroke,
SVGObserverUtils::StrokeProperty());
if (ps) {
RefPtr<gfxPattern> pattern =
- ps->GetPaintServerPattern(aFrame, dt, aContext->CurrentMatrix(),
+ ps->GetPaintServerPattern(aFrame, dt, aContext->CurrentMatrixDouble(),
&nsStyleSVG::mStroke, strokeOpacity, aImgParams);
if (pattern) {
pattern->CacheColorStops(dt);
aOutPattern->Init(*pattern->GetPattern(dt));
return;
}
}
if (aContextPaint) {
RefPtr<gfxPattern> pattern;
switch (style->mStroke.Type()) {
case eStyleSVGPaintType_ContextFill:
pattern =
aContextPaint->GetFillPattern(dt, strokeOpacity,
- aContext->CurrentMatrix(), aImgParams);
+ aContext->CurrentMatrixDouble(), aImgParams);
break;
case eStyleSVGPaintType_ContextStroke:
pattern =
aContextPaint->GetStrokePattern(dt, strokeOpacity,
- aContext->CurrentMatrix(), aImgParams);
+ aContext->CurrentMatrixDouble(), aImgParams);
break;
default:
;
}
if (pattern) {
aOutPattern->Init(*pattern->GetPattern(dt));
return;
}
--- a/widget/gtk/nsNativeThemeGTK.cpp
+++ b/widget/gtk/nsNativeThemeGTK.cpp
@@ -1167,21 +1167,21 @@ nsNativeThemeGTK::DrawWidgetBackground(g
// translate everything so (0,0) is the top left of the drawingRect
gfxPoint origin = rect.TopLeft() + drawingRect.TopLeft();
#if (MOZ_WIDGET_GTK == 2)
gfxContextAutoSaveRestore autoSR(ctx);
gfxMatrix matrix;
if (!snapped) { // else rects are in device coords
- matrix = ctx->CurrentMatrix();
+ matrix = ctx->CurrentMatrixDouble();
}
matrix.Translate(origin);
matrix.Scale(scaleFactor, scaleFactor); // Draw in GDK coords
- ctx->SetMatrix(matrix);
+ ctx->SetMatrixDouble(matrix);
// The gdk_clip is just advisory here, meaning "you don't
// need to draw outside this rect if you don't feel like it!"
GdkRectangle gdk_clip = {0, 0, drawingRect.width, drawingRect.height};
ThemeRenderer renderer(state, gtkWidgetType, flags, direction,
gdk_rect, gdk_clip);
