// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include "swdirectgdiengine.h"
#include "swdirectgdibitmap.h"
#include "swdirectgdidriverimpl.h"
#include <bmalphablend.h>
#include <graphics/bitmap.inl>
#include <graphics/gdi/gdiinline.inl>

/**
@see MDirectGdiEngine::DrawBitmap(cosnt TRect&, const CFbsBitmap&, const TRect&)
@panic DGDIAdapter 7, if the bitmap is invalid (debug only). 
*/
void CSwDirectGdiEngine::DrawBitmap(const TRect& aDestRect,
									const CFbsBitmap& aSource,
									const TRect& aSourceRect)
	{
	if (aSource.ExtendedBitmapType() != KNullUid)
		{
		iDriver->SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}
	
	TRect destRect(aDestRect);
	destRect.Move(iOrigin);
	TRect targetRect(destRect);		 
	const CSwDirectGdiBitmap& srce = static_cast<const CSwDirectGdiBitmap&>(aSource);	

	CBitwiseBitmap* bmp = srce.Address();
	GRAPHICS_ASSERT_DEBUG(bmp,EDirectGdiPanicInvalidBitmap);

	const TInt limit = iDefaultRegionPtr->Count();
	const TBool opaqueSource = (!IsAlphaChannel(aSource.DisplayMode())) && (iDrawMode == DirectGdi::EDrawModePEN);
	if (opaqueSource)
		{
		iDrawMode = DirectGdi::EDrawModeWriteAlpha;
		}

	TRect clipRect(0,0,0,0);
	for (TInt count = 0; count < limit; count++)
		{
		clipRect = (*iDefaultRegionPtr)[count];
		if (!clipRect.Intersects(targetRect))
			{
			continue;
			}

		clipRect.Intersection(targetRect);
		DoDrawBitmap(destRect,bmp,aSource.DataAddress(),aSource.DataStride(),aSourceRect, clipRect);

		iDrawDevice->UpdateRegion(clipRect);
		}
	if (opaqueSource)
		{
		iDrawMode = DirectGdi::EDrawModePEN;
		}
	}

/*
Draws the bitmap. If aSrceRect equals aDestRect, a DoBitBlt() is performed instead.
@panic DGDIAdapter 1013, if the clipping rectangle is dully outside the destination bounds (debug only).
*/
void CSwDirectGdiEngine::DoDrawBitmap(const TRect& aDestRect,
							 CBitwiseBitmap* aBitmap,
							 TUint32* aBase,
							 TInt aStride,
							 const TRect& aSrceRect,
							 const TRect& aClipRect)
	{
#ifdef _DEBUG
	TRect deviceDestRect;
	iDrawDevice->GetDrawRect(deviceDestRect);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iTl.iX >= deviceDestRect.iTl.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iTl.iY >= deviceDestRect.iTl.iY, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iBr.iX <= deviceDestRect.iBr.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iBr.iY <= deviceDestRect.iBr.iY, EDirectGdiPanicOutOfBounds);
