#include "dsa.h"

#include "sdlepocapi.h"

#include <cdsb.h>

LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)

	{

	return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1; 

	}

template<class T>

NONSHARABLE_CLASS(CBitmapSurface) : public T

	{

public:

	CBitmapSurface(RWsSession& aSession);

private:

	void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

	~CBitmapSurface();

	TUint8* LockSurface();

	void UnlockHwSurface();

	void CreateSurfaceL();

	void Wipe(TInt aLength);

	void Free();

	void Update(CFbsBitmap& aBmp);

	TInt ExternalUpdate();

private:

	CFbsBitmap* iBmp;

	CFbsBitmap* iCopyBmp;

	};

template<class T>

void CBitmapSurface<T>::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)		

	{

	delete iCopyBmp;

	iCopyBmp = NULL;

	iCopyBmp = new (ELeave) CFbsBitmap();

	T::ConstructL(aWindow, aDevice);

	}

template<class T>

CBitmapSurface<T>::CBitmapSurface(RWsSession& aSession) : T(aSession)

	{

	}

template<class T>

void CBitmapSurface<T>::Free()

	{

	delete iBmp;

	iBmp = NULL;

	T::Free();

	}

template<class T>

CBitmapSurface<T>::~CBitmapSurface()

	{

	__ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));

	delete iCopyBmp;

	}

template<class T>

TUint8* CBitmapSurface<T>::LockSurface()

	{

	iBmp->LockHeap();

	return reinterpret_cast<TUint8*>(iBmp->DataAddress());

	}

template<class T>

void CBitmapSurface<T>::UnlockHwSurface()

	{

	iBmp->UnlockHeap();

	T::SetUpdating(EFalse);

	Update(*iBmp);

	}

template<class T>	

void CBitmapSurface<T>::Update(CFbsBitmap& aBmp)

	{

	if(!T::Blitter(aBmp))

		{

		if(T::SwSize() == T::HwRect().Size())

			T::Gc().BitBlt(T::HwRect().iTl, &aBmp);

		else

			T::Gc().DrawBitmap(T::HwRect(), &aBmp);

		}

	T::DrawOverlays();

	T::CompleteUpdate();	

	}

template<class T>	

void CBitmapSurface<T>::CreateSurfaceL()

	{

	Free();

	iBmp  = new (ELeave) CFbsBitmap();

	User::LeaveIfError(iBmp->Create(T::SwSize(), T::DisplayMode()));

	T::CreateSurfaceL(*iBmp);

	}

template<class T>

void CBitmapSurface<T>::Wipe(TInt aLength) //dont call in drawing

	{

	iBmp->LockHeap();

	Mem::FillZ(iBmp->DataAddress(), aLength);

	iBmp->UnlockHeap();

	}

template<class T>		

TInt CBitmapSurface<T>::ExternalUpdate()

	{

	if(iCopyBmp->Handle() == 0)

		{

		const TInt err = iCopyBmp->Duplicate(iBmp->Handle());

		if(err != KErrNone)

			return err;

		}

	Update(*iCopyBmp);

	return KErrNone;

	}

//////////////////////////////////////////////////////////////////////

NONSHARABLE_CLASS(CDsaBitgdi) : public CDsa

	{

public:

	CDsaBitgdi(RWsSession& aSession);

protected:

	 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

	 CBitmapContext& Gc();

	 void CompleteUpdate();

	 ~CDsaBitgdi();

	 void CreateSurfaceL(CFbsBitmap& aBmp);

	 void Free();

	 void UnlockHWSurfaceRequestComplete();

private:

	 void Resume();

	 CFbsBitGc* iGc;

	 CFbsDevice* iDevice;

	 CFbsBitmap* iBitGdiBmp;

	 CWindowGc* iWinGc;

	 RWindow* iWindow;

	 TInt iHandle;

	 };

CDsaBitgdi::CDsaBitgdi(RWsSession& aSession) : CDsa(aSession)

	{

	}

CDsaBitgdi::~CDsaBitgdi()

	{

	delete iWinGc;

	delete iBitGdiBmp;

	}

void CDsaBitgdi::CompleteUpdate()

	{

	EpocSdlEnv::Request(CDsa::ERequestUpdate);

	}

