--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA2/dsa.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,1504 @@
+#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>
+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())
+		{
+		iAddress = NULL;
+		SetActive();
+		iDsb.Dsb().EndUpdate(iStatus);
+		}
+	}
+	
+TUint8* CDsbSurface::Address()
+	{
+	if(iAddress == NULL && !IsActive())
+		{
+		TAcceleratedBitmapInfo info;
+		if(KErrNone == iDsb.Dsb().BeginUpdate(info))
+			iAddress = info.iAddress;
+		}
+	return iAddress;
+	}
+	
+void CDsbSurface::RunL()
+	{
+	iDsb.SurfaceReady();
+	}
+
+void CDsbSurface::DoCancel()
+	{
+	//empty
+	}
+		
+NONSHARABLE_CLASS(CDsaB) : public CDsaBase,
+ public MDsbObs
+	{
+	public:
+		CDsaB(RWsSession& aSession, TInt aFlags);
+	private:
+		~CDsaB();
+		TUint8* LockSurface();
+		void UnlockHWSurfaceRequestComplete();
+		void UnlockHwSurface();
+		void CreateSurfaceL();
+		void Wipe(TInt aLength);
+		void RecreateL();
+		void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
+		CDirectScreenBitmap& Dsb();
+		void SurfaceReady();
+		TInt ExternalUpdate();
+	private:
+		CDsbSurface* iSurface1;
+		CDsbSurface* iSurface2;
+		CDirectScreenBitmap* iDsb;
+		TInt iType;
+	};
+
+CDsaB::CDsaB(RWsSession& aSession, TInt aFlags) : CDsaBase(aSession), iType(aFlags)
+	{
+	}
+
+
+	
+void CDsaB::UnlockHWSurfaceRequestComplete()
+	{
+	iSurface1->Complete();
+	if(iSurface2 != NULL)
+		iSurface2->Complete();
+	}	
+
+void CDsaB::CreateSurfaceL()
+	{
+	__ASSERT_ALWAYS(SwSize() == HwRect().Size(), PANIC(KErrNotSupported));
+	}
+	
+void CDsaB::Wipe(TInt aLength) //dont call in drawing
+	{
+	TUint8* addr = LockSurface();
+	if(addr != NULL) 
+		{
+		Mem::FillZ(addr, aLength);
+		UnlockHwSurface();
+		}
+	}
+	
+
+void CDsaB::UnlockHwSurface()
+	{
+	EpocSdlEnv::Request(CDsa::ERequestUpdate);
+	}
+	
+TUint8* CDsaB::LockSurface()
+	{
+	TUint8* addr =  iSurface1->Address();
+	if(addr == NULL && iSurface2 != NULL)
+		addr =  iSurface2->Address();
+	SetUpdating(addr == NULL);
+	return addr;
+	}
+	
+void CDsaB::SurfaceReady()	
+	{
+	SetUpdating(EFalse);
+	}
+
+CDirectScreenBitmap& CDsaB::Dsb()
+	{
+	return *iDsb;
+	}
+	
+void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
+	{
+	if(iDsb == NULL)
+		iDsb = CDirectScreenBitmap::NewL();	
+	CDsaBase::ConstructL(aWindow, aDevice);
+	if(iSurface1 == NULL)	
+		iSurface1 = new (ELeave) CDsbSurface(*this);
+	if(iSurface2 == NULL && iType & CDirectScreenBitmap::EDoubleBuffer)
+		iSurface2 = new (ELeave) CDsbSurface(*this);
+	}
+	
+CDsaB::~CDsaB()
+	{
+	delete iSurface1;
+	delete iSurface2;
+	delete iDsb;
+	}	
+
+void CDsaB::RecreateL()
+	{
+    iDsb->Close();
+    iDsb->Create(HwRect(), CDirectScreenBitmap::TSettingsFlags(iType));
+	}
+	
+TInt CDsaB::ExternalUpdate()
+	{
+	if(LockSurface())
+		{
+		UnlockHWSurfaceRequestComplete();
+		return KErrNone;
+		}
+	return KErrNotReady;
+	}
+		
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////	
+
+
+
+CDsa* CDsa::CreateL(RWsSession& aSession)
+	{
+	if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB))
+		{
+		TInt flags = CDirectScreenBitmap::ENone;
+		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer))
+			flags |= CDirectScreenBitmap::EDoubleBuffer;
+		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrementalUpdate))
+			flags |= CDirectScreenBitmap::EIncrementalUpdate;
+		return new (ELeave) CDsaB(aSession, flags);
+		}
+	else if(EpocSdlEnv::Flags(CSDL::EDrawModeGdi))
+		{
+		return new (ELeave) CBitmapSurface<CDsaBitgdi>(aSession);
+		}
+    else
+    	{
+        return new (ELeave) CBitmapSurface<CDsaA>(aSession);
+		}
+	}
+	
+	
+void CDsa::RecreateL()
+	{
+	}
+
+void CDsa::Free()
+	{
+	}
+	
+TSize CDsa::WindowSize() const
+	{
+	TSize size = iSwSize;
+	if(iStateFlags & EOrientation90)
+		{
+		const TInt tmp = size.iWidth;
+		size.iWidth = size.iHeight;
+		size.iHeight = tmp;
+		}
+	return size;
+	}
+	
+void CDsa::SetSuspend()
+	{
+	iStateFlags |= ESdlThreadSuspend;
+	}
+
+
+void CDsa::SetUpdating(TBool aUpdate)
+	{
+	if(aUpdate)
+		iStateFlags |= EUpdating;
+	else
+		iStateFlags &= ~EUpdating;
+	}
+
+
+TBool CDsa::Stopped() const
+	{
+	return (iStateFlags & ESdlThreadExplicitStop);
+	}
+
+void CDsa::SetOrientation(CSDL::TOrientationMode aOrientation)
+	{
+	TInt flags = 0;
+	switch(aOrientation)
+		{
+		case CSDL::EOrientation90:
+			flags = EOrientation90;
+			break;
+		case CSDL::EOrientation180:
+			flags = EOrientation180;
+			break;
+		case CSDL::EOrientation270:
+			flags = EOrientation90 | EOrientation180;
+			break;
+		case CSDL::EOrientation0:
+			flags = 0;
+			break;
+		}
+	if(flags != (iStateFlags & EOrientationFlags))
+		{
+		iStateFlags |= EOrientationChanged;
+		iNewFlags = flags; //cannot be set during drawing...
+		}
+	}
+
+CDsa::~CDsa()
+    {
+    iOverlays.Close();
+    User::Free(iLut256);
+    }
+         
+void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)
+    {			
+	if(iLut256 == NULL)
+		iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));
+	iTargetMode = aWindow.DisplayMode();
+	iTargetBpp = BytesPerPixel(DisplayMode());
+	iScreenRect = TRect(aWindow.Position(), aWindow.Size());
+	SetTargetRect();
+    }
+    
+void CDsa::DrawOverlays()
+	{
+	const TInt last = iOverlays.Count() - 1;
+	for(TInt i = last; i >= 0 ; i--)
+		iOverlays[i].iOverlay->Draw(Gc(), HwRect(), SwSize());
+	}
+
+TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority)
+	{
+	TInt i;
+	for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++)
+		{}
+	const TOverlay overlay = {&aOverlay, aPriority};
+	return iOverlays.Insert(overlay, i);
+	}
+	
+TInt CDsa::RemoveOverlay(MOverlay& aOverlay)
+	{
+	for(TInt i = 0; i < iOverlays.Count(); i++)
+		{
+		if(iOverlays[i].iOverlay == &aOverlay)
+			{
+			iOverlays.Remove(i);
+			return KErrNone;
+			}
+		}
+	return KErrNotFound;
+	}
+
+void CDsa::LockPalette(TBool aLock)
+	{
+	if(aLock)
+		iStateFlags |= EPaletteLocked;
+	else
+		iStateFlags &= ~EPaletteLocked;
+	}
+TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette)
+	{
+	if(iLut256 == NULL)
+		return KErrNotFound;
+	const TInt count = aCount - aFirst;
+	if(count > 256)
+		return KErrArgument;
+	if(iStateFlags & EPaletteLocked)
+		return KErrNone;
+	for(TInt i = aFirst; i < count; i++) //not so busy here:-)
+		{
+		iLut256[i] = aPalette[i];
+		}
+	return KErrNone;
+	}
+	
+	
+
+
+    
+CDsa::CDsa(RWsSession& aSession) : 
+ 	iSession(aSession),
+  	iStateFlags(0)
+	{
+//	CActiveScheduler::Add(this);
+	iCFTable[0] = CopyMem;
+	iCFTable[1] = CopyMemFlipReversed;
+	iCFTable[2] = CopyMemReversed;
+	iCFTable[3] = CopyMemFlip;	
+	
+	iCFTable[4] = Copy256;
+	iCFTable[5] = Copy256FlipReversed;
+	iCFTable[6] = Copy256Reversed;
+	iCFTable[7] = Copy256Flip;	
+	
+	
+	iCFTable[8] = CopySlow;
+	iCFTable[9] = CopySlowFlipReversed;
+	iCFTable[10] = CopySlowReversed;
+	iCFTable[11] = CopySlowFlip;	
+	}
+	
+RWsSession& CDsa::Session()
+	{
+	return iSession;
+	}
+
+TInt CDsa::RedrawRequest()
+	{
+	if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning)))
+		{
+		return ExternalUpdate();
+		}
+	return KErrNotReady;
+	}
+
+TUint8* CDsa::LockHwSurface()
+	{
+	if((iStateFlags & EUpdating) == 0) //else frame is skipped
+		{
+		return LockSurface();
+		}
+	return NULL; 
+	}
+
+/*	
+void CDsa::RunL()
+	{
+	iStateFlags &= ~EUpdating;
+	}
+		
+	
+void CDsa::DoCancel()
+	{
+	iStateFlags &= ~EUpdating;
+	//nothing can do, just wait?
+	}
+*/	
+
+	
+TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode)
+	{
+	if(aHwSurface && aMode != DisplayMode())
+		return KErrArgument;
+	
+	iSourceMode = aMode;
+	
+	iSourceBpp = BytesPerPixel(aMode);
+	
+	const TSize size = WindowSize();
+	if(aSize.iWidth > size.iWidth)
+		return KErrTooBig;
+	if(aSize.iHeight > size.iHeight)
+		return KErrTooBig;
+	
+	TRAPD(err, CreateSurfaceL());
+	if(err != KErrNone)
+		return err;
+
+	SetCopyFunction();
+	
+	return KErrNone;
+	}
+	
+
+void CDsa::CreateZoomerL(const TSize& aSize)
+	{
+	iSwSize = aSize;
+	iStateFlags |= EResizeRequest;
+	CreateSurfaceL();
+	SetTargetRect();
+	}
+	
+
+/*
+void SaveBmp(const TDesC& aName, const TAny* aData, TInt aLength, const TSize& aSz, TDisplayMode aMode)
+	{
+	CFbsBitmap* s = new CFbsBitmap();
+	s->Create(aSz, aMode);
+	s->LockHeap();
+	TUint32* addr = s->DataAddress();
+	Mem::Copy(addr, aData, aLength);
+	s->UnlockHeap();
+	s->Save(aName);
+	s->Reset();
+	delete s;
+	}
+	
+void SaveBmp(const TDesC& aName, const TUint32* aData, const TSize& aSz)
+	{
+	CFbsBitmap* s = new CFbsBitmap();
+	s->Create(aSz, EColor64K);
+	TBitmapUtil bmp(s);
+	bmp.Begin(TPoint(0, 0));
+	for(TInt j = 0; j < aSz.iHeight; j++)
+		{
+		bmp.SetPos(TPoint(0, j));
+		for(TInt i = 0; i < aSz.iWidth; i++)
+			{
+			bmp.SetPixel(*aData);
+			aData++;
+			bmp.IncXPos();
+			}
+		}
+	bmp.End();
+	s->Save(aName);
+	s->Reset();
+	delete s;
+	}	
+	
+TBuf<16> FooName(TInt aFoo)
+	{
+	TBuf<16> b;
+	b.Format(_L("C:\\pic%d.mbm"), aFoo);
+	return b;
+	}
+	
+*/
+
+
+void CDsa::ClipCopy(TUint8* aTarget,
+ 					const TUint8* aSource,
+ 					const TRect& aUpdateRect,
+ 					const TRect& aSourceRect) const
+ 		{
+ 		const TDsa dsa(*this);
+ 		switch(iSourceBpp)
+ 			{
+ 			case 1:
+ 				::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
+ 				break;
+ 			case 2:
+ 				::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
+ 				break;
+ 			case 4:
+ 				::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
+ 				break;
+ 			}
+ 		}	
+
+
+void CDsa::Wipe() //dont call in drawing
+	{
+	if(IsDsaAvailable())
+		Wipe(iTargetBpp * SwSize().iWidth * SwSize().iHeight);
+	}
+	
+void CDsa::SetCopyFunction()
+	{
+	//calculate offset to correct function in iCFTable according to given parameters
+	TInt function = 0;
+	const TInt KCopyFunctions = 4;
+	const TInt KOffsetToNative = 0;
+	const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions;
+	const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;
+	const TInt KOffsetTo90Functions = 1;
+	const TInt KOffsetTo180Functions = 2;
+	
+	if(iSourceMode == DisplayMode())
+		function = KOffsetToNative; 		//0
+	else if(iSourceMode == EColor256)
+		function = KOffsetTo256;			//4
+	else
+		function = KOffsetToOtherModes; 	//8
+	
+	if(iStateFlags & EOrientation90)
+		function += KOffsetTo90Functions; 	// + 1
+	if(iStateFlags & EOrientation180)
+		function += KOffsetTo180Functions; 	//+ 2
+	
+	iCopyFunction = iCFTable[function];
+	
+	Wipe();
+	}
+	
+inline void Rotate(TRect& aRect)
+	{
+	const TInt dx = aRect.iBr.iX - aRect.iTl.iX;
+	const TInt dy = aRect.iBr.iY - aRect.iTl.iY;
+
+	aRect.iBr.iX = aRect.iTl.iX + dy;
+	aRect.iBr.iY = aRect.iTl.iY + dx;
+	
+	const TInt tmp = aRect.iTl.iX;
+	aRect.iTl.iX = aRect.iTl.iY;
+	aRect.iTl.iY = tmp;
+	}
+	
+/*	
+int bar = 0;
+*/	
+
+TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
+	{
+
+	if(iStateFlags & EOrientationChanged)
+		{
+		iStateFlags &= ~EOrientationFlags;
+		iStateFlags |= iNewFlags;
+		SetCopyFunction();
+		iStateFlags &= ~EOrientationChanged;
+	    EpocSdlEnv::WaitDeviceChange();
+	    return EFalse; //skip this frame as data is may be changed
+		}
+
+	if(iTargetAddr == NULL)
+		{
+		iTargetAddr = LockHwSurface();
+		}
+		
+	TUint8* target = iTargetAddr;
+	if(target == NULL)
+		return EFalse;
+	
+	
+	TRect targetRect = TRect(TPoint(0, 0), SwSize());
+	
+	TRect sourceRect = aRect;
+	TRect updateRect = aUpdateRect;
+	
+//	TPoint move(0, 0);
+	
+	
+	if(iStateFlags & EOrientation90)
+		{
+		Rotate(sourceRect);
+		Rotate(updateRect);
+		}
+		
+	if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))
+		{
+		sourceRect.Intersection(targetRect); //so source always smaller or equal than target
+		//updateRect.Intersection(targetRect);
+		ClipCopy(target, aBits, updateRect, sourceRect);
+		}
+	else
+		{
+		const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored
+		Mem::Copy(target, aBits, byteCount);
+		}
+
+	return ETrue;
+	}
+	
+		
+void CDsa::UpdateSwSurface()
+	{
+	iTargetAddr = NULL;
+	UnlockHwSurface();	//could be faster if does not use AO, but only check status before redraw, then no context switch needed
+	}
+	
+
+
+	
+void CDsa::DoStop()
+	{
+	if(IsDsaAvailable())
+		iStateFlags |= ESdlThreadExplicitStop;
+	Stop();
+	}
+
+	
+void CDsa::Stop()
+	{
+	iStateFlags &= ~ERunning;
+	}
+	
+void CDsa::Start()
+	{
+    iStateFlags |= ERunning;
+	
+	iStateFlags &= ~ESdlThreadExplicitStop;
+ 
+    if(iStateFlags & ESdlThreadSuspend)
+    	{
+    	EpocSdlEnv::Resume();
+    	iStateFlags &= ~ ESdlThreadSuspend;
+    	}	
+    EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);	
+	}
+
+
+TBool CDsa::Blitter(CFbsBitmap& aBmp)
+	{
+	return iBlitter && iBlitter->BitBlt(Gc(), aBmp, HwRect(), SwSize());	
+	}
+	
+void CDsa::SetBlitter(MBlitter* aBlitter)
+	{
+	iBlitter = aBlitter;
+	}
+	
+	
+TPoint CDsa::WindowCoordinates(const TPoint& aPoint) const	
+	{
+	TPoint pos = aPoint - iScreenRect.iTl;
+	const TSize asz = iScreenRect.Size();
+	if(iStateFlags & EOrientation180)
+		{
+		pos.iX = asz.iWidth - pos.iX;
+		pos.iY = asz.iHeight - pos.iY;	
+		}	
+	if(iStateFlags & EOrientation90)
+		{
+		pos.iX = aPoint.iY;
+		pos.iY = aPoint.iX;	
+		}
+	pos.iX <<= 16;
+	pos.iY <<= 16;
+	pos.iX /= asz.iWidth; 
+	pos.iY /= asz.iHeight;
+	pos.iX *= iSwSize.iWidth;
+	pos.iY *= iSwSize.iHeight;
+	pos.iX >>= 16;
+	pos.iY >>= 16;
+	return pos; 	
+	}
+	
+void CDsa::SetTargetRect()
+	{
+	iTargetRect = iScreenRect;
+	if(iStateFlags & EResizeRequest && EpocSdlEnv::Flags(CSDL::EAllowImageResizeKeepRatio))
+		{
+		const TSize asz = iScreenRect.Size();
+		const TSize sz = iSwSize;
+		
+		TRect rect;
+		
+		const TInt dh = (sz.iHeight << 16) / sz.iWidth;
+
+		if((asz.iWidth * dh ) >> 16 <= asz.iHeight)
+			{
+			rect.SetRect(TPoint(0, 0), TSize(asz.iWidth, (asz.iWidth * dh) >> 16));
+			}
+		else
+			{
+			const TInt dw = (sz.iWidth << 16) / sz.iHeight;
+	    	rect.SetRect(TPoint(0, 0), TSize((asz.iHeight * dw) >> 16, asz.iHeight));
+			}
+		rect.Move((asz.iWidth - rect.Size().iWidth) >> 1, (asz.iHeight - rect.Size().iHeight) >> 1);  
+		
+		iTargetRect = rect;
+		iTargetRect.Move(iScreenRect.iTl);
+
+		} 
+	if(!(iStateFlags & EResizeRequest))
+		iSwSize = iScreenRect.Size();
+
+	}
+		
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	TUint32* target = aTarget;
+	const TUint32* endt = target + aBytes; 
+	const TUint8* source = aSource;
+	while(target < endt)
+		{
+		*target++ = aDsa.iLut256[*source++]; 
+		}
+	}
+	
+void CDsa::Copy256Reversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	const TUint32* target = aTarget;
+	TUint32* endt = aTarget + aBytes; 
+	const TUint8* source = aSource;
+	while(target < endt)
+		{
+		*(--endt) = aDsa.iLut256[*source++]; 
+		}
+	}	
+	
+void CDsa::Copy256Flip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	TUint32* target = aTarget;
+	const TUint32* endt = target + aBytes; 
+	const TUint8* column = aSource;
+
+	while(target < endt)
+		{
+		*target++ = aDsa.iLut256[*column];
+		column += aLineLen;
+		}
+	}
+	
+void CDsa::Copy256FlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	const TUint32* target = aTarget;
+	TUint32* endt = aTarget + aBytes; 
+	const TUint8* column = aSource;
+
+	while(target < endt)
+		{
+		*(--endt) = aDsa.iLut256[*column];
+		column += aLineLen;
+		}
+	}		
+
+void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	const TUint32* src = reinterpret_cast<const TUint32*>(aSource);
+	Mem::Copy(aTarget, src, aBytes << 2);
+	}
+	
+void CDsa::CopyMemFlip(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	TUint32* target = aTarget;
+	const TUint32* endt = target + aBytes; 
+	const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
+
+	while(target < endt)
+		{
+		*target++ = *column;
+		column += aLineLen;
+		}
+	}
+	
+void CDsa::CopyMemReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	const TUint32* target = aTarget;
+	TUint32* endt = aTarget + aBytes; 
+	const TUint32* source = reinterpret_cast<const TUint32*>(aSource);
+	while(target < endt)
+		{
+		*(--endt) = *source++; 
+		}
+	}	
+	
+	
+void CDsa::CopyMemFlipReversed(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	const TUint32* target = aTarget;
+	TUint32* endt = aTarget + aBytes; 
+	const TUint32* column = reinterpret_cast<const TUint32*>(aSource);
+
+	while(target < endt)
+		{
+		*(--endt) = *column;
+		column += aLineLen;
+		}
+	}
+			
+/*
+
+LOCAL_C TRgb rgb16MA(TInt aValue)
+	{
+	return TRgb::Color16MA(aValue);
+	}
+*/	
+NONSHARABLE_CLASS(MRgbCopy)
+	{
+	public:
+	virtual void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed) = 0;
+	virtual void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed) = 0;
+	};
+	
+template <class T>
+NONSHARABLE_CLASS(TRgbCopy) : public MRgbCopy
+	{
+	public:
+	TRgbCopy(TDisplayMode aMode);
+	void* operator new(TUint aBytes, TAny* aMem);
+	void Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed);
+	void FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed);
+	static TUint32 Gray256(const TUint8& aPixel);
+	static TUint32 Color256(const TUint8& aPixel);
+	static TUint32 Color4K(const TUint16& aPixel);
+	static TUint32 Color64K(const TUint16& aPixel);
+	static TUint32 Color16M(const TUint32& aPixel);
+	static TUint32 Color16MU(const TUint32& aPixel);
+	static TUint32 Color16MA(const TUint32& aPixel);
+	private:
+		typedef TUint32 (*TRgbFunc) (const T& aValue);
+		TRgbFunc iFunc;
+	};
+		
+		
+template <class T>		
+void* TRgbCopy<T>::operator new(TUint /*aBytes*/, TAny* aMem)
+	{
+	return aMem;
+	}
+		
+template <class T>
+TRgbCopy<T>::TRgbCopy(TDisplayMode aMode)
+	{
+	switch(aMode)
+		{
+		case EGray256 : iFunc = (TRgbFunc) Gray256; break;
+		case EColor256 : iFunc =  (TRgbFunc) Color256; break;
+		case EColor4K : iFunc =  (TRgbFunc) Color4K; break;
+		case EColor64K : iFunc =  (TRgbFunc) Color64K; break;
+		case EColor16M : iFunc =  (TRgbFunc) Color16M; break;
+		case EColor16MU : iFunc =  (TRgbFunc) Color16MU; break;
+		case EColor16MA : iFunc =  (TRgbFunc) Color16MA; break;
+		default:
+			PANIC(KErrNotSupported);
+		}
+	}
+	
+template <class T>
+void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TBool aReversed)
+	{
+	const T* source = reinterpret_cast<const T*>(aSource);
+	TUint32* target = aTarget;
+	TUint32* endt = target + aBytes;
+	
+	if(aReversed)
+		{
+		while(target < endt)
+			{
+			const T value = *source++;
+			*(--endt) = iFunc(value);//iFunc(value).Value();
+			}
+		}
+	else
+		{
+		while(target < endt)
+			{
+			const T value = *source++;
+			*target++ = iFunc(value);//iFunc(value).Value();
+			}
+		}
+	}
+	
+template <class T>
+void TRgbCopy<T>::FlipCopy(TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen, TBool aReversed)
+	{
+	const T* column = reinterpret_cast<const T*>(aSource);
+	TUint32* target = aTarget;
+	TUint32* endt = target + aBytes;
+	
+	if(aReversed)
+		{
+		while(target < endt)
+			{
+			*(--endt) = iFunc(*column);
+			column += aLineLen;
+			}
+		}
+	else
+		{
+		while(target < endt)
+			{
+			*target++ = iFunc(*column);
+			column += aLineLen;
+			}
+		}
+	}	
+		
+template <class T> TUint32 TRgbCopy<T>::Gray256(const TUint8& aPixel)
+	{
+	const TUint32 px = aPixel << 16 | aPixel << 8 | aPixel;
+	return px;
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color256(const TUint8& aPixel)
+	{
+	return TRgb::Color256(aPixel).Value();
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color4K(const TUint16& aPixel)
+	{
+	TUint32 col = (aPixel & 0xF00) << 12;
+	col |= (aPixel & 0xF00) << 8; 
+	
+	col |= (aPixel & 0x0F0) << 8;
+	col |= (aPixel & 0x0F0);
+	
+	col |= (aPixel & 0x00F) << 4;
+	col |= (aPixel & 0x00F);
+	
+	return col;
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color64K(const TUint16& aPixel)
+	{
+	TUint32 col = (aPixel & 0xF800)<< 8;
+	col |= (aPixel & 0xE000) << 3; 
+	
+	col |= (aPixel & 0x07E0) << 5;
+	col |= (aPixel & 0xC0) >> 1;
+	
+	col |= (aPixel & 0x07E0) << 3;
+	col |= (aPixel & 0x1C) >> 2;
+	
+	return col;
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color16M(const TUint32& aPixel)
+	{
+	return TRgb::Color16M(aPixel).Value();
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color16MU(const TUint32& aPixel)
+	{
+	return TRgb::Color16MU(aPixel).Value();
+	}
+	
+template <class T> TUint32 TRgbCopy<T>::Color16MA(const TUint32& aPixel)
+	{
+	return TRgb::Color16MA(aPixel).Value();
+	}
+
+typedef TUint64 TStackMem;
+
+LOCAL_C MRgbCopy* GetCopy(TAny* mem, TDisplayMode aMode)
+	{
+	if(aMode == EColor256 || aMode == EGray256)
+		{
+		return new (mem) TRgbCopy<TUint8>(aMode);
+		}
+	if(aMode == EColor4K || aMode == EColor64K)
+		{
+		return new (mem) TRgbCopy<TUint16>(aMode);
+		}
+	if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA)
+		{
+		return new (mem) TRgbCopy<TUint32>(aMode);
+		}
+	PANIC(KErrNotSupported);
+	return NULL;
+	}
+	
+
+void CDsa::CopySlowFlipReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	TStackMem mem = 0;
+	GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, ETrue);	
+	}
+	
+void CDsa::CopySlowFlip(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt aLineLen)
+	{
+	TStackMem mem = 0;
+	GetCopy(&mem, aDsa.iSourceMode)->FlipCopy(aTarget, aSource, aBytes, aLineLen, EFalse);
+	}
+	
+void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	TStackMem mem = 0;
+	GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, EFalse);	
+	}	
+
+void CDsa::CopySlowReversed(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, TInt aBytes, TInt)
+	{
+	TStackMem mem = 0;
+	GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, ETrue);	
+	}	
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////7