/**
* @param aXSide LEFT means we draw from the left side of the buffer (which
* is drawn on the right side of mBufferRect). RIGHT means we draw from
* the right side of the buffer (which is drawn on the left side of
* mBufferRect).
* @param aYSide TOP means we draw from the top side of the buffer (which
* is drawn on the bottom side of mBufferRect). BOTTOM means we draw from
* the bottom side of the buffer (which is drawn on the top side of
* mBufferRect).
*/
void
ThebesLayerBuffer::DrawBufferQuadrant(gfxContext* aTarget,
XSide aXSide, YSide aYSide,
float aOpacity,
gfxASurface* aMask,
const gfxMatrix* aMaskTransform)
{
// The rectangle that we're going to fill. Basically we're going to
// render the buffer at mBufferRect + quadrantTranslation to get the
// pixels in the right place, but we're only going to paint within
// mBufferRect
nsIntRect quadrantRect = GetQuadrantRectangle(aXSide, aYSide);
nsIntRect fillRect;
if (!fillRect.IntersectRect(mBufferRect, quadrantRect))
return;
aTarget->NewPath();
aTarget->Rectangle(gfxRect(fillRect.x, fillRect.y,
fillRect.width, fillRect.height),
true);
gfxPoint quadrantTranslation(quadrantRect.x, quadrantRect.y);
nsRefPtr<gfxPattern> pattern = new gfxPattern(mBuffer);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
gfxPattern::GraphicsFilter filter = gfxPattern::FILTER_NEAREST;
pattern->SetFilter(filter);
#endif
gfxContextMatrixAutoSaveRestore saveMatrix(aTarget);
// Transform from user -> buffer space.
gfxMatrix transform;
transform.Translate(-quadrantTranslation);
pattern->SetMatrix(transform);
aTarget->SetPattern(pattern);
if (aMask) {
if (aOpacity == 1.0) {
aTarget->SetMatrix(*aMaskTransform);
aTarget->Mask(aMask);
} else {
aTarget->PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
aTarget->Paint(aOpacity);
aTarget->PopGroupToSource();
aTarget->SetMatrix(*aMaskTransform);
aTarget->Mask(aMask);
}
} else {
if (aOpacity == 1.0) {
aTarget->Fill();
} else {
aTarget->Save();
aTarget->Clip();
aTarget->Paint(aOpacity);
aTarget->Restore();
}
}
}
/**
* @param aXSide LEFT means we draw from the left side of the buffer (which
* is drawn on the right side of mBufferRect). RIGHT means we draw from
* the right side of the buffer (which is drawn on the left side of
* mBufferRect).
* @param aYSide TOP means we draw from the top side of the buffer (which
* is drawn on the bottom side of mBufferRect). BOTTOM means we draw from
* the bottom side of the buffer (which is drawn on the top side of
* mBufferRect).
*/
void
RotatedBuffer::DrawBufferQuadrant(gfx::DrawTarget* aTarget,
XSide aXSide, YSide aYSide,
ContextSource aSource,
float aOpacity,
gfx::CompositionOp aOperator,
gfx::SourceSurface* aMask,
const gfx::Matrix* aMaskTransform) const
{
// The rectangle that we're going to fill. Basically we're going to
// render the buffer at mBufferRect + quadrantTranslation to get the
// pixels in the right place, but we're only going to paint within
// mBufferRect
nsIntRect quadrantRect = GetQuadrantRectangle(aXSide, aYSide);
nsIntRect fillRect;
if (!fillRect.IntersectRect(mBufferRect, quadrantRect))
return;
gfx::Point quadrantTranslation(quadrantRect.x, quadrantRect.y);
MOZ_ASSERT(aOperator == OP_OVER || aOperator == OP_SOURCE);
// direct2d is much slower when using OP_SOURCE so use OP_OVER and
// (maybe) a clear instead. Normally we need to draw in a single operation
// (to avoid flickering) but direct2d is ok since it defers rendering.
// We should try abstract this logic in a helper when we have other use
// cases.
if (aTarget->GetType() == BACKEND_DIRECT2D && aOperator == OP_SOURCE) {
aOperator = OP_OVER;
if (mDTBuffer->GetFormat() == FORMAT_B8G8R8A8) {
aTarget->ClearRect(ToRect(fillRect));
}
}
RefPtr<gfx::SourceSurface> snapshot;
if (aSource == BUFFER_BLACK) {
snapshot = mDTBuffer->Snapshot();
} else {
MOZ_ASSERT(aSource == BUFFER_WHITE);
snapshot = mDTBufferOnWhite->Snapshot();
}
if (aOperator == OP_SOURCE) {
// OP_SOURCE is unbounded in Azure, and we really don't want that behaviour here.
// We also can't do a ClearRect+FillRect since we need the drawing to happen
// as an atomic operation (to prevent flickering).
aTarget->PushClipRect(gfx::Rect(fillRect.x, fillRect.y,
fillRect.width, fillRect.height));
}
if (aMask) {
// Transform from user -> buffer space.
Matrix transform;
transform.Translate(quadrantTranslation.x, quadrantTranslation.y);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
SurfacePattern source(snapshot, EXTEND_CLAMP, transform, FILTER_POINT);
#else
SurfacePattern source(snapshot, EXTEND_CLAMP, transform);
#endif
Matrix oldTransform = aTarget->GetTransform();
aTarget->SetTransform(*aMaskTransform);
aTarget->MaskSurface(source, aMask, Point(0, 0), DrawOptions(aOpacity, aOperator));
aTarget->SetTransform(oldTransform);
} else {
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
DrawSurfaceOptions options(FILTER_POINT);
#else
DrawSurfaceOptions options;
#endif
aTarget->DrawSurface(snapshot, ToRect(fillRect),
GetSourceRectangle(aXSide, aYSide),
options,
DrawOptions(aOpacity, aOperator));
}
if (aOperator == OP_SOURCE) {
aTarget->PopClip();
}
aTarget->Flush();
}