void CDsaBitgdi::UnlockHWSurfaceRequestComplete()

	{

	if(iHandle == 0)

		return;

	if(iBitGdiBmp == NULL)

		{

		iBitGdiBmp = new CFbsBitmap();

		if(iBitGdiBmp == NULL)

			return;

		iBitGdiBmp->Duplicate(iHandle);

		}

	iWindow->Invalidate();

	iWindow->BeginRedraw();

	iWinGc->Activate(*iWindow);

	iWinGc->BitBlt(TPoint(0, 0), iBitGdiBmp);

	iWinGc->Deactivate();

	iWindow->EndRedraw();

	}	

void CDsaBitgdi::Resume()

	{

	Start();

	}

CBitmapContext& CDsaBitgdi::Gc()

 	{

 	return *iGc;

 	}

 void CDsaBitgdi::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)

 	{

 	delete iBitGdiBmp;

 	iBitGdiBmp = NULL;

 	delete iWinGc;

 	iWinGc = NULL;

 	iHandle = 0;

 	iWindow = &aWindow;

 	User::LeaveIfError(aDevice.CreateContext(iWinGc));

 	CDsa::ConstructL(aWindow, aDevice);

 	Start();

 	}

void CDsaBitgdi::CreateSurfaceL(CFbsBitmap& aBmp)	

	{

	iDevice = CFbsBitmapDevice::NewL(&aBmp);

	User::LeaveIfError(iDevice->CreateContext(iGc));

	iHandle = aBmp.Handle();

	}

void CDsaBitgdi::Free()

	{

	delete iGc;

	iGc = NULL;

	delete iDevice;

	iDevice = NULL;

	}

////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////

NONSHARABLE_CLASS(CDsaBase) : public CDsa, public MDirectScreenAccess

	{

protected:	

	inline CDirectScreenAccess& Dsa() const;

	CDsaBase(RWsSession& aSession);

	~CDsaBase();

	void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

	void Stop();

	void Resume();

	CBitmapContext& Gc();

protected:

    CDirectScreenAccess*  iDsa;

private:

	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

private:

	void RestartL();

	};

inline CDirectScreenAccess& CDsaBase::Dsa() const

	{

	return *iDsa;

	}

CDsaBase::CDsaBase(RWsSession& aSession) : CDsa(aSession)

	{

	}

CBitmapContext& CDsaBase::Gc()

	{

	return *Dsa().Gc();

	}

void CDsaBase::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)

    {

    CDsa::ConstructL(aWindow, aDevice);

    if(iDsa != NULL)

    	{

    	iDsa->Cancel();

    	delete iDsa;

    	iDsa = NULL;

    	}

    iDsa = CDirectScreenAccess::NewL(

    				Session(),

					aDevice,

					aWindow,

					*this);				

    RestartL();

    }	

void CDsaBase::Resume()	

	{

	if(Stopped())

		Restart(RDirectScreenAccess::ETerminateRegion);

	}	

CDsaBase::~CDsaBase()

	{

	if(iDsa != NULL)

        {

        iDsa->Cancel();

        }

    delete iDsa;

	}

void CDsaBase::RestartL()

    {

    iDsa->StartL();	

    const RRegion* r = iDsa->DrawingRegion();

    const TRect rect = r->BoundingRect();

    iDsa->Gc()->SetClippingRegion(r);	

    if(rect != ScreenRect())

    	{

    	return ;	

   	 	}

   	SetTargetRect();

	RecreateL();

	Start();

    }

void CDsaBase::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)

	{

	Stop();

	}

void CDsaBase::Restart(RDirectScreenAccess::TTerminationReasons aReason)

	{

	if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart

		{												

		TRAPD(err, RestartL());

		PANIC_IF_ERROR(err);

		}

	}

void CDsaBase::Stop()

	{

	CDsa::Stop();

	iDsa->Cancel();

	}

   ///////////////////////////////////////////////////////////////////////

   /////////////////////////////////////////////////////////////////////// 

