// 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:

//

#ifndef __MNGRENDERER_H__

#define __MNGRENDERER_H__

/** 	@file

	@internalTechnology */

#include <icl/imageprocessor.h>

#include "PixelConsumer.h"

#include "PixelFilter.h"

class CFbsBitmap;

class CImageProcessor;

class MPixelFilter;

class CRgbPixelConsumer;

class CAlphaPixelConsumer;

class CPixelProcessor: public CImageProcessor 

	{

public:

// from the CImageProcessor //

	TBool SetPixels(TRgb* aColorBuffer,TInt aBufferLength);

	TBool SetMonoPixel(TInt aGray256);

	TBool SetMonoPixelRun(TInt aGray256,TInt aCount);

	TBool SetMonoPixels(TUint32* aGray256Buffer,TInt aBufferLength);

	TBool SetMonoPixelBlock(TUint32* aGray256Buffer);

//Subframes with No Loops 

//virtual keyword added

    virtual void PrepareL(CFbsBitmap& /*aBitmap*/,const TRect& aImageRect);  

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

	void SetYPosIncrement(TInt aYInc);

	void SetLineRepeat(TInt aLineRepeat);

	void SetPixelPadding(TInt aNumberOfPixels);

	TBool SetPixelBlock(TRgb* aColorBuffer);

	TBool SetPos(const TPoint& aPosition);

	TBool FlushPixels();

	inline void SetPixelConsumer(CPixelConsumerBase* aSubFilter);

	inline void SetPixelFilter(MPixelFilter* aFilter);

	inline void SetPixelFunction(CRgbPixelConsumer::SetPixelFunc aSetPixelFunction);

protected:

	TInt			iPixelsToSkip;

	TInt			iPixelPadding;

	TInt			iYInc;

	TPoint			iPixelPosition;

	TSize			iCurrentImgSize;

	CPixelConsumerBase*	iPixelConsumer;

	MPixelFilter*	iPixelFilter;

	CRgbPixelConsumer::SetPixelFunc iSetPixelFunction; // function pointer to either SetRGBPixel or SetRGBAPixel

	};

class CMngRenderer;	//Subframes with No Loops

class CAlphaProcessor;

class CRgbProcessor: public CPixelProcessor 

	{

public:

//Subframes with No Loops

	CRgbProcessor(CMngRenderer* aMngRenderer); 

	static CRgbProcessor* NewL(CMngRenderer* aMngRenderer);  

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

//

	TBool SetPixelRun(TRgb aColor,TInt aCount);

	TBool SetPixel(TRgb aColor);

	TBool SetPixels(TRgb* aColorBuffer,TInt aBufferLength);

protected:	

	inline CRgbPixelConsumer* Consumer() const;

	inline TBool SetPixelImpl(TRgb aColor);

	inline TBool SetPixelImplWithPf(TRgb aColor);

//Subframes with No Loops

private:

    CMngRenderer*   iMngRenderer;

 	};

class CAlphaProcessor: public CPixelProcessor 

	{

public:

	static CAlphaProcessor* NewL();

	TBool SetPixelRun(TRgb aColor,TInt aCount);

	TBool SetPixel(TRgb aColor);

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

protected:

	inline CAlphaPixelConsumer* Consumer() const;

	};

class CMngRenderer: public CBase 

	{

public:

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

	~CMngRenderer();

	void OnNewImageL();

	void SetBackground(const TRgb aBgColour, TBool aColourIsMandatory);

	inline TRgb BgColour() const;

	void ClearOutputRect();

	void Reset();

	void SetImageOrigin(const TPoint& aOrigin);

	void SetImageClipRect(const TRect& aClippingRect);

	void SetBgClipRect(const TRect& aClippingRect);

	inline CImageProcessor& ImageProcessor();

	inline CImageProcessor* MaskProcessor();

	inline void CurrentFrame(CFbsBitmap& aBitmap, const TRect& aSrcRect) const;

	inline void CurrentMask(CFbsBitmap& aBitmap, const TRect& aSrcRect) const;

	void  SetRgbFilter(MPixelFilter* aPixelFilter);

	inline void  SetOutputEnabled(TBool aEnabled);

	inline TBool OutputEnabled() const;

	//Subframes with No Loops

	void UpdateRectEmpty();

	inline const TRect& UpdatedRect() const;

	void UpdateRect(const TRect& aRect);

	inline const TPoint& ViewPortOrigin() const;

	inline const TRect& ClippingRect() const;

	//

protected:

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

	void ConstructL();

protected:

	const TBool			iAlphaNeeded;

	const TSize			iRenderSize;

	TRgbaColour			iBgColour;

	TPoint				iViewPortOrigin;

	TRect				iImageClipRect;	// Current clipping rect for images (i.e. by DEFI)

	TRect				iBgClipRect;	// Current clipping rect for layers (i.e. by FRAM)

	TRect				iClippingRect;	// Current effective clipping rect (intersection of above two)

	//Subframes with No Loops

	TRect				iUpdateRect;

	//

	TPoint				iPixelPosition;

	TSize				iCurrentImgSize;

	TBool				iOutputEnbaled;

	MPixelFilter*		iRgbFilter;

	CPixelProcessor*	iRgbProcessor;

	CPixelProcessor*	iAlphaProcessor;

	CRgbPixelConsumer*	iRgbConsumer;

	CAlphaPixelConsumer*iAlphaConsumer;

	TBool				iBgColourSet;

	TBool				iBgColourIsMandatory;

	TDisplayMode		iDestDisplayMode;

	TDisplayMode		iMaskDisplayMode;

	};

#include "Mngrenderer.inl"

#endif // ndef __MNGRENDERER_H__