// Copyright (c) 2004-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:

//

/** 	@file

	@internalTechnology */

#include <fbs.h>

#include "MngPanic.h"

#include "MngRenderer.h"

/** 

 the color will be used as a "default" to clear background if an image doesn't

 have one defined and there is no alpha channel

*/

const TUint KDefaultColor=0; 

/*static*/

CMngRenderer* CMngRenderer::NewL(const TSize& aSize, TBool aAlphaNeeded, TDisplayMode aDestDisplayMode, TDisplayMode aMaskDisplayMode)

	{

	CMngRenderer* self=new (ELeave) CMngRenderer(aSize, aAlphaNeeded, aDestDisplayMode, aMaskDisplayMode);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CMngRenderer::CMngRenderer(const TSize& aSize, TBool aAlphaNeeded, TDisplayMode aDestDisplayMode, TDisplayMode aMaskDisplayMode)

 : iAlphaNeeded(aAlphaNeeded),

   iRenderSize(aSize),

   iDestDisplayMode(aDestDisplayMode),

   iMaskDisplayMode(aMaskDisplayMode)

	{

	}

void CMngRenderer::ConstructL()

	{

	TInt pixelSize;

	CRgbPixelConsumer::SetPixelFunc setPixelFunction;

	if(iDestDisplayMode == EColor16MA || iDestDisplayMode == EColor16MU)

		{

		pixelSize = KRgbaPixelSize;

		setPixelFunction = &CRgbPixelConsumer::SetRGBAPixel;

		}

	else

		{

		pixelSize = KRgbPixelSize;

		setPixelFunction = &CRgbPixelConsumer::SetRGBPixel;

		}

	iRgbConsumer = new (ELeave) CRgbPixelConsumer(pixelSize);

	iRgbConsumer->InitL(iRenderSize);

	if (iAlphaNeeded) // as required by source image

		{

		iAlphaConsumer= new (ELeave) CAlphaPixelConsumer();

		iAlphaConsumer->InitL(iRenderSize);

		if (iDestDisplayMode == EColor16MA && iMaskDisplayMode != EGray256)  // No mask

			{

			// In this case, there is a single 16MA destination, so we need to put the

			// alpha data into the alpha channel, rather than 0xFF.

			iRgbConsumer->SetAlphaEnabledBitmap(ETrue);

			}

		}

	iRgbConsumer->SetAlphaConsumer(iAlphaConsumer);

	iRgbProcessor=CRgbProcessor::NewL(this);

	iRgbProcessor->SetPixelConsumer(iRgbConsumer);

	iRgbProcessor->SetPixelFunction(setPixelFunction);

	CAlphaProcessor* Alpha= NULL;

	if (iAlphaNeeded)

		{

		Alpha = CAlphaProcessor::NewL();

		iAlphaProcessor = Alpha;

		Alpha->SetPixelConsumer(iAlphaConsumer);

		}

	}

CMngRenderer::~CMngRenderer()

	{

	delete iRgbProcessor;

	delete iAlphaProcessor;

	if (NULL != iRgbFilter)

		{

		iRgbFilter->Release();

		iRgbFilter = NULL;

		}

	delete iRgbConsumer;

	delete iAlphaConsumer;

	}

void CMngRenderer::Reset()

	{

	SetOutputEnabled(ETrue);

	iBgColourSet	= EFalse;

	iBgColourIsMandatory = EFalse;

	iBgColour		= KDefaultColor;

	const TPoint KZero(0,0);

	iViewPortOrigin = KZero;

	iClippingRect	= TRect(KZero, iRenderSize.AsPoint());

	iImageClipRect	= iClippingRect;

	iBgClipRect		= iClippingRect;

	// Subframes with No Loops

	// updated rect as empty 

   	UpdateRectEmpty();

	//

	iRgbConsumer->SetClippingRect(iClippingRect);

	iRgbConsumer->SetOrigin(KZero);

	ImageProcessor().SetPos(KZero);

	ImageProcessor().SetYPosIncrement(1);

	if (iAlphaConsumer)

		{

		iAlphaConsumer->SetClippingRect(iClippingRect);

		iAlphaConsumer->SetOrigin(KZero);

		}

	}

/*

Clears the current layer clipping rect

*/

void CMngRenderer::ClearOutputRect()

	{

   	UpdateRect(iBgClipRect);

	if (iBgColourSet && iBgColourIsMandatory)

		{

		iRgbConsumer->Clear( iBgColour, iBgClipRect );

		if (iAlphaConsumer)

			{

			iAlphaConsumer->Clear(KOpaqueAlpha, iBgClipRect);

			}

		}

	else

		{

		if (iAlphaConsumer)

			{

			iAlphaConsumer->Clear(KTransparentAlpha, iBgClipRect);

			if (iDestDisplayMode == EColor16MA && iMaskDisplayMode != EGray256)

				{

				iRgbConsumer->ClearAlpha(KTransparentAlpha, iBgClipRect);

				}

			}

		else

			{

			// no alpha, so clear by available color

			iRgbConsumer->Clear(iBgColour, iBgClipRect );

			}

		}

	}

void CMngRenderer::OnNewImageL()

	{

	if (iAlphaConsumer)

		{

		iAlphaConsumer->SetEnabled(EFalse);

		}

	}

void CMngRenderer::SetBackground(const TRgb aBgColour, TBool aColourIsMandatory)

	{

	iBgColour			= aBgColour.Internal();

	iBgColourIsMandatory= aColourIsMandatory;

	iBgColourSet= ETrue;

	}

void CMngRenderer::SetImageOrigin(const TPoint& aOrigin)

	{

	iViewPortOrigin = aOrigin;

	iRgbConsumer->SetOrigin(aOrigin);

	if (iAlphaConsumer)

		{

		iAlphaConsumer->SetOrigin(aOrigin);	

		}

	}

void CMngRenderer::SetImageClipRect(const TRect& aClippingRect)

	{

	iImageClipRect	= aClippingRect;

	iClippingRect	= aClippingRect;

	iClippingRect.Intersection(iBgClipRect);

	iRgbConsumer->SetClippingRect(iClippingRect);

	if (iAlphaConsumer)

		{

		iAlphaConsumer->SetClippingRect(iClippingRect);	

		}

	}

void CMngRenderer::SetBgClipRect(const TRect& aClippingRect)

	{

	iBgClipRect		= aClippingRect;

	iBgClipRect.Intersection(TRect(TPoint(0,0), iRenderSize.AsPoint()));

	iClippingRect	= iBgClipRect;

	iClippingRect.Intersection(iImageClipRect);

	iRgbConsumer->SetClippingRect(iClippingRect);

	if (iAlphaConsumer)

		{

		iAlphaConsumer->SetClippingRect(iClippingRect);	

		}

	}

void CMngRenderer::SetRgbFilter(MPixelFilter* aPixelFilter)

	{

	if (NULL != iRgbFilter)

		{

		iRgbFilter->Release();

		}

	if (NULL != aPixelFilter)

		{

		aPixelFilter->AddRef();

		}

	iRgbFilter = aPixelFilter;

	iRgbProcessor->SetPixelFilter(aPixelFilter);

	}

//Subframes with No Loops

void CMngRenderer::UpdateRect(const TRect& aRect) 

	{

	/** Top Left Minima */

	if(iUpdateRect.iTl.iX > aRect.iTl.iX )	

		{

		iUpdateRect.iTl.iX = aRect.iTl.iX;

		}

	if(iUpdateRect.iTl.iY > aRect.iTl.iY)

		{

		iUpdateRect.iTl.iY = aRect.iTl.iY;

		}

	/** Bottom Right Maxima */

	if(iUpdateRect.iBr.iX < aRect.iBr.iX )	

		{

		iUpdateRect.iBr.iX = aRect.iBr.iX;

		}

	if(iUpdateRect.iBr.iY < aRect.iBr.iY)

		{

		iUpdateRect.iBr.iY = aRect.iBr.iY;

		}

	}

void CMngRenderer::UpdateRectEmpty()

	{

	const TPoint KZero(0,0);

	iUpdateRect.iBr = KZero;

    iUpdateRect.iTl = iRenderSize.AsPoint();

	}

//

//  from the CImageProcessor //

TBool CPixelProcessor::SetPixelBlock(TRgb* /*aColorBuffer*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetPixels(TRgb* /*aColorBuffer*/,TInt /*aBufferLength*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetMonoPixel(TInt /*aGray256*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetMonoPixelRun(TInt /*aGray256*/,TInt /*aCount*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetMonoPixels(TUint32* /*aGray256Buffer*/,TInt /*aBufferLength*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetMonoPixelBlock(TUint32* /*aGray256Buffer*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CPixelProcessor::SetPos(const TPoint& aPosition)

	{

	iPixelPosition = aPosition;

	return ETrue;

	}

TBool CPixelProcessor::FlushPixels()

	{

	if (NULL != iPixelFilter)

		{

		iPixelFilter->Commit();

		}

	return ETrue;

	}

void CPixelProcessor::PrepareL(CFbsBitmap& /*aBitmap*/,const TRect& aImageRect)

	{

	iCurrentImgSize = aImageRect.Size();

	iPixelsToSkip	= iPixelPadding;

	iYInc			= 1;

	iPixelPosition.SetXY(0,0);

	if (NULL != iPixelConsumer)

		{

		iPixelConsumer->Prepare();	

		}

	if (NULL != iPixelFilter)

		{

		iPixelFilter->PrepareL(iCurrentImgSize, static_cast<CRgbPixelConsumer*>(iPixelConsumer) ); 

		}

	}

void CPixelProcessor::PrepareL(CFbsBitmap& /*aBitmap*/,const TRect& /*aImageRect*/,const TSize& /*aRgbBlockSize*/)

	{

	ASSERT(EFalse);

	}

void CPixelProcessor::SetYPosIncrement(TInt aYInc)

	{

	iYInc = aYInc;

	}

void CPixelProcessor::SetLineRepeat(TInt /*aLineRepeat*/)

	{

	// we don't use progressive decoding

	}

void CPixelProcessor::SetPixelPadding(TInt aNumberOfPixels)

	{

	iPixelPadding = aNumberOfPixels; 

	}

/*static*/

CRgbProcessor* CRgbProcessor::NewL(CMngRenderer* aMngRenderer) 

	{

	return new (ELeave) CRgbProcessor(aMngRenderer); 

	}

CRgbProcessor::CRgbProcessor(CMngRenderer* aMngRenderer):iMngRenderer(aMngRenderer)	

	{

	}

TBool CRgbProcessor::SetPixels(TRgb* aColorBuffer,TInt aBufferLength)

	{

	ASSERT(aBufferLength>0);

	if (aBufferLength > iPixelsToSkip)

		{	

		aBufferLength -= iPixelsToSkip;

		iPixelsToSkip = 0;

		if (iPixelFilter==NULL)

			{		

			do 

				{

				SetPixelImpl(*aColorBuffer++);

				} while (--aBufferLength > 0);

			}

		else

			{

			do

				{

				SetPixelImplWithPf(*aColorBuffer++);

				} while (--aBufferLength > 0);

			}

		}

	else

		{

		iPixelsToSkip -= aBufferLength;

		}		

	return ETrue;

	}

TBool CRgbProcessor::SetPixelRun(TRgb aColor,TInt aCount)

	{

	if (aCount > iPixelsToSkip)

		{

		aCount -= iPixelsToSkip;

		iPixelsToSkip = 0;

		if (iPixelFilter==NULL)

			{

			do

				{

				SetPixelImpl(aColor);

				} while (--aCount);

			}

		else

			{

			do

				{

				SetPixelImplWithPf(aColor);

				} while (--aCount);

			}

		}

	else

		{

		iPixelsToSkip -= aCount;

		}

	return ETrue;

	}

//Subframes with No Loops

//added here

void CRgbProcessor::PrepareL(CFbsBitmap& aBitmap,const TRect& aImageRect)  

	{

	//updation with this new image. new image rect is defined by OriginSet(iViewPortOrigin) and OriginSet+Bottom right calc from aImageRect size

	TSize imageSize(aImageRect.Width(), aImageRect.Height());

	TRect imageRect(iMngRenderer->ViewPortOrigin(),imageSize);

	imageRect.Intersection(iMngRenderer->ClippingRect()); //Bug fix

	iMngRenderer->UpdateRect(imageRect);  

	CPixelProcessor::PrepareL(aBitmap, aImageRect);

	}

//

TBool CRgbProcessor::SetPixel(TRgb aColor)

	{

	if (iPixelsToSkip)

		{

		--iPixelsToSkip;

		return ETrue;

		}

	return iPixelFilter==NULL? SetPixelImpl(aColor) : SetPixelImplWithPf(aColor);

	}

inline 

TBool CRgbProcessor::SetPixelImplWithPf(TRgb aColor)

	{

	iPixelFilter->SetPixel(iPixelPosition, aColor.Internal());

	if (++iPixelPosition.iX == iCurrentImgSize.iWidth)

		{

		iPixelPosition.iX	= 0;

		iPixelPosition.iY  += iYInc;

		iPixelsToSkip		= iPixelPadding;

		}	

	return ETrue;

	}

inline 

TBool CRgbProcessor::SetPixelImpl(TRgb aColor)

	{

	iPixelConsumer->SetPos(iPixelPosition);

	CALL_SETPIXEL_FUNCTION(*Consumer(), iSetPixelFunction)(TRgbaColour(aColor.Internal()));

	if (++iPixelPosition.iX == iCurrentImgSize.iWidth)

		{

		iPixelPosition.iX	= 0;

		iPixelPosition.iY  += iYInc;

		iPixelsToSkip		= iPixelPadding;

		}

	return ETrue;

	}

/*static*/

CAlphaProcessor* CAlphaProcessor::NewL()

	{

	return new (ELeave) CAlphaProcessor();

	}

void CAlphaProcessor::PrepareL(CFbsBitmap& aBitmap, const TRect& aImageRect)

	{

	CPixelProcessor::PrepareL(aBitmap, aImageRect);

	if (Consumer())

		{

		Consumer()->SetEnabled(ETrue);	

		}

	}

TBool CAlphaProcessor::SetPixelRun(TRgb /*aColor*/,TInt /*aCount*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}

TBool CAlphaProcessor::SetPixel(TRgb /*aColor*/)

	{

	ASSERT(EFalse);

	return EFalse;

	}