void BasicThebesLayerBuffer::DrawTo(ThebesLayer* aLayer, gfxContext* aTarget, float aOpacity, Layer* aMaskLayer) { aTarget->Save(); // If the entire buffer is valid, we can just draw the whole thing, // no need to clip. But we'll still clip if clipping is cheap --- // that might let us copy a smaller region of the buffer. // Also clip to the visible region if we're told to. if (!aLayer->GetValidRegion().Contains(BufferRect()) || (ToData(aLayer)->GetClipToVisibleRegion() && !aLayer->GetVisibleRegion().Contains(BufferRect())) || IsClippingCheap(aTarget, aLayer->GetEffectiveVisibleRegion())) { // We don't want to draw invalid stuff, so we need to clip. Might as // well clip to the smallest area possible --- the visible region. // Bug 599189 if there is a non-integer-translation transform in aTarget, // we might sample pixels outside GetEffectiveVisibleRegion(), which is wrong // and may cause gray lines. gfxUtils::ClipToRegionSnapped(aTarget, aLayer->GetEffectiveVisibleRegion()); } // Pull out the mask surface and transform here, because the mask // is internal to basic layers gfxMatrix maskTransform; if (nsRefPtr<gfxASurface> maskSurface = GetMaskSurfaceAndTransform(aMaskLayer, &maskTransform)) { DrawBufferWithRotation(aTarget, aOpacity, maskSurface, &maskTransform); } else { DrawBufferWithRotation(aTarget, aOpacity); } aTarget->Restore(); }
void ContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource, const nsIntRegion& aUpdateRegion) { nsRefPtr<gfxContext> destCtx = GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_BLACK); destCtx->SetOperator(gfxContext::OPERATOR_SOURCE); bool isClippingCheap = IsClippingCheap(destCtx, aUpdateRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destCtx, aUpdateRegion); } if (SupportsAzureContent()) { MOZ_ASSERT(!destCtx->IsCairo()); if (destCtx->GetDrawTarget()->GetFormat() == FORMAT_B8G8R8A8) { destCtx->GetDrawTarget()->ClearRect(Rect(0, 0, mFrontBufferRect.width, mFrontBufferRect.height)); } aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_BLACK); } else { aSource.DrawBufferWithRotation(destCtx, BUFFER_BLACK); } if (aSource.HaveBufferOnWhite()) { MOZ_ASSERT(HaveBufferOnWhite()); nsRefPtr<gfxContext> destCtx = GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_WHITE); destCtx->SetOperator(gfxContext::OPERATOR_SOURCE); bool isClippingCheap = IsClippingCheap(destCtx, aUpdateRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destCtx, aUpdateRegion); } if (SupportsAzureContent()) { MOZ_ASSERT(!destCtx->IsCairo()); if (destCtx->GetDrawTarget()->GetFormat() == FORMAT_B8G8R8A8) { destCtx->GetDrawTarget()->ClearRect(Rect(0, 0, mFrontBufferRect.width, mFrontBufferRect.height)); } aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_WHITE); } else { aSource.DrawBufferWithRotation(destCtx, BUFFER_WHITE); } } }
void ContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource, const nsIntRegion& aUpdateRegion) { nsRefPtr<gfxContext> destCtx = GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_BLACK); if (!destCtx) { return; } destCtx->SetOperator(gfxContext::OPERATOR_SOURCE); bool isClippingCheap = IsClippingCheap(destCtx, aUpdateRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destCtx, aUpdateRegion); } if (SupportsAzureContent()) { MOZ_ASSERT(!destCtx->IsCairo()); aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_BLACK, 1.0, OP_SOURCE); } else { aSource.DrawBufferWithRotation(destCtx, BUFFER_BLACK); } if (aSource.HaveBufferOnWhite()) { MOZ_ASSERT(HaveBufferOnWhite()); nsRefPtr<gfxContext> destCtx = GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_WHITE); destCtx->SetOperator(gfxContext::OPERATOR_SOURCE); bool isClippingCheap = IsClippingCheap(destCtx, aUpdateRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destCtx, aUpdateRegion); } if (SupportsAzureContent()) { MOZ_ASSERT(!destCtx->IsCairo()); aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_WHITE, 1.0, OP_SOURCE); } else { aSource.DrawBufferWithRotation(destCtx, BUFFER_WHITE); } } }
void ContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource, const nsIntRegion& aUpdateRegion) { DrawIterator iter; while (DrawTarget* destDT = BorrowDrawTargetForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_BLACK, &iter)) { bool isClippingCheap = IsClippingCheap(destDT, iter.mDrawRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destDT, iter.mDrawRegion); } aSource.DrawBufferWithRotation(destDT, BUFFER_BLACK, 1.0, CompositionOp::OP_SOURCE); if (isClippingCheap) { destDT->PopClip(); } // Flush the destination before the sources become inaccessible (Unlock). destDT->Flush(); ReturnDrawTargetToBuffer(destDT); } if (aSource.HaveBufferOnWhite()) { MOZ_ASSERT(HaveBufferOnWhite()); DrawIterator whiteIter; while (DrawTarget* destDT = BorrowDrawTargetForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_WHITE, &whiteIter)) { bool isClippingCheap = IsClippingCheap(destDT, whiteIter.mDrawRegion); if (isClippingCheap) { gfxUtils::ClipToRegion(destDT, whiteIter.mDrawRegion); } aSource.DrawBufferWithRotation(destDT, BUFFER_WHITE, 1.0, CompositionOp::OP_SOURCE); if (isClippingCheap) { destDT->PopClip(); } // Flush the destination before the sources become inaccessible (Unlock). destDT->Flush(); ReturnDrawTargetToBuffer(destDT); } } }
void RotatedContentBuffer::DrawTo(ThebesLayer* aLayer, gfxContext* aTarget, float aOpacity, gfxASurface* aMask, const gfxMatrix* aMaskTransform) { if (!EnsureBuffer()) { return; } RefPtr<DrawTarget> dt = aTarget->GetDrawTarget(); MOZ_ASSERT(dt, "Did you pass a non-Azure gfxContext?"); bool clipped = false; // If the entire buffer is valid, we can just draw the whole thing, // no need to clip. But we'll still clip if clipping is cheap --- // that might let us copy a smaller region of the buffer. // Also clip to the visible region if we're told to. if (!aLayer->GetValidRegion().Contains(BufferRect()) || (ToData(aLayer)->GetClipToVisibleRegion() && !aLayer->GetVisibleRegion().Contains(BufferRect())) || IsClippingCheap(aTarget, aLayer->GetEffectiveVisibleRegion())) { // We don't want to draw invalid stuff, so we need to clip. Might as // well clip to the smallest area possible --- the visible region. // Bug 599189 if there is a non-integer-translation transform in aTarget, // we might sample pixels outside GetEffectiveVisibleRegion(), which is wrong // and may cause gray lines. gfxUtils::ClipToRegionSnapped(dt, aLayer->GetEffectiveVisibleRegion()); clipped = true; } RefPtr<gfx::SourceSurface> mask; if (aMask) { mask = gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(dt, aMask); } Matrix maskTransform; if (aMaskTransform) { maskTransform = ToMatrix(*aMaskTransform); } CompositionOp op = CompositionOpForOp(aTarget->CurrentOperator()); DrawBufferWithRotation(dt, BUFFER_BLACK, aOpacity, op, mask, &maskTransform); if (clipped) { dt->PopClip(); } }
void BasicThebesLayerBuffer::SetBackingBufferAndUpdateFrom( gfxASurface* aBuffer, gfxASurface* aSource, const nsIntRect& aRect, const nsIntPoint& aRotation, const nsIntRegion& aUpdateRegion) { SetBackingBuffer(aBuffer, aRect, aRotation); nsRefPtr<gfxContext> destCtx = GetContextForQuadrantUpdate(aUpdateRegion.GetBounds()); destCtx->SetOperator(gfxContext::OPERATOR_SOURCE); if (IsClippingCheap(destCtx, aUpdateRegion)) { gfxUtils::ClipToRegion(destCtx, aUpdateRegion); } BasicThebesLayerBuffer srcBuffer(aSource, aRect, aRotation); srcBuffer.DrawBufferWithRotation(destCtx, 1.0); }