#endif

	if (aDestRect.Size() == aSrceRect.Size())
		{
		TRect clippedRect(aDestRect);
		clippedRect.Intersection(aClipRect);

		const TPoint destPoint(clippedRect.iTl);
		clippedRect.Move(aSrceRect.iTl - aDestRect.iTl);
		DoBitBlt(destPoint,aBitmap,aBase,aStride,clippedRect);

		return;
		}

	MFastBlend* fastBlend=NULL;
	if (FastBlendInterface(aBitmap,NULL,fastBlend)==KErrNone)
		{
		if (fastBlend->FastBlendBitmapScaled(aClipRect, aDestRect, aSrceRect, aBase, aStride, aBitmap->DisplayMode(), aBitmap->SizeInPixels(), GcDrawMode(iDrawMode), CFbsDrawDevice::ENoShadow)== KErrNone)
			{
			return;
			}
		}
	
	TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();
	const TInt scanLineBytes = iDrawDevice->ScanLineBytes();
	TPtr8 scanLineDes(reinterpret_cast<TUint8*>(scanLineBuffer), scanLineBytes, scanLineBytes);

	// For EColor16MU targets, don't use EColor16MAP when draw mode is EDrawModeWriteAlpha.
	// Format conversion provides no performance gain and WriteLine expects EColor16MU 
	// in this case.
	const TDisplayMode dispMode = iDrawDevice->DisplayMode() == EColor16MU && iDrawMode == DirectGdi::EDrawModeWriteAlpha ? EColor16MU : iDrawDevice->ScanLineDisplayMode();

	TLinearDDA xLine;
	TInt bitmapXStart = 0;
	xLine.Construct(TPoint(aSrceRect.iTl.iX,aDestRect.iTl.iX),
					TPoint(aSrceRect.iBr.iX,aDestRect.iBr.iX),TLinearDDA::ELeft);
	xLine.JumpToYCoord(bitmapXStart,aClipRect.iTl.iX);

	TLinearDDA yLine;
	TPoint yCoord(aSrceRect.iTl.iY,aDestRect.iTl.iY);
	yLine.Construct(yCoord,TPoint(aSrceRect.iBr.iY,aDestRect.iBr.iY),TLinearDDA::ELeft);
	TInt dummy;
	yLine.JumpToYCoord2(dummy,aClipRect.iTl.iY);
	yCoord.SetXY(dummy,aClipRect.iTl.iY);

	const TInt srceWidth = aSrceRect.Width();
	const TInt destWidth = aDestRect.Width();
	const TInt clipWidth = aClipRect.Width();
	const TInt clipStrch = aClipRect.iTl.iX - aDestRect.iTl.iX;

	TLineScanningPosition lineScanPos(aBase);
	TBool finished = EFalse;
	const TPoint KZeroPoint(0,0);
	const CGraphicsContext::TDrawMode drawMode = GcDrawMode(iDrawMode);
	while (yCoord.iY < aClipRect.iBr.iY && !finished)
		{
		aBitmap->StretchScanLine(scanLineDes,TPoint(bitmapXStart,yCoord.iX),
								 clipStrch,clipWidth,destWidth,aSrceRect.iTl.iX,
								 srceWidth,KZeroPoint,dispMode,aBase,lineScanPos);
		if (yCoord.iY == aClipRect.iTl.iY)
			{
			aBitmap->SetCompressionBookmark(lineScanPos, aBase,NULL);
			}
		iDrawDevice->WriteLine(aClipRect.iTl.iX,yCoord.iY,clipWidth, scanLineBuffer, drawMode);
		finished = yLine.NextStep(yCoord);
		}
	}

/**
@see MDirectGdiEngine::DrawMaskedBitmap(cosnt TRect&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, TBool)
@panic DGDIAdapter 7, if the source or mask bitmap is invalid (debug only).
*/
void CSwDirectGdiEngine::DrawBitmapMasked(const TRect& aDestRect,
						 const CFbsBitmap& aBitmap,
						 const TRect& aSourceRect,
						 const CFbsBitmap& aMaskBitmap,
						 TBool aInvertMask)
	{
	if ((aBitmap.ExtendedBitmapType() != KNullUid) || (aMaskBitmap.ExtendedBitmapType() != KNullUid))
		{
		iDriver->SetError(KErrNotSupported); // Not supported for extended bitmaps
		return;
		}

	aBitmap.BeginDataAccess();
	aMaskBitmap.BeginDataAccess();
	
	TRect destRect(aDestRect);
	destRect.Move(iOrigin);
	TRect targetRect(destRect);	
	const TBool opaqueSource = (!IsAlphaChannel(aBitmap.DisplayMode())) && (iDrawMode == DirectGdi::EDrawModePEN);
	
	CBitwiseBitmap* srcebmp = ((CSwDirectGdiBitmap&)aBitmap).Address();
	CBitwiseBitmap* maskbmp = ((CSwDirectGdiBitmap&)aMaskBitmap).Address();
	GRAPHICS_ASSERT_DEBUG(srcebmp,EDirectGdiPanicInvalidBitmap);
	GRAPHICS_ASSERT_DEBUG(maskbmp,EDirectGdiPanicInvalidBitmap);

	const TInt limit = iDefaultRegionPtr->Count();
	if (opaqueSource)
		{
		iDrawMode = DirectGdi::EDrawModeWriteAlpha;
		}
	TRect clipRect(0,0,0,0);
	for (TInt count = 0; count < limit; count++)
		{
		clipRect = (*iDefaultRegionPtr)[count];
		if (!clipRect.Intersects(targetRect))
			{
			continue;
			}
		clipRect.Intersection(targetRect);
		DoDrawBitmapMasked(destRect,
					   srcebmp,
					   aBitmap.DataAddress(),
					   aSourceRect,
					   maskbmp,
					   aMaskBitmap.DataAddress(),
					   aInvertMask,
					   clipRect);
		iDrawDevice->UpdateRegion(clipRect);
		}
	if (opaqueSource)
		{
		iDrawMode = DirectGdi::EDrawModePEN;
		}

	aBitmap.EndDataAccess(ETrue);
	aMaskBitmap.EndDataAccess(ETrue);
	}