NONSHARABLE_CLASS(TDsa)

	{

	public:

		inline TDsa(const CDsa& aDsa);

		inline TBool IsFlip() const;

		inline TBool IsTurn() const;

		inline const TSize& SwSize() const;

		inline void Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const;

	private:

		const CDsa& iDsa;

	};

inline TDsa::TDsa(const CDsa& aDsa) : iDsa(aDsa)

	{	

	}

inline TBool TDsa::IsTurn() const

	{

	return iDsa.iStateFlags & CDsa::EOrientation90;

	}

inline TBool TDsa::IsFlip() const

	{

	return iDsa.iStateFlags & CDsa::EOrientation180;

	}	

inline const TSize& TDsa::SwSize() const

	{

	return iDsa.SwSize();

	}

inline void TDsa::Copy(TUint32* aTarget, const TUint8* aSrc, TInt aBytes, TInt aHeight) const

	{

	iDsa.iCopyFunction(iDsa, aTarget, aSrc, aBytes, aHeight);

	}

template<class T, class S>	

void ClipCopy(const TDsa& iDsa, TUint8* aTarget,

 					const TUint8* aSource,

 					const TRect& aUpdateRect,

 					const TRect& aSourceRect)

	{

	const S* source = reinterpret_cast<const S*>(aSource);

	const TInt lineWidth = aSourceRect.Width();

	source += (aUpdateRect.iTl.iY * lineWidth); 

	const TInt sourceStartOffset = aUpdateRect.iTl.iX;

	source += sourceStartOffset;

	T* targetPtr = reinterpret_cast<T*>(aTarget);

	const TInt scanLineWidth = iDsa.SwSize().iWidth;

	targetPtr += (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * scanLineWidth; 

	const TInt targetStartOffset = (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);

	targetPtr += targetStartOffset;

	const TInt height = aUpdateRect.Height(); 

	const TInt lineMove = iDsa.IsTurn() ? 1 : lineWidth;

	const TInt copyLen = aUpdateRect.Width();

	if(iDsa.IsFlip())

		{

		targetPtr += scanLineWidth *  (height - 1);

		for(TInt i = 0; i < height; i++) //source is always smaller

			{

			iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);

			source += lineMove;

			targetPtr -= scanLineWidth;

			}

		}

	else

		{

		for(TInt i = 0; i < height; i++) //source is always smaller

			{

			iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);

			source += lineMove;

			targetPtr += scanLineWidth; // >> 2;

			}

		}

	}

NONSHARABLE_CLASS(CDsaA) : public CDsaBase

	{

	public:

		CDsaA(RWsSession& aSession);

	protected:

		void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);

		void CompleteUpdate();

		void CreateSurfaceL(CFbsBitmap& aBmp);

		void Free();

		void UnlockHWSurfaceRequestComplete();	

	};

CDsaA::CDsaA(RWsSession& aSession) : CDsaBase(aSession)

	{

	}

void CDsaA::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)		

	{

	CDsaBase::ConstructL(aWindow, aDevice);

	}

void CDsaA::CompleteUpdate()

	{

	iDsa->ScreenDevice()->Update();

	}

void CDsaA::CreateSurfaceL(CFbsBitmap& /*aBmp*/)

	{

	}

void CDsaA::Free()

	{

	}

void CDsaA::UnlockHWSurfaceRequestComplete()

	{

	PANIC(KErrNotSupported);

	}	

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

NONSHARABLE_CLASS(MDsbObs)

	{

	public:

		virtual void SurfaceReady() = 0;

		virtual CDirectScreenBitmap& Dsb() = 0;

	};

NONSHARABLE_CLASS(CDsbSurface) : public CActive

	{

	public:

		CDsbSurface(MDsbObs& aDsb);

		TUint8* Address();

		void Complete();

		~CDsbSurface();

	private:

		void RunL();

		void DoCancel();

	private:

		MDsbObs& iDsb; 

		TUint8* iAddress;

	};	

CDsbSurface::CDsbSurface(MDsbObs& aDsb) : CActive(CActive::EPriorityHigh) , iDsb(aDsb)

	{

	CActiveScheduler::Add(this);

	}

CDsbSurface::~CDsbSurface()

	{

	Cancel();

	}

void CDsbSurface::Complete()

	{

	if(iAddress != NULL && !IsActive())