1 #include "dsa.h"

     2 #include "sdlepocapi.h"

     3 #include <cdsb.h>

     4 

     5 

     6 LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)

     7 	{

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

     9 	}

    10 

    11 

    12 

    13 

    14 template<class T>

    15 NONSHARABLE_CLASS(CBitmapSurface) : public T

    16 	{

    17 public:

    18 	CBitmapSurface(RWsSession& aSession);

    19 private:

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

    21 	~CBitmapSurface();

    22 	TUint8* LockSurface();

    23 	void UnlockHwSurface();

    24 	void CreateSurfaceL();

    25 	void Wipe(TInt aLength);

    26 	void Free();

    27 	void Update(CFbsBitmap& aBmp);

    28 	TInt ExternalUpdate();

    29 private:

    30 	CFbsBitmap* iBmp;

    31 	CFbsBitmap* iCopyBmp;

    32 	};

    33 	

    34 

    35 template<class T>

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

    37 	{

    38 	delete iCopyBmp;

    39 	iCopyBmp = NULL;

    40 	iCopyBmp = new (ELeave) CFbsBitmap();

    41 	T::ConstructL(aWindow, aDevice);

    42 	}

    43 	

    44 template<class T>

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

    46 	{

    47 	}

    48 	

    49 template<class T>

    50 void CBitmapSurface<T>::Free()

    51 	{

    52 	delete iBmp;

    53 	iBmp = NULL;

    54 	T::Free();

    55 	}

    56 

    57 template<class T>

    58 CBitmapSurface<T>::~CBitmapSurface()

    59 	{

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

    61 	delete iCopyBmp;

    62 	}

    63 	

    64 template<class T>

    65 TUint8* CBitmapSurface<T>::LockSurface()

    66 	{

    67 	iBmp->LockHeap();

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

    69 	}

    70 

    71 

    72 template<class T>

    73 void CBitmapSurface<T>::UnlockHwSurface()

    74 	{

    75 	iBmp->UnlockHeap();

    76 	T::SetUpdating(EFalse);

    77 	Update(*iBmp);

    78 	}

    79 

    80 	

    81 template<class T>	

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

    83 	{

    84 	if(!T::Blitter(aBmp))

    85 		{

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

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

    88 		else

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

    90 		}

    91 	T::DrawOverlays();

    92 	T::CompleteUpdate();	

    93 	}

    94 	

    95 template<class T>	

    96 void CBitmapSurface<T>::CreateSurfaceL()

    97 	{

    98 	Free();

    99 	iBmp  = new (ELeave) CFbsBitmap();

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

   101 	T::CreateSurfaceL(*iBmp);

   102 	}

   103 

   104 template<class T>

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

   106 	{

   107 	iBmp->LockHeap();

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

   109 	iBmp->UnlockHeap();

   110 	}

   111 

   112 template<class T>		

   113 TInt CBitmapSurface<T>::ExternalUpdate()

   114 	{

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

   116 		{

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

   118 		if(err != KErrNone)

   119 			return err;

   120 		}

   121 	Update(*iCopyBmp);

   122 	return KErrNone;

   123 	}

   124 

   125 

   126 //////////////////////////////////////////////////////////////////////

   127 

   128 

   129 

   130 NONSHARABLE_CLASS(CDsaBitgdi) : public CDsa

   131 	{

   132 public:

   133 	CDsaBitgdi(RWsSession& aSession);

   134 protected:

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

   136 	 CBitmapContext& Gc();

   137 	 void CompleteUpdate();

   138 	 ~CDsaBitgdi();

   139 	 void CreateSurfaceL(CFbsBitmap& aBmp);

   140 	 void Free();

   141 	 void UnlockHWSurfaceRequestComplete();

   142 private:

   143 	 void Resume();

   144 	 

   145 	 CFbsBitGc* iGc;

   146 	 CFbsDevice* iDevice;

   147 	 CFbsBitmap* iBitGdiBmp;

   148 	 CWindowGc* iWinGc;

   149 	 RWindow* iWindow;

   150 	 TInt iHandle;

   151 	 };

   152 

   153 

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

   155 	{

   156 	}

   157 

   158 CDsaBitgdi::~CDsaBitgdi()

   159 	{

   160 	delete iWinGc;

   161 	delete iBitGdiBmp;

   162 	}

   163 

   164 void CDsaBitgdi::CompleteUpdate()

   165 	{

   166 	EpocSdlEnv::Request(CDsa::ERequestUpdate);

   167 	}

   168 

   169 	

   170 void CDsaBitgdi::UnlockHWSurfaceRequestComplete()

   171 	{

   172 	if(iHandle == 0)

   173 		return;

   174 	

   175 	if(iBitGdiBmp == NULL)

   176 		{

   177 		iBitGdiBmp = new CFbsBitmap();

   178 		if(iBitGdiBmp == NULL)

   179 			return;

   180 		iBitGdiBmp->Duplicate(iHandle);

   181 		}

   182 	

   183 	iWindow->Invalidate();

   184 	

   185 	iWindow->BeginRedraw();

   186 	iWinGc->Activate(*iWindow);

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

   188 	iWinGc->Deactivate();

   189 	iWindow->EndRedraw();

   190 	}	

   191 	

   192 void CDsaBitgdi::Resume()

   193 	{

   194 	Start();

   195 	}

   196 	

   197 CBitmapContext& CDsaBitgdi::Gc()

   198  	{

   199  	return *iGc;

   200  	}

   201  	

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

   203  	{

   204  	

   205  	delete iBitGdiBmp;

   206  	iBitGdiBmp = NULL;

   207  	delete iWinGc;

   208  	iWinGc = NULL;

   209  	iHandle = 0;

   210  	

   211  	iWindow = &aWindow;

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

   213  	CDsa::ConstructL(aWindow, aDevice);

   214  	Start();

   215  	}

   216  	

   217 void CDsaBitgdi::CreateSurfaceL(CFbsBitmap& aBmp)	

   218 	{

   219 	iDevice = CFbsBitmapDevice::NewL(&aBmp);

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

   221 	iHandle = aBmp.Handle();

   222 	}

   223 	

   224 void CDsaBitgdi::Free()

   225 	{

   226 	delete iGc;

   227 	iGc = NULL;

   228 	delete iDevice;

   229 	iDevice = NULL;

   230 	}

   231 	

   232 ////////////////////////////////////////////////////////////////////////

   233 ///////////////////////////////////////////////////////////////////////

   234 

   235 NONSHARABLE_CLASS(CDsaBase) : public CDsa, public MDirectScreenAccess

   236 	{

   237 protected:	

   238 	inline CDirectScreenAccess& Dsa() const;

   239 	CDsaBase(RWsSession& aSession);

   240 	~CDsaBase();

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

   242 	void Stop();

   243 	void Resume();

   244 	CBitmapContext& Gc();

   245 protected:

   246     CDirectScreenAccess*  iDsa;

   247 private:

   248 	void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

   249 	void Restart(RDirectScreenAccess::TTerminationReasons aReason);

   250 private:

   251 	void RestartL();

   252 	};

   253 

   254 

   255 inline CDirectScreenAccess& CDsaBase::Dsa() const

   256 	{

   257 	return *iDsa;

   258 	}

   259 	

   260 

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

   262 	{

   263 	}

   264 	

   265 CBitmapContext& CDsaBase::Gc()

   266 	{

   267 	return *Dsa().Gc();

   268 	}

   269 	

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

   271     {

   272     CDsa::ConstructL(aWindow, aDevice);

   273     if(iDsa != NULL)

   274     	{

   275     	iDsa->Cancel();

   276     	delete iDsa;

   277     	iDsa = NULL;

   278     	}

   279     	

   280     iDsa = CDirectScreenAccess::NewL(

   281     				Session(),

   282 					aDevice,

   283 					aWindow,

   284 					*this);				

   285     RestartL();

   286     }	

   287 	

   288 void CDsaBase::Resume()	

   289 	{

   290 	if(Stopped())

   291 		Restart(RDirectScreenAccess::ETerminateRegion);

   292 	}	

   293 	

   294 CDsaBase::~CDsaBase()

   295 	{

   296 	if(iDsa != NULL)

   297         {

   298         iDsa->Cancel();

   299         }

   300     delete iDsa;

   301 	}

   302 	

   303 	

   304 void CDsaBase::RestartL()

   305     {

   306    

   307     

   308     iDsa->StartL();	

   309     

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

   311     const TRect rect = r->BoundingRect();

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

   313    

   314     if(rect != ScreenRect())

   315     	{

   316     	return ;	

   317    	 	}

   318    	 	

   319      

   320    	SetTargetRect();

   321 	RecreateL();

   322 	

   323 	Start();

   324     

   325     

   326     }

   327 

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

   329 	{

   330 	Stop();

   331 	}

   332 	

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

   334 	{

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

   336 		{												

   337 		TRAPD(err, RestartL());

   338 		PANIC_IF_ERROR(err);

   339 		}

   340 	}

   341 	

   342 	

   343 void CDsaBase::Stop()

   344 	{

   345 	CDsa::Stop();

   346 	iDsa->Cancel();

   347 	}

   348 		

   349     

   350    ///////////////////////////////////////////////////////////////////////

   351    /////////////////////////////////////////////////////////////////////// 

   352 NONSHARABLE_CLASS(TDsa)

   353 	{

   354 	public:

   355 		inline TDsa(const CDsa& aDsa);

   356 		inline TBool IsFlip() const;

   357 		inline TBool IsTurn() const;

   358 		inline const TSize& SwSize() const;

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

   360 	private:

   361 		const CDsa& iDsa;

   362 	};

   363 

   364 

   365 

   366 

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

   368 	{	

   369 	}

   370 

   371 inline TBool TDsa::IsTurn() const

   372 	{

   373 	return iDsa.iStateFlags & CDsa::EOrientation90;

   374 	}

   375 	

   376 inline TBool TDsa::IsFlip() const

   377 	{

   378 	return iDsa.iStateFlags & CDsa::EOrientation180;

   379 	}	

   380 	

   381 inline const TSize& TDsa::SwSize() const

   382 	{

   383 	return iDsa.SwSize();

   384 	}

   385 		

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

   387 	{

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

   389 	}

   390 	

   391 template<class T, class S>	

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

   393  					const TUint8* aSource,

   394  					const TRect& aUpdateRect,

   395  					const TRect& aSourceRect)

   396 	{

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

   398 	const TInt lineWidth = aSourceRect.Width();

   399 	

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

   401 	const TInt sourceStartOffset = aUpdateRect.iTl.iX;

   402 	source += sourceStartOffset;

   403 	

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

   405 	

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

   407 	

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

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

   410 	

   411 	targetPtr += targetStartOffset;

   412 	

   413 	

   414 	const TInt height = aUpdateRect.Height(); 

   415 		

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

   417 	const TInt copyLen = aUpdateRect.Width();

   418 	

   419 	

   420 	if(iDsa.IsFlip())

   421 		{

   422 		

   423 		targetPtr += scanLineWidth *  (height - 1);

   424 	

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

   426 			{

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

   428 			source += lineMove;

   429 			targetPtr -= scanLineWidth;

   430 			}

   431 		}

   432 	else

   433 		{

   434 		

   435 		

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

   437 			{

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

   439 			source += lineMove;

   440 			targetPtr += scanLineWidth; // >> 2;

   441 			}

   442 		}

   443 

   444 	}

   445 	

   446 

   447  

   448 NONSHARABLE_CLASS(CDsaA) : public CDsaBase

   449 	{

   450 	public:

   451 		CDsaA(RWsSession& aSession);

   452 	protected:

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

   454 		void CompleteUpdate();

   455 		void CreateSurfaceL(CFbsBitmap& aBmp);

   456 		void Free();

   457 		void UnlockHWSurfaceRequestComplete();	

   458 	};

   459 	

   460 	

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

   462 	{

   463 	}

   464 	

   465 

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

   467 	{

   468 	CDsaBase::ConstructL(aWindow, aDevice);

   469 	}

   470 	

   471 void CDsaA::CompleteUpdate()

   472 	{

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

   474 	}

   475 	

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

   477 	{

   478 	}

   479 	

   480 void CDsaA::Free()

   481 	{

   482 	

   483 	}

   484 	

   485 void CDsaA::UnlockHWSurfaceRequestComplete()

   486 	{

   487 	PANIC(KErrNotSupported);

   488 	}	

   489 	

   490 	

   491 	

   492 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   493 

   494 NONSHARABLE_CLASS(MDsbObs)

   495 	{

   496 	public:

   497 		virtual void SurfaceReady() = 0;

   498 		virtual CDirectScreenBitmap& Dsb() = 0;

   499 	};

   500 	

   501 NONSHARABLE_CLASS(CDsbSurface) : public CActive

   502 	{

   503 	public:

   504 		CDsbSurface(MDsbObs& aDsb);

   505 		TUint8* Address();

   506 		void Complete();

   507 		~CDsbSurface();

   508 	private:

   509 		void RunL();

   510 		void DoCancel();

   511 	private:

   512 		MDsbObs& iDsb; 

   513 		TUint8* iAddress;

   514 	};	

   515 

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

   517 	{

   518 	CActiveScheduler::Add(this);

   519 	}

   520 

   521 CDsbSurface::~CDsbSurface()

   522 	{

   523 	Cancel();

   524 	}

   525 	

   526 void CDsbSurface::Complete()

   527 	{

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

   529 		{

   530 		iAddress = NULL;

   531 		SetActive();

   532 		iDsb.Dsb().EndUpdate(iStatus);

   533 		}

   534 	}

   535 	

   536 TUint8* CDsbSurface::Address()

   537 	{

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

   539 		{

   540 		TAcceleratedBitmapInfo info;

   541 		if(KErrNone == iDsb.Dsb().BeginUpdate(info))

   542 			iAddress = info.iAddress;

   543 		}

   544 	return iAddress;

   545 	}

   546 	

   547 void CDsbSurface::RunL()

   548 	{

   549 	iDsb.SurfaceReady();

   550 	}

   551 

   552 void CDsbSurface::DoCancel()

   553 	{

   554 	//empty

   555 	}

   556 		

   557 NONSHARABLE_CLASS(CDsaB) : public CDsaBase,

   558  public MDsbObs

   559 	{

   560 	public:

   561 		CDsaB(RWsSession& aSession, TInt aFlags);

   562 	private:

   563 		~CDsaB();

   564 		TUint8* LockSurface();

   565 		void UnlockHWSurfaceRequestComplete();

   566 		void UnlockHwSurface();

   567 		void CreateSurfaceL();

   568 		void Wipe(TInt aLength);

   569 		void RecreateL();

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

   571 		CDirectScreenBitmap& Dsb();

   572 		void SurfaceReady();

   573 		TInt ExternalUpdate();

   574 	private:

   575 		CDsbSurface* iSurface1;

   576 		CDsbSurface* iSurface2;

   577 		CDirectScreenBitmap* iDsb;

   578 		TInt iType;

   579 	};

   580 

   581 CDsaB::CDsaB(RWsSession& aSession, TInt aFlags) : CDsaBase(aSession), iType(aFlags)

   582 	{

   583 	}

   584 

   585 

   586 	

   587 void CDsaB::UnlockHWSurfaceRequestComplete()

   588 	{

   589 	iSurface1->Complete();

   590 	if(iSurface2 != NULL)

   591 		iSurface2->Complete();

   592 	}	

   593 

   594 void CDsaB::CreateSurfaceL()

   595 	{

   596 	__ASSERT_ALWAYS(SwSize() == HwRect().Size(), PANIC(KErrNotSupported));

   597 	}

   598 	

   599 void CDsaB::Wipe(TInt aLength) //dont call in drawing

   600 	{

   601 	TUint8* addr = LockSurface();

   602 	if(addr != NULL) 

   603 		{

   604 		Mem::FillZ(addr, aLength);

   605 		UnlockHwSurface();

   606 		}

   607 	}

   608 	

   609 

   610 void CDsaB::UnlockHwSurface()

   611 	{

   612 	EpocSdlEnv::Request(CDsa::ERequestUpdate);

   613 	}

   614 	

   615 TUint8* CDsaB::LockSurface()

   616 	{

   617 	TUint8* addr =  iSurface1->Address();

   618 	if(addr == NULL && iSurface2 != NULL)

   619 		addr =  iSurface2->Address();

   620 	SetUpdating(addr == NULL);

   621 	return addr;

   622 	}

   623 	

   624 void CDsaB::SurfaceReady()	

   625 	{

   626 	SetUpdating(EFalse);

   627 	}

   628 

   629 CDirectScreenBitmap& CDsaB::Dsb()

   630 	{

   631 	return *iDsb;

   632 	}

   633 	

   634 void CDsaB::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)

   635 	{

   636 	if(iDsb == NULL)

   637 		iDsb = CDirectScreenBitmap::NewL();	

   638 	CDsaBase::ConstructL(aWindow, aDevice);

   639 	if(iSurface1 == NULL)	

   640 		iSurface1 = new (ELeave) CDsbSurface(*this);

   641 	if(iSurface2 == NULL && iType & CDirectScreenBitmap::EDoubleBuffer)

   642 		iSurface2 = new (ELeave) CDsbSurface(*this);

   643 	}

   644 	

   645 CDsaB::~CDsaB()

   646 	{

   647 	delete iSurface1;

   648 	delete iSurface2;

   649 	delete iDsb;

   650 	}	

   651 

   652 void CDsaB::RecreateL()

   653 	{

   654     iDsb->Close();

   655     iDsb->Create(HwRect(), CDirectScreenBitmap::TSettingsFlags(iType));

   656 	}

   657 	

   658 TInt CDsaB::ExternalUpdate()

   659 	{

   660 	if(LockSurface())

   661 		{

   662 		UnlockHWSurfaceRequestComplete();

   663 		return KErrNone;

   664 		}

   665 	return KErrNotReady;

   666 	}

   667 		

   668 

   669 /////////////////////////////////////////////////////////////////////////////////////////////////////	

   670 

   671 

   672 

   673 CDsa* CDsa::CreateL(RWsSession& aSession)

   674 	{

   675 	if(EpocSdlEnv::Flags(CSDL::EDrawModeDSB))

   676 		{

   677 		TInt flags = CDirectScreenBitmap::ENone;

   678 		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBDoubleBuffer))

   679 			flags |= CDirectScreenBitmap::EDoubleBuffer;

   680 		if(EpocSdlEnv::Flags(CSDL::EDrawModeDSBIncrementalUpdate))

   681 			flags |= CDirectScreenBitmap::EIncrementalUpdate;

   682 		return new (ELeave) CDsaB(aSession, flags);

   683 		}

   684 	else if(EpocSdlEnv::Flags(CSDL::EDrawModeGdi))

   685 		{

   686 		return new (ELeave) CBitmapSurface<CDsaBitgdi>(aSession);

   687 		}

   688     else

   689     	{

   690         return new (ELeave) CBitmapSurface<CDsaA>(aSession);

   691 		}

   692 	}

   693 	

   694 	

   695 void CDsa::RecreateL()

   696 	{

   697 	}

   698 

   699 void CDsa::Free()

   700 	{

   701 	}

   702 	

   703 TSize CDsa::WindowSize() const

   704 	{

   705 	TSize size = iSwSize;

   706 	if(iStateFlags & EOrientation90)

   707 		{

   708 		const TInt tmp = size.iWidth;

   709 		size.iWidth = size.iHeight;

   710 		size.iHeight = tmp;

   711 		}

   712 	return size;

   713 	}

   714 	

   715 void CDsa::SetSuspend()

   716 	{

   717 	iStateFlags |= ESdlThreadSuspend;

   718 	}

   719 

   720 

   721 void CDsa::SetUpdating(TBool aUpdate)

   722 	{

   723 	if(aUpdate)

   724 		iStateFlags |= EUpdating;

   725 	else

   726 		iStateFlags &= ~EUpdating;

   727 	}

   728 

   729 

   730 TBool CDsa::Stopped() const

   731 	{

   732 	return (iStateFlags & ESdlThreadExplicitStop);

   733 	}

   734 

   735 void CDsa::SetOrientation(CSDL::TOrientationMode aOrientation)

   736 	{

   737 	TInt flags = 0;

   738 	switch(aOrientation)

   739 		{

   740 		case CSDL::EOrientation90:

   741 			flags = EOrientation90;

   742 			break;

   743 		case CSDL::EOrientation180:

   744 			flags = EOrientation180;

   745 			break;

   746 		case CSDL::EOrientation270:

   747 			flags = EOrientation90 | EOrientation180;

   748 			break;

   749 		case CSDL::EOrientation0:

   750 			flags = 0;

   751 			break;

   752 		}

   753 	if(flags != (iStateFlags & EOrientationFlags))

   754 		{

   755 		iStateFlags |= EOrientationChanged;

   756 		iNewFlags = flags; //cannot be set during drawing...

   757 		}

   758 	}

   759 

   760 CDsa::~CDsa()

   761     {

   762     iOverlays.Close();

   763     User::Free(iLut256);

   764     }

   765          

   766 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)

   767     {			

   768 	if(iLut256 == NULL)

   769 		iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));

   770 	iTargetMode = aWindow.DisplayMode();

   771 	iTargetBpp = BytesPerPixel(DisplayMode());

   772 	iScreenRect = TRect(aWindow.Position(), aWindow.Size());

   773 	SetTargetRect();

   774     }

   775     

   776 void CDsa::DrawOverlays()

   777 	{

   778 	const TInt last = iOverlays.Count() - 1;

   779 	for(TInt i = last; i >= 0 ; i--)

   780 		iOverlays[i].iOverlay->Draw(Gc(), HwRect(), SwSize());

   781 	}

   782 

   783 TInt CDsa::AppendOverlay(MOverlay& aOverlay, TInt aPriority)

   784 	{

   785 	TInt i;

   786 	for(i = 0; i < iOverlays.Count() && iOverlays[i].iPriority < aPriority; i++)

   787 		{}

   788 	const TOverlay overlay = {&aOverlay, aPriority};

   789 	return iOverlays.Insert(overlay, i);

   790 	}

   791 	

   792 TInt CDsa::RemoveOverlay(MOverlay& aOverlay)

   793 	{

   794 	for(TInt i = 0; i < iOverlays.Count(); i++)

   795 		{

   796 		if(iOverlays[i].iOverlay == &aOverlay)

   797 			{

   798 			iOverlays.Remove(i);

   799 			return KErrNone;

   800 			}

   801 		}

   802 	return KErrNotFound;

   803 	}

   804 

   805 void CDsa::LockPalette(TBool aLock)

   806 	{

   807 	if(aLock)

   808 		iStateFlags |= EPaletteLocked;

   809 	else

   810 		iStateFlags &= ~EPaletteLocked;

   811 	}

   812 TInt CDsa::SetPalette(TInt aFirst, TInt aCount, TUint32* aPalette)

   813 	{

   814 	if(iLut256 == NULL)

   815 		return KErrNotFound;

   816 	const TInt count = aCount - aFirst;

   817 	if(count > 256)

   818 		return KErrArgument;

   819 	if(iStateFlags & EPaletteLocked)

   820 		return KErrNone;

   821 	for(TInt i = aFirst; i < count; i++) //not so busy here:-)

   822 		{

   823 		iLut256[i] = aPalette[i];

   824 		}

   825 	return KErrNone;

   826 	}

   827 	

   828 	

   829 

   830 

   831     

   832 CDsa::CDsa(RWsSession& aSession) : 

   833  	iStateFlags(0),

   834  	iSession(aSession)

   835   

   836 	{

   837 //	CActiveScheduler::Add(this);

   838 	iCFTable[0] = CopyMem;

   839 	iCFTable[1] = CopyMemFlipReversed;

   840 	iCFTable[2] = CopyMemReversed;

   841 	iCFTable[3] = CopyMemFlip;	

   842 	

   843 	iCFTable[4] = Copy256;

   844 	iCFTable[5] = Copy256FlipReversed;

   845 	iCFTable[6] = Copy256Reversed;

   846 	iCFTable[7] = Copy256Flip;	

   847 	

   848 	

   849 	iCFTable[8] = CopySlow;

   850 	iCFTable[9] = CopySlowFlipReversed;

   851 	iCFTable[10] = CopySlowReversed;

   852 	iCFTable[11] = CopySlowFlip;	

   853 	}

   854 	

   855 RWsSession& CDsa::Session()

   856 	{

   857 	return iSession;

   858 	}

   859 

   860 TInt CDsa::RedrawRequest()

   861 	{

   862 	if(!(iStateFlags & (EUpdating) && (iStateFlags & ERunning)))

   863 		{

   864 		return ExternalUpdate();

   865 		}

   866 	return KErrNotReady;

   867 	}

   868 

   869 TUint8* CDsa::LockHwSurface()

   870 	{

   871 	if((iStateFlags & EUpdating) == 0) //else frame is skipped

   872 		{

   873 		return LockSurface();

   874 		}

   875 	return NULL; 

   876 	}

   877 

   878 /*	

   879 void CDsa::RunL()

   880 	{

   881 	iStateFlags &= ~EUpdating;

   882 	}

   883 		

   884 	

   885 void CDsa::DoCancel()

   886 	{

   887 	iStateFlags &= ~EUpdating;

   888 	//nothing can do, just wait?

   889 	}

   890 */	

   891 

   892 	

   893 TInt CDsa::AllocSurface(TBool aHwSurface, const TSize& aSize, TDisplayMode aMode)

   894 	{

   895 	if(aHwSurface && aMode != DisplayMode())

   896 		return KErrArgument;

   897 	

   898 	iSourceMode = aMode;

   899 	

   900 	iSourceBpp = BytesPerPixel(aMode);

   901 	

   902 	const TSize size = WindowSize();

   903 	if(aSize.iWidth > size.iWidth)

   904 		return KErrTooBig;

   905 	if(aSize.iHeight > size.iHeight)

   906 		return KErrTooBig;

   907 	

   908 	TRAPD(err, CreateSurfaceL());

   909 	if(err != KErrNone)

   910 		return err;

   911 

   912 	SetCopyFunction();

   913 	

   914 	return KErrNone;

   915 	}

   916 	

   917 

   918 void CDsa::CreateZoomerL(const TSize& aSize)

   919 	{

   920 	iSwSize = aSize;

   921 	iStateFlags |= EResizeRequest;

   922 	CreateSurfaceL();

   923 	SetTargetRect();

   924 	}

   925 	

   926 

   927 /*

   928 void SaveBmp(const TDesC& aName, const TAny* aData, TInt aLength, const TSize& aSz, TDisplayMode aMode)

   929 	{

   930 	CFbsBitmap* s = new CFbsBitmap();

   931 	s->Create(aSz, aMode);

   932 	s->LockHeap();

   933 	TUint32* addr = s->DataAddress();

   934 	Mem::Copy(addr, aData, aLength);

   935 	s->UnlockHeap();

   936 	s->Save(aName);

   937 	s->Reset();

   938 	delete s;

   939 	}

   940 	

   941 void SaveBmp(const TDesC& aName, const TUint32* aData, const TSize& aSz)

   942 	{

   943 	CFbsBitmap* s = new CFbsBitmap();

   944 	s->Create(aSz, EColor64K);

   945 	TBitmapUtil bmp(s);

   946 	bmp.Begin(TPoint(0, 0));

   947 	for(TInt j = 0; j < aSz.iHeight; j++)

   948 		{

   949 		bmp.SetPos(TPoint(0, j));

   950 		for(TInt i = 0; i < aSz.iWidth; i++)

   951 			{

   952 			bmp.SetPixel(*aData);

   953 			aData++;

   954 			bmp.IncXPos();

   955 			}

   956 		}

   957 	bmp.End();

   958 	s->Save(aName);

   959 	s->Reset();

   960 	delete s;

   961 	}	

   962 	

   963 TBuf<16> FooName(TInt aFoo)

   964 	{

   965 	TBuf<16> b;

   966 	b.Format(_L("C:\\pic%d.mbm"), aFoo);

   967 	return b;

   968 	}

   969 	

   970 */

   971 

   972 

   973 void CDsa::ClipCopy(TUint8* aTarget,

   974  					const TUint8* aSource,

   975  					const TRect& aUpdateRect,

   976  					const TRect& aSourceRect) const

   977  		{

   978  		const TDsa dsa(*this);

   979  		switch(iSourceBpp)

   980  			{

   981  			case 1:

   982  				::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   983  				break;

   984  			case 2:

   985  				::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   986  				break;

   987  			case 4:

   988  				::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);

   989  				break;

   990  			}

   991  		}	

   992 

   993 

   994 void CDsa::Wipe() //dont call in drawing

   995 	{

   996 	if(IsDsaAvailable())

   997 		Wipe(iTargetBpp * SwSize().iWidth * SwSize().iHeight);

   998 	}

   999 	

  1000 void CDsa::SetCopyFunction()

  1001 	{

  1002 	//calculate offset to correct function in iCFTable according to given parameters

  1003 	TInt function = 0;

  1004 	const TInt KCopyFunctions = 4;

  1005 	const TInt KOffsetToNative = 0;

  1006 	const TInt KOffsetTo256 = KOffsetToNative + KCopyFunctions;

  1007 	const TInt KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;

  1008 	const TInt KOffsetTo90Functions = 1;

  1009 	const TInt KOffsetTo180Functions = 2;

  1010 	

  1011 	if(iSourceMode == DisplayMode())

  1012 		function = KOffsetToNative; 		//0

  1013 	else if(iSourceMode == EColor256)

  1014 		function = KOffsetTo256;			//4

  1015 	else

  1016 		function = KOffsetToOtherModes; 	//8

  1017 	

  1018 	if(iStateFlags & EOrientation90)

  1019 		function += KOffsetTo90Functions; 	// + 1

  1020 	if(iStateFlags & EOrientation180)

  1021 		function += KOffsetTo180Functions; 	//+ 2

  1022 	

  1023 	iCopyFunction = iCFTable[function];

  1024 	

  1025 	Wipe();

  1026 	}

  1027 	

  1028 inline void Rotate(TRect& aRect)

  1029 	{

  1030 	const TInt dx = aRect.iBr.iX - aRect.iTl.iX;

  1031 	const TInt dy = aRect.iBr.iY - aRect.iTl.iY;

  1032 

  1033 	aRect.iBr.iX = aRect.iTl.iX + dy;

  1034 	aRect.iBr.iY = aRect.iTl.iY + dx;

  1035 	

  1036 	const TInt tmp = aRect.iTl.iX;

  1037 	aRect.iTl.iX = aRect.iTl.iY;

  1038 	aRect.iTl.iY = tmp;

  1039 	}

  1040 	

  1041 /*	

  1042 int bar = 0;

  1043 */	

  1044 

  1045 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)

  1046 	{

  1047 

  1048 	if(iStateFlags & EOrientationChanged)

  1049 		{

  1050 		iStateFlags &= ~EOrientationFlags;

  1051 		iStateFlags |= iNewFlags;

  1052 		SetCopyFunction();

  1053 		iStateFlags &= ~EOrientationChanged;

  1054 	    EpocSdlEnv::WaitDeviceChange();

  1055 	    return EFalse; //skip this frame as data is may be changed

  1056 		}

  1057 

  1058 	if(iTargetAddr == NULL)

  1059 		{

  1060 		iTargetAddr = LockHwSurface();

  1061 		}

  1062 		

  1063 	TUint8* target = iTargetAddr;

  1064 	if(target == NULL)

  1065 		return EFalse;

  1066 	

  1067 	

  1068 	TRect targetRect = TRect(TPoint(0, 0), SwSize());

  1069 	

  1070 	TRect sourceRect = aRect;

  1071 	TRect updateRect = aUpdateRect;

  1072 	

  1073 //	TPoint move(0, 0);

  1074 	

  1075 	

  1076 	if(iStateFlags & EOrientation90)

  1077 		{

  1078 		Rotate(sourceRect);

  1079 		Rotate(updateRect);

  1080 		}

  1081 		

  1082 	if(iSourceMode != DisplayMode() ||  targetRect != sourceRect || targetRect != updateRect || ((iStateFlags & EOrientationFlags) != 0))

  1083 		{

  1084 		sourceRect.Intersection(targetRect); //so source always smaller or equal than target

  1085 		//updateRect.Intersection(targetRect);

  1086 		ClipCopy(target, aBits, updateRect, sourceRect);

  1087 		}

  1088 	else

  1089 		{

  1090 		const TInt byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored

  1091 		Mem::Copy(target, aBits, byteCount);

  1092 		}

  1093 

  1094 	return ETrue;

  1095 	}

  1096 	

  1097 		

  1098 void CDsa::UpdateSwSurface()

  1099 	{

  1100 	iTargetAddr = NULL;

  1101 	UnlockHwSurface();	//could be faster if does not use AO, but only check status before redraw, then no context switch needed

  1102 	}

  1103 	

  1104 

  1105 

  1106 	

  1107 void CDsa::DoStop()

  1108 	{

  1109 	if(IsDsaAvailable())

  1110 		iStateFlags |= ESdlThreadExplicitStop;

  1111 	Stop();

  1112 	}

  1113 

  1114 	

  1115 void CDsa::Stop()

  1116 	{

  1117 	iStateFlags &= ~ERunning;

  1118 	}

  1119 	

  1120 void CDsa::Start()

  1121 	{

  1122     iStateFlags |= ERunning;

  1123 	

  1124 	iStateFlags &= ~ESdlThreadExplicitStop;

  1125  

  1126     if(iStateFlags & ESdlThreadSuspend)

  1127     	{

  1128     	EpocSdlEnv::Resume();

  1129     	iStateFlags &= ~ ESdlThreadSuspend;

  1130     	}	

  1131     EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);	

  1132 	}

  1133 

  1134 

  1135 TBool CDsa::Blitter(CFbsBitmap& aBmp)