/**
* @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();
}
ThebesLayerBuffer::PaintState
ThebesLayerBuffer::BeginPaint(ThebesLayer* aLayer, ContentType aContentType)
{
PaintState result;
result.mRegionToDraw.Sub(aLayer->GetVisibleRegion(), aLayer->GetValidRegion());
if (mBuffer && aContentType != mBuffer->GetContentType()) {
// We're effectively clearing the valid region, so we need to draw
// the entire visible region now.
result.mRegionToDraw = aLayer->GetVisibleRegion();
result.mRegionToInvalidate = aLayer->GetValidRegion();
Clear();
}
if (result.mRegionToDraw.IsEmpty())
return result;
nsIntRect drawBounds = result.mRegionToDraw.GetBounds();
nsIntRect visibleBounds = aLayer->GetVisibleRegion().GetBounds();
nsRefPtr<gfxASurface> destBuffer;
nsIntRect destBufferRect;
if (BufferSizeOkFor(visibleBounds.Size())) {
// The current buffer is big enough to hold the visible area.
if (mBufferRect.Contains(visibleBounds)) {
// We don't need to adjust mBufferRect.
destBufferRect = mBufferRect;
} else {
// The buffer's big enough but doesn't contain everything that's
// going to be visible. We'll move it.
destBufferRect = nsIntRect(visibleBounds.TopLeft(), mBufferRect.Size());
}
nsIntRect keepArea;
if (keepArea.IntersectRect(destBufferRect, mBufferRect)) {
// Set mBufferRotation so that the pixels currently in mBuffer
// will still be rendered in the right place when mBufferRect
// changes to destBufferRect.
nsIntPoint newRotation = mBufferRotation +
(destBufferRect.TopLeft() - mBufferRect.TopLeft());
WrapRotationAxis(&newRotation.x, mBufferRect.width);
WrapRotationAxis(&newRotation.y, mBufferRect.height);
NS_ASSERTION(nsIntRect(nsIntPoint(0,0), mBufferRect.Size()).Contains(newRotation),
"newRotation out of bounds");
PRInt32 xBoundary = destBufferRect.XMost() - newRotation.x;
PRInt32 yBoundary = destBufferRect.YMost() - newRotation.y;
if ((drawBounds.x < xBoundary && xBoundary < drawBounds.XMost()) ||
(drawBounds.y < yBoundary && yBoundary < drawBounds.YMost())) {
// The stuff we need to redraw will wrap around an edge of the
// buffer, so we will need to do a self-copy
if (mBufferRotation == nsIntPoint(0,0)) {
destBuffer = mBuffer;
} else {
// We can't do a real self-copy because the buffer is rotated.
// So allocate a new buffer for the destination.
destBufferRect = visibleBounds;
destBuffer = CreateBuffer(aContentType, destBufferRect.Size());
if (!destBuffer)
return result;
}
} else {
mBufferRect = destBufferRect;
mBufferRotation = newRotation;
}
} else {
// No pixels are going to be kept. The whole visible region
// will be redrawn, so we don't need to copy anything, so we don't
// set destBuffer.
mBufferRect = destBufferRect;
mBufferRotation = nsIntPoint(0,0);
}
} else {
// The buffer's not big enough, so allocate a new one
destBufferRect = visibleBounds;
destBuffer = CreateBuffer(aContentType, destBufferRect.Size());
if (!destBuffer)
return result;
}
// If we have no buffered data already, then destBuffer will be a fresh buffer
// and we do not need to clear it below.
PRBool isClear = mBuffer == nsnull;
if (destBuffer) {
if (mBuffer) {
// Copy the bits
nsRefPtr<gfxContext> tmpCtx = new gfxContext(destBuffer);
nsIntPoint offset = -destBufferRect.TopLeft();
tmpCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
tmpCtx->Translate(gfxPoint(offset.x, offset.y));
DrawBufferWithRotation(tmpCtx, 1.0);
}
mBuffer = destBuffer.forget();
mBufferRect = destBufferRect;
mBufferRotation = nsIntPoint(0,0);
}
nsIntRegion invalidate;
invalidate.Sub(aLayer->GetValidRegion(), destBufferRect);
result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);
result.mContext = new gfxContext(mBuffer);
// Figure out which quadrant to draw in
PRInt32 xBoundary = mBufferRect.XMost() - mBufferRotation.x;
PRInt32 yBoundary = mBufferRect.YMost() - mBufferRotation.y;
XSide sideX = drawBounds.XMost() <= xBoundary ? RIGHT : LEFT;
YSide sideY = drawBounds.YMost() <= yBoundary ? BOTTOM : TOP;
nsIntRect quadrantRect = GetQuadrantRectangle(sideX, sideY);
NS_ASSERTION(quadrantRect.Contains(drawBounds), "Messed up quadrants");
result.mContext->Translate(-gfxPoint(quadrantRect.x, quadrantRect.y));
ClipToRegion(result.mContext, result.mRegionToDraw);
if (aContentType == gfxASurface::CONTENT_COLOR_ALPHA && !isClear) {
result.mContext->SetOperator(gfxContext::OPERATOR_CLEAR);
result.mContext->Paint();
result.mContext->SetOperator(gfxContext::OPERATOR_OVER);
}
return result;
}
