Added S60 port. SDL-1.2
authorRyan C. Gordon <icculus@icculus.org>
Sun, 24 Jun 2007 18:26:35 +0000
branchSDL-1.2
changeset 3975 e85e65aec22f
parent 3974 42578e98a295
child 3976 8582c6a5ca16
Added S60 port.
README.Symbian
docs.html
include/SDL_config.h.default
include/SDL_config.h.in
include/SDL_config_symbian.h
include/SDL_stdinc.h
include/SDL_thread.h
include/begin_code.h
src/SDL.c
src/audio/SDL_audio.c
src/audio/SDL_sysaudio.h
src/audio/symbian/SDL_epocaudio.cpp
src/audio/symbian/SDL_epocaudio.h
src/audio/symbian/streamplayer.cpp
src/audio/symbian/streamplayer.h
src/events/SDL_events.c
src/file/SDL_rwops.c
src/main/symbian/EKA1/SDL_main.cpp
src/main/symbian/EKA2/SDL_main.cpp
src/main/symbian/EKA2/sdlexe.cpp
src/main/symbian/EKA2/sdllib.cpp
src/main/symbian/EKA2/vectorbuffer.cpp
src/main/symbian/EKA2/vectorbuffer.h
src/stdlib/SDL_getenv.c
src/thread/SDL_thread_c.h
src/thread/symbian/SDL_sysmutex.cpp
src/thread/symbian/SDL_syssem.cpp
src/thread/symbian/SDL_systhread.cpp
src/thread/symbian/SDL_systhread_c.h
src/timer/symbian/SDL_systimer.cpp
src/video/symbian/EKA1/SDL_epocevents.cpp
src/video/symbian/EKA1/SDL_epocvideo.cpp
src/video/symbian/EKA1/SDL_epocvideo.h
src/video/symbian/EKA2/SDL_epocevents.cpp
src/video/symbian/EKA2/SDL_epocvideo.cpp
src/video/symbian/EKA2/SDL_epocvideo.h
src/video/symbian/EKA2/dsa.cpp
src/video/symbian/EKA2/dsa_new.cpp
src/video/symbian/EKA2/dsa_old.cpp
src/video/symbian/SDL_epocevents_c.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.Symbian	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,32 @@
+==============================================================================
+Using the Simple DirectMedia Layer with S60 3.x / Symbian 9.x
+==============================================================================
+
+These instuctions are for people developing for S60 3.x. S60 3.x
+uses Symbian OS so you need S60 SDK.
+
+extract "symbian.zip" into this folder.
+
+go to symbian folder
+
+bldmake bldfiles
+abld build
+
+That produces WINSCW and ARMV5 versions of sdl.dll runtime library 
+and sdl.lib for development. 
+
+Eaudiolib.lib and dll are generated as well, and must be delivered
+along SDL as it uses it for audio.
+
+There are certain problems with GCC compiler when building for
+target, it may compile or binaries are buggy - please use RVCT
+compiler as it works and produces far more effient code.
+
+Its likely that SDL application should be integrated into S60 
+work and behave well there. So there is CSDL class (sdlepocapi.h)
+to make this easy. If you do porting from other system, then 
+implement a S60 application and use CSDL class, they you may
+not need to modify original SDL code at all!
+
+
+
--- a/docs.html	Thu Jun 21 18:48:13 2007 +0000
+++ b/docs.html	Sun Jun 24 18:26:35 2007 +0000
@@ -46,6 +46,9 @@
 <P>
 	Support for Nokia 9210 "EPOC" driver has been removed from the main SDL code.
 </P>
+<P>
+	Unofficial support for the S60/SymbianOS platform has been added.
+</P>
 </BLOCKQUOTE>
 
 <H3> Unix Notes </H3>
--- a/include/SDL_config.h.default	Thu Jun 21 18:48:13 2007 +0000
+++ b/include/SDL_config.h.default	Sun Jun 24 18:26:35 2007 +0000
@@ -32,6 +32,8 @@
 #include "SDL_config_macos.h"
 #elif defined(__MACOSX__)
 #include "SDL_config_macosx.h"
+#elif defined(__SYMBIAN32__)
+#include "SDL_config_symbian.h"  /* must be before win32! */
 #elif defined(__WIN32__)
 #include "SDL_config_win32.h"
 #elif defined(__OS2__)
--- a/include/SDL_config.h.in	Thu Jun 21 18:48:13 2007 +0000
+++ b/include/SDL_config.h.in	Sun Jun 24 18:26:35 2007 +0000
@@ -224,7 +224,6 @@
 /* Enable various threading systems */
 #undef SDL_THREAD_BEOS
 #undef SDL_THREAD_DC
-#undef SDL_THREAD_EPOC
 #undef SDL_THREAD_OS2
 #undef SDL_THREAD_PTH
 #undef SDL_THREAD_PTHREAD
@@ -237,7 +236,6 @@
 #undef SDL_TIMER_BEOS
 #undef SDL_TIMER_DC
 #undef SDL_TIMER_DUMMY
-#undef SDL_TIMER_EPOC
 #undef SDL_TIMER_MACOS
 #undef SDL_TIMER_MINT
 #undef SDL_TIMER_OS2
@@ -255,7 +253,6 @@
 #undef SDL_VIDEO_DRIVER_DIRECTFB
 #undef SDL_VIDEO_DRIVER_DRAWSPROCKET
 #undef SDL_VIDEO_DRIVER_DUMMY
-#undef SDL_VIDEO_DRIVER_EPOC
 #undef SDL_VIDEO_DRIVER_FBCON
 #undef SDL_VIDEO_DRIVER_GAPI
 #undef SDL_VIDEO_DRIVER_GEM
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/SDL_config_symbian.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,146 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+/*
+
+Symbian version Markus Mertama
+
+*/
+
+
+#ifndef _SDL_CONFIG_SYMBIAN_H
+#define _SDL_CONFIG_SYMBIAN_H
+
+#include "SDL_platform.h"
+
+/* This is the minimal configuration that can be used to build SDL */
+
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#ifdef __GCCE__
+#define SYMBIAN32_GCCE
+#endif
+
+#ifndef _SIZE_T_DEFINED
+typedef unsigned int size_t;
+#endif
+
+#ifndef _INTPTR_T_DECLARED
+typedef unsigned int uintptr_t;
+#endif 
+
+#ifndef _INT8_T_DECLARED
+typedef signed char int8_t;
+#endif 
+
+#ifndef _UINT8_T_DECLARED
+typedef unsigned char uint8_t;
+#endif
+
+#ifndef _INT16_T_DECLARED
+typedef signed short int16_t;
+#endif
+
+#ifndef _UINT16_T_DECLARED
+typedef unsigned short uint16_t;
+#endif
+
+#ifndef _INT32_T_DECLARED
+typedef signed int int32_t;
+#endif
+
+#ifndef _UINT32_T_DECLARED
+typedef unsigned int uint32_t;
+#endif
+
+#ifndef _INT64_T_DECLARED
+typedef signed long long int64_t;
+#endif
+
+#ifndef _UINT64_T_DECLARED
+typedef unsigned long long uint64_t;
+#endif
+
+#define SDL_AUDIO_DRIVER_EPOCAUDIO	1
+
+
+/* Enable the stub cdrom driver (src/cdrom/dummy/\*.c) */
+#define SDL_CDROM_DISABLED	1
+
+/* Enable the stub joystick driver (src/joystick/dummy/\*.c) */
+#define SDL_JOYSTICK_DISABLED	1
+
+/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
+#define SDL_LOADSO_DISABLED	1
+
+#define SDL_THREAD_SYMBIAN 1
+
+#define SDL_VIDEO_DRIVER_EPOC    1
+
+#define SDL_VIDEO_OPENGL 0
+
+#define SDL_HAS_64BIT_TYPE	1
+
+#define HAVE_LIBC	1
+#define HAVE_STDIO_H 1
+#define STDC_HEADERS 1
+#define HAVE_STRING_H 1
+#define HAVE_CTYPE_H 1
+#define HAVE_MATH_H 1
+
+#define HAVE_MALLOC 1
+#define HAVE_CALLOC 1
+#define HAVE_REALLOC 1
+#define HAVE_FREE 1
+//#define HAVE_ALLOCA 1
+#define HAVE_QSORT 1
+#define HAVE_ABS 1
+#define HAVE_MEMSET 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCMP 1
+#define HAVE_STRLEN 1
+#define HAVE__STRUPR 1
+#define HAVE_STRCHR 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_ITOA 1
+#define HAVE_STRTOL 1
+#define HAVE_STRTOUL 1
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOD 1
+#define HAVE_ATOI 1
+#define HAVE_ATOF 1
+#define HAVE_STRCMP 1
+#define HAVE_STRNCMP 1
+#define HAVE__STRICMP 1
+#define HAVE__STRNICMP 1
+#define HAVE_SSCANF 1
+#define HAVE_STDARG_H	1
+#define HAVE_STDDEF_H	1
+
+
+
+#endif /* _SDL_CONFIG_SYMBIAN_H */
--- a/include/SDL_stdinc.h	Thu Jun 21 18:48:13 2007 +0000
+++ b/include/SDL_stdinc.h	Sun Jun 24 18:26:35 2007 +0000
@@ -91,7 +91,9 @@
 
 #ifdef SDL_HAS_64BIT_TYPE
 typedef int64_t		Sint64;
+#ifndef SYMBIAN32_GCCE
 typedef uint64_t	Uint64;
+#endif
 #else
 /* This is really just a hack to prevent the compiler from complaining */
 typedef struct {
--- a/include/SDL_thread.h	Thu Jun 21 18:48:13 2007 +0000
+++ b/include/SDL_thread.h	Sun Jun 24 18:26:35 2007 +0000
@@ -45,7 +45,7 @@
 typedef struct SDL_Thread SDL_Thread;
 
 /* Create a thread */
-#if (defined(__WIN32__) && !defined(HAVE_LIBC)) || defined(__OS2__)
+#if ((defined(__WIN32__) && !defined(HAVE_LIBC)) || defined(__OS2__)) &&  !defined(__SYMBIAN32__)
 /*
    We compile SDL into a DLL on OS/2. This means, that it's the DLL which
    creates a new thread for the calling process with the SDL_CreateThread()
--- a/include/begin_code.h	Thu Jun 21 18:48:13 2007 +0000
+++ b/include/begin_code.h	Sun Jun 24 18:26:35 2007 +0000
@@ -83,11 +83,15 @@
 #endif
 #endif /* SDLCALL */
 
-/* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */
 #ifdef __SYMBIAN32__ 
+#ifndef EKA2 
 #undef DECLSPEC
 #define DECLSPEC
-#endif /* __SYMBIAN32__ */
+#elif !defined(__WINS__)
+#undef DECLSPEC
+#define DECLSPEC __declspec(dllexport)
+#endif //EKA2
+#endif //__SYMBIAN32__
 
 /* Force structure packing at 4 byte alignment.
    This is necessary if the header is included in code which has structure
@@ -116,7 +120,7 @@
 #if defined(_MSC_VER) || defined(__BORLANDC__) || \
     defined(__DMC__) || defined(__SC__) || \
     defined(__WATCOMC__) || defined(__LCC__) || \
-    defined(__DECC)
+    defined(__DECC) || defined(__EABI__)
 #ifndef __inline__
 #define __inline__	__inline
 #endif
--- a/src/SDL.c	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/SDL.c	Sun Jun 24 18:26:35 2007 +0000
@@ -323,7 +323,7 @@
 }
 #endif /* __WATCOMC__ */
 
-#elif defined(__WIN32__)
+#elif defined(__WIN32__)  && !defined(__SYMBIAN32__)
 
 #if !defined(HAVE_LIBC) || (defined(__WATCOMC__) && defined(BUILD_DLL))
 /* Need to include DllMain() on Watcom C for some reason.. */
--- a/src/audio/SDL_audio.c	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/audio/SDL_audio.c	Sun Jun 24 18:26:35 2007 +0000
@@ -107,6 +107,9 @@
 #if SDL_AUDIO_DRIVER_DART
 	&DART_bootstrap,
 #endif
+#if SDL_AUDIO_DRIVER_EPOCAUDIO
+	&EPOCAudio_bootstrap,
+#endif
 	NULL
 };
 SDL_AudioDevice *current_audio = NULL;
@@ -545,7 +548,7 @@
 	switch (audio->opened) {
 		case  1:
 			/* Start the audio thread */
-#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC) && !defined(__SYMBIAN32__)
 #undef SDL_CreateThread
 			audio->thread = SDL_CreateThread(SDL_RunAudio, audio, NULL, NULL);
 #else
--- a/src/audio/SDL_sysaudio.h	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/audio/SDL_sysaudio.h	Sun Jun 24 18:26:35 2007 +0000
@@ -171,6 +171,9 @@
 #if SDL_AUDIO_DRIVER_DART
 extern AudioBootStrap DART_bootstrap;
 #endif
+#if SDL_AUDIO_DRIVER_EPOCAUDIO
+extern AudioBootStrap EPOCAudio_bootstrap; 
+#endif
 
 /* This is the current audio device */
 extern SDL_AudioDevice *current_audio;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/symbian/SDL_epocaudio.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,614 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_epocaudio.cpp
+    Epoc based SDL audio driver implementation
+    
+    Markus Mertama
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id: SDL_epocaudio.c,v 0.0.0.0 2001/06/19 17:19:56 hercules Exp $";
+#endif
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+
+#include "epoc_sdl.h"
+
+#include <e32hal.h>
+
+
+extern "C" {
+#include "SDL_audio.h"
+#include "SDL_error.h"
+#include "SDL_audiomem.h"
+#include "SDL_audio_c.h"
+#include "SDL_timer.h"
+#include "SDL_audiodev_c.h"
+}
+
+#include "SDL_epocaudio.h"
+
+#include "streamplayer.h"
+
+
+//#define DEBUG_AUDIO
+
+
+/* Audio driver functions */
+
+static int EPOC_OpenAudio(SDL_AudioDevice *thisdevice, SDL_AudioSpec *spec);
+static void EPOC_WaitAudio(SDL_AudioDevice *thisdevice);
+static void EPOC_PlayAudio(SDL_AudioDevice *thisdevice);
+static Uint8 *EPOC_GetAudioBuf(SDL_AudioDevice *thisdevice);
+static void EPOC_CloseAudio(SDL_AudioDevice *thisdevice);
+static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice);
+
+static int Audio_Available(void);
+static SDL_AudioDevice *Audio_CreateDevice(int devindex);
+static void Audio_DeleteDevice(SDL_AudioDevice *device);
+
+
+//void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len);
+
+#ifdef __WINS__
+#define DODUMP
+#endif
+
+#ifdef DODUMP
+NONSHARABLE_CLASS(TDump)
+	{
+	public:
+	TInt Open();
+	void Close();
+	void Dump(const TDesC8& aDes);
+	private:
+		RFile iFile;
+    	RFs iFs; 
+	};
+	
+TInt TDump::Open()
+	{
+	TInt err = iFs.Connect();
+	if(err == KErrNone)
+		{
+#ifdef __WINS__
+_LIT(target, "C:\\sdlau.raw");
+#else
+_LIT(target, "E:\\sdlau.raw");
+#endif 
+		err = iFile.Replace(iFs, target, EFileWrite);
+		}
+	return err;
+	}
+void TDump::Close()
+	{
+	iFile.Close();
+	iFs.Close();
+	}
+void TDump::Dump(const TDesC8& aDes)
+	{
+	iFile.Write(aDes);
+	}
+#endif
+
+
+NONSHARABLE_CLASS(CSimpleWait) : public CTimer
+	{
+	public:
+		void Wait(TTimeIntervalMicroSeconds32 aWait);
+		static CSimpleWait* NewL();
+	private:
+		CSimpleWait();
+		void RunL();
+	};
+
+
+CSimpleWait* CSimpleWait::NewL()
+	{
+	CSimpleWait* wait = new (ELeave) CSimpleWait();
+	CleanupStack::PushL(wait);
+	wait->ConstructL();
+	CleanupStack::Pop();
+	return wait;
+	}
+
+void CSimpleWait::Wait(TTimeIntervalMicroSeconds32 aWait)
+	{
+	After(aWait);
+	CActiveScheduler::Start();
+	}
+	
+CSimpleWait::CSimpleWait() : CTimer(CActive::EPriorityStandard)	
+	{
+	CActiveScheduler::Add(this);
+	}
+
+void CSimpleWait::RunL()
+	{
+	CActiveScheduler::Stop();
+	}
+
+const TInt KAudioBuffers(2);
+	
+
+NONSHARABLE_CLASS(CEpocAudio) : public CBase, public MStreamObs, public MStreamProvider
+    {
+    public:
+    	static void* NewL(TInt BufferSize, TInt aFill);
+    	inline static CEpocAudio& Current(SDL_AudioDevice* thisdevice);
+    	
+    	static void Free(SDL_AudioDevice* thisdevice);
+ 		
+    	void Wait();
+    	void Play();
+    //	void SetBuffer(const TDesC8& aBuffer);
+    	void ThreadInitL(TAny* aDevice);
+    	void Open(TInt iRate, TInt iChannels, TUint32 aType, TInt aBytes);
+    	~CEpocAudio();
+    	TUint8* Buffer();
+    	TBool SetPause(TBool aPause);
+    #ifdef DODUMP
+    	void Dump(const TDesC8& aBuf) {iDump.Dump(aBuf);}
+    #endif
+    private:
+    	CEpocAudio(TInt aBufferSize);
+    	void Complete(TInt aState, TInt aError);
+    	TPtrC8 Data();
+    	void ConstructL(TInt aFill);
+    private:
+    	TInt iBufferSize;
+    	CStreamPlayer* iPlayer;
+    	TInt iBufferRate;
+    	TInt iRate;
+    	TInt iChannels;
+    	TUint32 iType;
+    	TInt iPosition;
+    	TThreadId iTid;
+    	TUint8* iAudioPtr;
+    	TUint8* iBuffer;
+    //	TTimeIntervalMicroSeconds iStart;
+    	TTime iStart;
+    	TInt iTune;
+    	CSimpleWait* iWait;
+    #ifdef DODUMP
+    	TDump iDump;
+    #endif
+    };
+
+inline CEpocAudio& CEpocAudio::Current(SDL_AudioDevice* thisdevice)
+	{
+	return *static_cast<CEpocAudio*>((void*)thisdevice->hidden);
+	}
+	
+/*
+
+TBool EndSc(TAny*)
+	{	
+	CActiveScheduler::Stop();
+	}
+	
+LOCAL_C void CleanScL()
+	{
+	CIdle* d = CIdle::NewLC(CActive:::EPriorityIdle);
+	d->Start(TCallBack(EndSc));
+	CActiveScheduler::Start();
+	
+	}
+*/
+	
+void CEpocAudio::Free(SDL_AudioDevice* thisdevice)
+	{
+    CEpocAudio* ea = static_cast<CEpocAudio*>((void*)thisdevice->hidden);
+    if(ea)
+    	{
+		ASSERT(ea->iTid == RThread().Id());
+    	delete ea;
+    	thisdevice->hidden = NULL;	
+   
+    	CActiveScheduler* as =  CActiveScheduler::Current();
+    	ASSERT(as->StackDepth() == 0);    	
+    	delete as;
+    	CActiveScheduler::Install(NULL);
+    	}
+    ASSERT(thisdevice->hidden == NULL);
+	}
+	
+CEpocAudio::CEpocAudio(TInt aBufferSize) : iBufferSize(aBufferSize), iPosition(-1) 
+	{
+	}
+
+void* CEpocAudio::NewL(TInt aBufferSize, TInt aFill)
+	{
+	CEpocAudio* eAudioLib = new (ELeave) CEpocAudio(aBufferSize);
+	CleanupStack::PushL(eAudioLib);
+	eAudioLib->ConstructL(aFill);
+	CleanupStack::Pop();
+	return eAudioLib;
+	}
+	
+void CEpocAudio::ConstructL(TInt aFill)
+	{
+	iBuffer = (TUint8*) User::AllocL(KAudioBuffers * iBufferSize);
+	memset(iBuffer, aFill, KAudioBuffers * iBufferSize);
+	iAudioPtr = iBuffer;
+	}
+
+
+TBool CEpocAudio::SetPause(TBool aPause)
+	{
+	if(aPause && iPosition >= 0)
+		{
+		iPosition = -1;
+		if(iPlayer != NULL)
+			iPlayer->Stop();
+		}
+	if(!aPause && iPosition < 0)
+		{
+		iPosition = 0;
+		if(iPlayer != NULL)
+			iPlayer->Start();
+		}
+	return iPosition < 0;
+	}
+	
+void CEpocAudio::ThreadInitL(TAny* aDevice)
+	{
+	iTid = RThread().Id(); 
+	CActiveScheduler* as =  new (ELeave) CActiveScheduler();
+    CActiveScheduler::Install(as);
+    
+    EpocSdlEnv::AppendCleanupItem(TSdlCleanupItem((TSdlCleanupOperation)EPOC_CloseAudio, aDevice));
+   
+    iWait = CSimpleWait::NewL();
+   
+    iPlayer = new (ELeave) CStreamPlayer(*this, *this);
+    iPlayer->ConstructL();	
+    iPlayer->OpenStream(iRate, iChannels, iType);
+    
+    #ifdef DODUMP
+    User::LeaveIfError(iDump.Open());
+    #endif
+	}
+	
+	
+	
+TUint8* CEpocAudio::Buffer()
+	{
+	iStart.UniversalTime();
+//	iStart = iPlayer->Position();		
+	return iAudioPtr;
+
+	}
+	
+CEpocAudio::~CEpocAudio()
+	{
+	if(iWait != NULL)
+		iWait->Cancel();
+	delete iWait; 
+	if(iPlayer != NULL)
+		iPlayer->Close();
+	delete iPlayer;
+	delete iBuffer;
+	}
+	
+void CEpocAudio::Complete(TInt aState, TInt aError)
+	{
+	if(aState == MStreamObs::EClose)
+		{
+		}
+	if(iPlayer->Closed())
+		return;
+	switch(aError)
+		{
+		case KErrUnderflow:
+		case KErrInUse:
+			iPlayer->Start();
+			break;
+		case KErrAbort:
+			iPlayer->Open();
+		}
+	}
+	
+
+void sos_adump(SDL_AudioDevice* thisdevice, void* data, int len)
+	{
+#ifdef DODUMP
+	const TPtrC8 buf((TUint8*)data, len);
+	CEpocAudio::Current(thisdevice).Dump(buf);
+#endif
+	}
+
+const TInt KClip(256);
+	
+TPtrC8 CEpocAudio::Data()
+	{
+	if(iPosition < 0)
+		return KNullDesC8();
+	
+	TPtrC8 data(iAudioPtr + iPosition, KClip);
+	
+#ifdef DODUMP
+	iDump.Dump(data);
+#endif
+	
+	iPosition += KClip;
+	if(iPosition >= iBufferSize) 
+		{
+		
+/*		if(iAudioPtr == iBuffer)
+			iAudioPtr = iBuffer + iBufferSize;
+		else
+			iAudioPtr = iBuffer;
+*/		
+		iAudioPtr += iBufferSize;
+		
+		if((iAudioPtr - iBuffer) >= KAudioBuffers * iBufferSize)
+			iAudioPtr = iBuffer;
+		
+		iPosition = -1;
+		if(iWait->IsActive())
+			{
+			iWait->Cancel();
+			CActiveScheduler::Stop();
+			}
+		}
+	return data;
+	}
+		
+
+
+	
+void CEpocAudio::Play()
+	{
+	iPosition = 0;
+	}
+
+void CEpocAudio::Wait()
+	{
+	if(iPosition >= 0 /*&& iPlayer->Playing()*/)
+		{
+		const TInt64 bufMs = TInt64(iBufferSize - KClip) * TInt64(1000000);
+		const TInt64 specTime =  bufMs / TInt64(iRate * iChannels * 2);
+		iWait->After(specTime);
+		
+		CActiveScheduler::Start();
+		TTime end;
+		end.UniversalTime();
+		const TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(iStart);
+	
+	
+//		const TTimeIntervalMicroSeconds end = iPlayer->Position();
+		
+		
+	
+		
+		const TInt diff = specTime - delta.Int64();
+		
+		if(diff > 0 && diff < 200000)
+			{
+			User::After(diff);
+			}
+		
+		}
+	else
+		{
+	User::After(10000); 
+//	iWait->Wait(10000); //just give some time...	
+		}	
+	}
+	
+void CEpocAudio::Open(TInt aRate, TInt aChannels, TUint32 aType, TInt aBytes)	
+	{
+	iRate = aRate;
+	iChannels = aChannels;
+	iType = aType;
+    iBufferRate = iRate * iChannels * aBytes; //1/x
+	}
+	
+
+/* Audio driver bootstrap functions */
+
+AudioBootStrap EPOCAudio_bootstrap = {
+	"epoc\0\0\0",
+	"EPOC streaming audio\0\0\0",
+	Audio_Available,
+	Audio_CreateDevice
+};
+
+
+static SDL_AudioDevice *Audio_CreateDevice(int /*devindex*/)
+{
+	SDL_AudioDevice *thisdevice;
+
+	/* Initialize all variables that we clean on shutdown */
+	thisdevice = (SDL_AudioDevice *)malloc(sizeof(SDL_AudioDevice));
+	if ( thisdevice ) {
+		memset(thisdevice, 0, (sizeof *thisdevice));
+		thisdevice->hidden = NULL; /*(struct SDL_PrivateAudioData *)
+			 malloc((sizeof thisdevice->hidden)); */
+	}
+	if ( (thisdevice == NULL) /*|| (thisdevice->hidden == NULL) */) {
+		SDL_OutOfMemory();
+		if ( thisdevice ) {
+			free(thisdevice);
+		}
+		return(0);
+	}
+//	memset(thisdevice->hidden, 0, (sizeof *thisdevice->hidden));
+
+	/* Set the function pointers */
+	thisdevice->OpenAudio = EPOC_OpenAudio;
+	thisdevice->WaitAudio = EPOC_WaitAudio;
+	thisdevice->PlayAudio = EPOC_PlayAudio;
+	thisdevice->GetAudioBuf = EPOC_GetAudioBuf;
+	thisdevice->CloseAudio = EPOC_CloseAudio;
+    thisdevice->ThreadInit = EPOC_ThreadInit;
+	thisdevice->free = Audio_DeleteDevice;
+
+	return thisdevice;
+}
+
+
+static void Audio_DeleteDevice(SDL_AudioDevice *device)
+    {
+	//free(device->hidden);
+	free(device);
+    }
+
+static int Audio_Available(void)
+{
+	return(1); // Audio stream modules should be always there!
+}
+
+
+static int EPOC_OpenAudio(SDL_AudioDevice *thisdevice, SDL_AudioSpec *spec)
+{
+	SDL_TRACE("SDL:EPOC_OpenAudio");
+
+	
+	TUint32 type = KMMFFourCCCodePCM16;
+	TInt bytes = 2;
+	
+	switch(spec->format)
+		{
+		case AUDIO_U16LSB: 
+			type = KMMFFourCCCodePCMU16; 
+			break;
+		case AUDIO_S16LSB: 
+			type = KMMFFourCCCodePCM16; 
+			break;
+		case AUDIO_U16MSB: 
+			type = KMMFFourCCCodePCMU16B; 
+			break;
+		case AUDIO_S16MSB: 
+			type = KMMFFourCCCodePCM16B; 
+			break; 
+			//8 bit not supported!
+		case AUDIO_U8: 
+		case AUDIO_S8:
+		default:
+			spec->format = AUDIO_S16LSB;
+		};
+	
+
+	
+	if(spec->channels > 2)
+		spec->channels = 2;
+	
+	spec->freq = CStreamPlayer::ClosestSupportedRate(spec->freq);
+	
+
+	/* Allocate mixing buffer */
+	const TInt buflen = spec->size;// * bytes * spec->channels;
+//	audiobuf = NULL;
+    
+    TRAPD(err, thisdevice->hidden = static_cast<SDL_PrivateAudioData*>(CEpocAudio::NewL(buflen, spec->silence)));
+    if(err != KErrNone)
+        return -1;
+
+	CEpocAudio::Current(thisdevice).Open(spec->freq, spec->channels, type, bytes);
+	
+	CEpocAudio::Current(thisdevice).SetPause(ETrue);
+	
+   // isSDLAudioPaused = 1;
+
+    thisdevice->enabled = 0; /* enable only after audio engine has been initialized!*/
+
+	/* We're ready to rock and roll. :-) */
+	return(0);
+}
+
+
+static void EPOC_CloseAudio(SDL_AudioDevice* thisdevice)
+    {
+#ifdef DEBUG_AUDIO
+    SDL_TRACE("Close audio\n");
+#endif
+
+	CEpocAudio::Free(thisdevice);
+	}
+
+
+static void EPOC_ThreadInit(SDL_AudioDevice *thisdevice)
+    {
+	SDL_TRACE("SDL:EPOC_ThreadInit");
+    CEpocAudio::Current(thisdevice).ThreadInitL(thisdevice);
+    RThread().SetPriority(EPriorityMore);
+    thisdevice->enabled = 1;
+    }
+
+/* This function waits until it is possible to write a full sound buffer */
+static void EPOC_WaitAudio(SDL_AudioDevice* thisdevice)
+{
+#ifdef DEBUG_AUDIO
+    SDL_TRACE1("wait %d audio\n", CEpocAudio::AudioLib().StreamPlayer(KSfxChannel).SyncTime());
+    TInt tics = User::TickCount();
+#endif
+
+	CEpocAudio::Current(thisdevice).Wait();
+
+#ifdef DEBUG_AUDIO
+    TInt ntics =  User::TickCount() - tics;
+    SDL_TRACE1("audio waited %d\n", ntics);
+    SDL_TRACE1("audio at %d\n", tics);
+#endif
+}
+
+
+ 
+static void EPOC_PlayAudio(SDL_AudioDevice* thisdevice)
+	{
+ 	if(CEpocAudio::Current(thisdevice).SetPause(SDL_GetAudioStatus() == SDL_AUDIO_PAUSED))
+ 		SDL_Delay(500); //hold on the busy loop
+ 	else
+ 		CEpocAudio::Current(thisdevice).Play();
+
+#ifdef DEBUG_AUDIO
+    SDL_TRACE("buffer has audio data\n");
+#endif
+
+	
+#ifdef DEBUG_AUDIO
+	SDL_TRACE1("Wrote %d bytes of audio data\n", buflen);
+#endif
+}
+
+static Uint8 *EPOC_GetAudioBuf(SDL_AudioDevice* thisdevice)
+	{
+	return CEpocAudio::Current(thisdevice).Buffer();
+	}
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/symbian/SDL_epocaudio.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,37 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id: SDL_epocaudio.h,v 1.1.2.2 2001/02/10 07:20:03 hercules Exp $";
+#endif
+
+#ifndef _SDL_EPOCAUDIO_H
+#define _SDL_EPOCAUDIO_H
+
+extern "C" {
+#include "SDL_sysaudio.h"
+}
+
+
+#endif /* _SDL_EPOCAUDIO_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/symbian/streamplayer.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,279 @@
+#include "streamplayer.h"
+#include<mda/common/audio.h>
+
+
+
+const TInt KMaxVolume(256);
+
+LOCAL_C TInt GetSampleRate(TInt aRate)
+    {
+    switch(aRate)
+        {
+        case 8000: return TMdaAudioDataSettings::ESampleRate8000Hz;
+        case 11025: return TMdaAudioDataSettings::ESampleRate11025Hz;
+        case 12000: return TMdaAudioDataSettings::ESampleRate12000Hz;
+        case 16000: return TMdaAudioDataSettings::ESampleRate16000Hz;
+        case 22050: return TMdaAudioDataSettings::ESampleRate22050Hz;
+        case 24000: return TMdaAudioDataSettings::ESampleRate24000Hz;
+        case 32000: return TMdaAudioDataSettings::ESampleRate32000Hz;
+        case 44100: return TMdaAudioDataSettings::ESampleRate44100Hz;
+        case 48000: return TMdaAudioDataSettings::ESampleRate48000Hz;
+        case 96000: return TMdaAudioDataSettings::ESampleRate96000Hz;
+        case 64000: return TMdaAudioDataSettings::ESampleRate64000Hz;
+        }
+    return KErrNotFound;
+    }
+
+LOCAL_C TInt GetChannels(TInt aChannels)
+    {
+    switch(aChannels)
+        {
+        case 1: return TMdaAudioDataSettings::EChannelsMono;
+        case 2: return TMdaAudioDataSettings::EChannelsStereo;
+        }
+    return KErrNotFound;
+    }
+    
+TInt CStreamPlayer::ClosestSupportedRate(TInt aRate)
+	{
+	if(aRate > 96000)
+		return 96000;
+	TInt rate = aRate;
+	while(GetSampleRate(rate) == KErrNotFound)
+		{
+		++rate;
+		}
+	return rate;
+	}
+
+CStreamPlayer::CStreamPlayer(MStreamProvider& aProvider,  MStreamObs& aObs) :
+ iProvider(aProvider), iObs(aObs), iVolume(KMaxVolume)
+	{	
+	}
+		
+CStreamPlayer::~CStreamPlayer()
+	{
+	iState |= EDied;
+	if(iState & EInited)
+		Close();
+	User::After(100000); //wait buffer to be flushed
+	ASSERT(iPtr.Length() == 0);
+	delete iStream;
+	}
+		
+		
+void CStreamPlayer::ConstructL()
+	{
+	iStream = CMdaAudioOutputStream::NewL(*this, EMdaPriorityMax);
+	iSilence.SetMax();
+	iSilence.FillZ();
+	}
+		
+
+TInt CStreamPlayer::OpenStream(TInt aRate, TInt aChannels, TUint32 aType)
+	{
+	Close();
+	
+	iType = aType;
+	
+	iRate = GetSampleRate(aRate);
+	if(iRate == KErrNotFound)
+		return KErrNotSupported;
+	
+	iChannels = GetChannels(aChannels);
+	if(iChannels == KErrNotFound)
+		return KErrNotSupported;
+	
+	Open();
+    
+    return KErrNone;
+	}
+
+
+TInt CStreamPlayer::MaxVolume() const
+	{
+	return KMaxVolume;
+	}
+
+void CStreamPlayer::SetVolume(TInt aNew)
+    {
+    
+    const TInt maxi = MaxVolume();
+    if(aNew > maxi)
+		return;
+    if(aNew < 0)
+    	return;
+    
+    iVolume = aNew;
+    
+    iState |= EVolumeChange;
+    }
+    
+ TInt CStreamPlayer::Volume() const
+    {
+	return iVolume;
+    }
+
+void CStreamPlayer::Open()
+	{
+	TMdaAudioDataSettings audioSettings;
+	audioSettings.Query();
+    audioSettings.iCaps = TMdaAudioDataSettings::ERealTime |
+     	TMdaAudioDataSettings::ESampleRateFixed; 
+    audioSettings.iSampleRate = iRate; 
+    audioSettings.iChannels = iChannels;
+	audioSettings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting;
+	audioSettings.iVolume = 0;
+	
+	iState &= ~EStopped;
+    iStream->Open(&audioSettings);    
+	}
+	
+void CStreamPlayer::Stop()
+	{
+	if(iState & (EStarted | EInited))
+		{
+		Close();
+		iState |= EStopped;
+		}
+	}
+	
+void CStreamPlayer::Start()
+	{
+	if(iPtr.Length() == 0)
+		{
+		iState |= EStarted;
+		if(iState & EInited)
+			{
+			Request();
+			}
+		else if(iState & EStopped)
+			{
+			Open();
+			}
+		}
+	}
+
+void CStreamPlayer::Close()
+	{
+	iState &= ~EInited;
+	iStream->Stop();
+	iState &= ~EStarted;
+	}
+	
+void CStreamPlayer::Request()
+	{
+	if(iState & EInited)
+		{
+		iPtr.Set(KNullDesC8);
+		
+		if(iState & EVolumeChange)
+			{
+       		const TReal newVol = iVolume;
+       		const TReal newMax = MaxVolume();
+       		const TInt maxVol = iStream->MaxVolume();
+       		const TReal max = static_cast<TReal>(maxVol);
+       		const TReal newvolume = (newVol * max) / newMax;
+       		const TInt vol = static_cast<TReal>(newvolume);
+       		iStream->SetVolume(vol);
+			iState &= ~EVolumeChange;
+			}
+			
+		if(iState & EStarted)
+			{
+	 		iPtr.Set(iProvider.Data());
+			}
+		if(iPtr.Length() == 0)
+			{
+			iPtr.Set(iSilence);
+			}
+		TRAPD(err, iStream->WriteL(iPtr));
+		if(err != KErrNone)
+			{
+			iObs.Complete(MStreamObs::EWrite, err);	
+			}
+	/*	else
+			{
+			iProvider.Written(iPtr.Length());
+			}*/
+		}
+	}
+	
+
+void CStreamPlayer::SetCapsL()
+	{
+	iStream->SetDataTypeL(iType);
+	iStream->SetAudioPropertiesL(iRate, iChannels);
+	}
+
+void CStreamPlayer::MaoscOpenComplete(TInt aError) 
+	{
+	if(aError == KErrNone)
+		{
+		TRAPD(err, SetCapsL());
+    	if(err == KErrNone)
+    		{
+    		iStream->SetPriority(EPriorityNormal, EMdaPriorityPreferenceTime);
+    		iState |= EInited;
+    		
+    		
+        	SetVolume(Volume());	
+    		
+    		if(iState & EStarted)
+    			{
+    			Request();
+    			}
+    			
+			}
+		aError = err;
+		}
+	if(!(iState & EDied))
+		iObs.Complete(MStreamObs::EInit, aError);
+	}
+	
+void CStreamPlayer::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)
+	{
+	iPtr.Set(KNullDesC8);
+	if(aError == KErrNone)
+		{
+		if(iState & EInited)
+			Request();
+		else
+			iStream->Stop();
+		}
+	else if(!(iState & EDied))
+		iObs.Complete(MStreamObs::EPlay, aError);
+	}
+	
+void CStreamPlayer::MaoscPlayComplete(TInt aError)
+	{	
+	iPtr.Set(KNullDesC8);
+	iState &= ~EStarted;
+	if(!(iState & EDied))
+		iObs.Complete(MStreamObs::EClose, aError);
+	}
+	
+TBool CStreamPlayer::Playing() const
+	{
+	return (iState & EInited) && (iState & EStarted);
+	}
+
+TBool CStreamPlayer::Closed() const
+	{
+	return !(iState & EInited) && !(iState & EDied);
+	}
+	
+	/*
+void CStreamPlayer::Request()
+	{
+	SetActive();
+	TRequestStatus* s = &iStatus;
+	User::RequestComplete(s, KErrNone);
+	}
+	//		iTimer.After(0);
+	*/
+	
+
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/symbian/streamplayer.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,89 @@
+#ifndef STREAMPLAYER_H
+#define STREAMPLAYER_H
+
+#include<MdaAudioOutputStream.h>
+
+const TInt KSilenceBuffer = 256;
+
+class MStreamObs
+    {
+    public:
+    	enum 
+    	{
+    	EInit, 
+    	EPlay,
+    	EWrite,
+    	EClose,	
+    	};
+        virtual void Complete(TInt aState, TInt aError) = 0;
+    };
+
+class MStreamProvider
+	{
+	public:
+		virtual TPtrC8 Data() = 0;	
+	};
+
+NONSHARABLE_CLASS(CStreamPlayer) : public CBase, public MMdaAudioOutputStreamCallback
+	{
+	public:
+		CStreamPlayer(MStreamProvider& aProvider, MStreamObs& aObs);
+		~CStreamPlayer();
+		void ConstructL();
+		
+		static TInt ClosestSupportedRate(TInt aRate);
+		
+		TInt OpenStream(TInt aRate, TInt aChannels, TUint32 aType = KMMFFourCCCodePCM16);
+		
+		void SetVolume(TInt aNew);
+		TInt Volume() const;
+		TInt MaxVolume() const;
+		
+		void Stop();
+		void Start();
+		void Open();
+		void Close();
+		
+		TBool Playing() const;
+		TBool Closed() const;
+		
+	private:
+
+		void MaoscOpenComplete(TInt aError) ;
+		void MaoscBufferCopied(TInt aError, const TDesC8& aBuffer);
+		void MaoscPlayComplete(TInt aError);
+	
+	private:
+		void Request();
+		void SetCapsL();
+
+	private:
+		MStreamProvider& iProvider;
+		MStreamObs& iObs;	
+		TInt iVolume;
+	
+		CMdaAudioOutputStream* iStream;
+	
+		TInt iRate;
+		TInt iChannels;
+		TUint32 iType;
+		
+		enum 
+			{
+				ENone = 0,
+				EInited = 0x1,
+				EStarted = 0x2,
+				EStopped = 0x4,
+				EVolumeChange = 0x8,
+				EDied		  = 0x10
+			};
+		
+		TInt iState;
+		TBuf8<KSilenceBuffer> iSilence;
+		TPtrC8 iPtr;
+	
+	};
+
+
+#endif
+
--- a/src/events/SDL_events.c	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/events/SDL_events.c	Sun Jun 24 18:26:35 2007 +0000
@@ -169,7 +169,7 @@
 
 		/* The event thread will handle timers too */
 		SDL_SetTimerThreaded(2);
-#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC) && !defined(__SYMBIAN32__)
 #undef SDL_CreateThread
 		SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL, NULL, NULL);
 #else
--- a/src/file/SDL_rwops.c	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/file/SDL_rwops.c	Sun Jun 24 18:26:35 2007 +0000
@@ -29,7 +29,7 @@
 #include "SDL_rwops.h"
 
 
-#if defined(__WIN32__)
+#if defined(__WIN32__) && !defined(__SYMBIAN32__)
 
 /* Functions to read/write Win32 API file pointers */
 /* Will not use it on WinCE because stdio is buffered, it means
@@ -372,7 +372,7 @@
 		return NULL;
 	}
 
-#if defined(__WIN32__)
+#if defined(__WIN32__) && !defined(__SYMBIAN32__)
 	rwops = SDL_AllocRW();
 	if (!rwops)
 		return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA1/SDL_main.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,152 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_main.cpp
+    The Epoc executable startup functions 
+
+    Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi)
+*/
+
+#include <e32std.h>
+#include <e32def.h>
+#include <e32svr.h>
+#include <e32base.h>
+#include <estlib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <w32std.h>
+#include <apgtask.h>
+
+#include "SDL_error.h"
+
+#if defined(__WINS__)
+#include <estw32.h>
+IMPORT_C void RegisterWsExe(const TDesC &aName);
+#endif
+
+/* The prototype for the application's main() function */
+#define main	SDL_main
+extern "C" int main (int argc, char *argv[], char *envp[]);
+extern "C" void exit (int ret);
+
+
+/* Epoc main function */
+
+#ifdef __WINS__
+
+
+void GetCmdLine(int& aArgc, char**& aArgv)
+    {
+    RChunk chunk;
+
+    if(chunk.OpenGlobal(RThread().Name(), ETrue) != KErrNone)
+        return;
+
+    TUint* ptr = (TUint*) chunk.Base();
+    if(ptr != NULL)
+        {
+        aArgc = (int)    *(ptr); // count
+        aArgv = (char**) *(ptr + 1);
+        }
+    chunk.Close();
+    }
+
+#endif
+
+
+TInt E32Main()
+    {
+    /*  Get the clean-up stack */
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+
+    /* Arrange for multi-threaded operation */
+	SpawnPosixServerThread();	
+
+    /* Get args and environment */
+	int argc=0;
+	char** argv=0;
+	char** envp=0;
+
+#ifndef __WINS__
+	__crt0(argc,argv,envp);	
+#else
+    GetCmdLine(argc, argv);
+#endif
+    /* Start the application! */
+
+    /* Create stdlib */
+    _REENT;
+
+    /* Set process and thread priority and name */
+
+    RThread currentThread;
+	RProcess thisProcess;
+	TParse exeName;
+	exeName.Set(thisProcess.FileName(), NULL, NULL);
+    currentThread.Rename(exeName.Name());
+    currentThread.SetProcessPriority(EPriorityLow);
+    currentThread.SetPriority(EPriorityMuchLess);
+
+     /* Call stdlib main */
+    int ret = main(argc, argv, envp); /* !! process exits here if there is "exit()" in main! */	
+    
+    /* Call exit */
+    //exit(ret); /* !! process exits here! */	
+    //Markus: I do not understand above
+    //I commented it at let this function
+    //to return ret value - was it purpose
+    //that cleanup below is not called at all - why?
+
+    /* Free resources and return */
+    
+    _cleanup(); //this is normally called at exit, I call it here, Markus 
+
+    CloseSTDLIB();
+   	delete cleanup;	
+#ifdef __WINS__
+//    User::Panic(_L("exit"), ret);
+  //  RThread().Kill(ret); //Markus  get rid of this thread
+  //  RThread().RaiseException(EExcKill);
+#endif
+    return ret;//Markus, or exit(ret); ??
+  //return(KErrNone);
+    }
+
+
+#ifdef __WINS__
+EXPORT_C TInt WinsMain()
+    {
+    return E32Main();
+ //   return WinsMain(0, 0, 0);
+    }
+#endif
+
+/* Epoc dll entry point */
+#if defined(__WINS__)
+GLDEF_C TInt E32Dll(TDllReason)
+	{
+	return(KErrNone);
+	}
+#endif
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA2/SDL_main.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,1035 @@
+/*
+    SDL_Main.cpp
+    Symbian OS services for SDL
+
+    Markus Mertama
+*/
+
+
+#include "epoc_sdl.h"
+
+#include"sdlepocapi.h"
+#include <e32base.h>
+#include <estlib.h>
+#include <stdio.h>
+#include <badesca.h>
+
+#include "vectorbuffer.h"
+#include <w32std.h>
+#include <aknappui.h>
+#include <aknapp.h>
+#include "SDL_epocevents_c.h"
+#include "SDL_keysym.h"
+#include "dsa.h"
+
+
+#ifdef SYMBIANC
+#include <reent.h>
+#endif
+
+//Markus Mertama
+
+
+extern SDLKey* KeyMap();
+extern void ResetKeyMap();
+
+class CCurrentAppUi;
+
+//const TUid KSDLUid =  { 0xF01F3D69 };
+
+NONSHARABLE_CLASS(EnvUtils)
+	{
+	public:
+	static void DisableKeyBlocking();
+	static TBool Rendezvous(RThread& aThread, TRequestStatus& aStatus);
+	};
+
+TInt Panic(TInt aErr, TInt aLine)
+	{
+	TBuf<64> b;
+	b.Format(_L("Main at %d"), aLine);
+	User::Panic(b, aErr);
+	return 0;	
+	}
+	
+
+NONSHARABLE_CLASS(CCurrentAppUi) : public CAknAppUi
+	{
+	public:
+	static CCurrentAppUi* Cast(CEikAppUi* aUi);
+	void DisableKeyBlocking();
+	};
+	
+	
+CCurrentAppUi* CCurrentAppUi::Cast(CEikAppUi* aUi)
+	{
+	return static_cast<CCurrentAppUi*>(aUi);	
+	}
+	
+void CCurrentAppUi::DisableKeyBlocking()	
+	{
+	SetKeyBlockMode(ENoKeyBlock);	
+	}
+
+
+class CEventQueue : public CBase, public MEventQueue
+    {
+    public:
+        static CEventQueue* NewL();
+        ~CEventQueue();
+    public:
+        TInt Append(const TWsEvent& aEvent);
+       	const TWsEvent& Shift();
+       	void Lock();
+       	void Unlock();
+        TBool HasData();
+    private:
+        TVector<TWsEvent, 64> iVector;
+        RCriticalSection iCS;
+    };
+    
+ CEventQueue* CEventQueue::NewL()
+    {
+    CEventQueue* q = new (ELeave) CEventQueue();
+    CleanupStack::PushL(q);
+    User::LeaveIfError(q->iCS.CreateLocal());
+    CleanupStack::Pop();
+    return q;
+    }
+    
+CEventQueue::~CEventQueue()
+    {
+    iCS.Close();
+    }
+    
+TInt CEventQueue::Append(const TWsEvent& aEvent)
+    {
+    iCS.Wait();
+   	const TInt err = iVector.Append(aEvent);
+    iCS.Signal();
+    return err;
+    }
+    
+    
+TBool CEventQueue::HasData()
+    {
+    return iVector.Size() > 0;
+    }
+
+
+void CEventQueue::Lock()
+	{
+    iCS.Wait();
+	}
+	
+void CEventQueue::Unlock()
+	{
+	iCS.Signal();
+	}
+
+const TWsEvent& CEventQueue::Shift()
+    {
+    const TWsEvent& event =  iVector.Shift();
+    return event;
+    }
+
+
+TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, TAny* aItem) :
+iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
+    {
+    }
+
+class CEikonEnv;
+class CSdlAppServ;
+
+    
+NONSHARABLE_CLASS(EpocSdlEnvData)
+    {
+    public:
+    void Free();
+    CEventQueue*            iEventQueue;
+    TMainFunc				iMain;
+    TInt            		iEpocEnvFlags;
+    int                     iArgc;
+    char**                  iArgv;
+    CDsa*                   iDsa;
+    CSdlAppServ*            iAppSrv;
+    TThreadId               iId;
+    CArrayFix<TSdlCleanupItem>* iCleanupItems; 
+    CEikAppUi*				iAppUi;
+    CSDL*					iSdl;
+    };
+  
+   
+EpocSdlEnvData* gEpocEnv;
+
+#define MAINFUNC(x) EXPORT_C TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
+    
+MAINFUNC(1)
+MAINFUNC(2)
+MAINFUNC(3)
+MAINFUNC(4)
+MAINFUNC(5)
+MAINFUNC(6)
+
+EXPORT_C TMainFunc::TMainFunc() 
+	{
+	Mem::FillZ(iMainFunc, sizeof(iMainFunc));
+	}
+	
+
+const void* TMainFunc::operator[](TInt aIndex) const
+	{
+	return iMainFunc[aIndex];
+	}
+
+
+NONSHARABLE_CLASS(CSdlAppServ) : public CActive
+    {
+    public:
+        enum
+            {
+            EAppSrvNoop = CDsa::ELastDsaRequest,
+            EAppSrvWindowWidth,
+            EAppSrvWindowHeight,
+            EAppSrvWindowDisplayMode,
+            EAppSrvWindowPointerCursorMode,
+            EAppSrvDsaStatus,
+            EAppSrvStopThread,
+            EAppSrvWaitDsa
+            };
+        CSdlAppServ();
+        void ConstructL();
+        ~CSdlAppServ();
+        TInt Request(TInt aService);
+        TInt RequestValue(TInt aService);
+        void Init(); 
+        void PanicMain(TInt aReason);
+        void PanicMain(const TDesC& aInfo, TInt aReason);
+        void SetObserver(MSDLObserver* aObserver);
+        TInt ObserverEvent(TInt aEvent, TInt aParam);
+        void SetParam(TInt aParam);
+        void HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread);
+        MSDLObserver* Observer();
+    private:
+        void RunL();
+        void DoCancel();
+    private:
+        const TThreadId iMainId;
+        RThread iAppThread;
+        TInt iService;
+        TInt iReturnValue;
+        RSemaphore iSema;
+        MSDLObserver* iObserver;
+        TRequestStatus* iStatusPtr;
+    };
+    
+CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())
+    {
+    }
+    
+    
+    
+MSDLObserver* CSdlAppServ::Observer()
+	{
+	return iObserver;
+	}
+	
+	
+void CSdlAppServ::SetObserver(MSDLObserver* aObserver)
+	{
+	iObserver = aObserver;
+	}	
+	
+TInt CSdlAppServ::ObserverEvent(TInt aEvent, TInt aParam)
+	{
+	if(iObserver != NULL)
+		{
+		if(RThread().Id() == gEpocEnv->iId)
+			{
+			return iObserver->SdlThreadEvent(aEvent, aParam);
+			}
+		else if(RThread().Id() == iMainId)
+			{
+			return iObserver->SdlEvent(aEvent, aParam);
+			}
+		PANIC(KErrNotSupported);
+		}
+	return 0;
+	}
+	
+void CSdlAppServ::PanicMain(TInt aReason)    
+    {
+    iAppThread.Panic(RThread().Name(), aReason);
+    }
+    
+void CSdlAppServ::PanicMain(const TDesC& aInfo, TInt aReason)    
+    {
+    iAppThread.Panic(aInfo, aReason);
+    }    
+    
+void CSdlAppServ::ConstructL()
+    {
+    CActiveScheduler::Add(this);
+    User::LeaveIfError(iSema.CreateLocal(1));
+    iStatus = KRequestPending;
+    iStatusPtr = &iStatus;
+    SetActive();
+    }
+        
+ CSdlAppServ::~CSdlAppServ()
+    {
+    Cancel();
+    if(iSema.Handle() != NULL)
+        iSema.Signal();
+    iSema.Close();
+    iAppThread.Close();
+    }
+    
+TInt CSdlAppServ::Request(TInt aService)
+    {
+    if(RThread().Id() != iAppThread.Id())
+    	{
+    	iSema.Wait();
+    	iService = aService;
+    	iAppThread.RequestComplete(iStatusPtr, KErrNone); 
+    	return KErrNone;
+    	}
+    return KErrBadHandle;
+    }
+    
+TInt CSdlAppServ::RequestValue(TInt aService)
+    {
+    Request(aService);
+    Request(EAppSrvNoop);
+    return iReturnValue;
+    }
+   
+void CSdlAppServ::Init()
+    {
+    PANIC_IF_ERROR(iAppThread.Open(iMainId));
+    }
+
+void CSdlAppServ::SetParam(TInt aParam)
+	{
+	iReturnValue = aParam;
+	}
+	
+void CSdlAppServ::HandleObserverValue(TInt aService, TInt aReturnValue, TBool aMainThread)
+	{
+	if(iObserver != NULL && aMainThread)
+		{
+		switch(aService)
+			{
+			case MSDLObserver::EEventScreenSizeChanged:
+			if(aReturnValue == MSDLObserver::EScreenSizeChangedDefaultPalette)
+				EpocSdlEnv::LockPalette(EFalse);
+			break;
+			}
+		}
+	if(!aMainThread && aService == MSDLObserver::EEventSuspend)
+		{
+		if(iObserver == NULL || 
+		(gEpocEnv->iDsa->Stopped() && aReturnValue != MSDLObserver::ESuspendNoSuspend))
+			{
+			EpocSdlEnv::Suspend();
+			}
+		}
+	}
+
+void CSdlAppServ::RunL()
+    {
+    if(iStatus == KErrNone)
+        {
+        switch(iService)
+            {
+            case CSdlAppServ::EAppSrvWaitDsa:
+            	EpocSdlEnv::SetWaitDsa();
+            	iReturnValue = EpocSdlEnv::IsDsaAvailable();
+            //		}
+            //	gEpocEnv->iDsa->Stop();
+            //	gEpocEnv->iDsa->RestartL();
+            	break;
+           	 case CSdlAppServ::EAppSrvStopThread:
+            	gEpocEnv->iDsa->SetSuspend();
+            	break;
+            case EpocSdlEnv::EDisableKeyBlocking:
+                EnvUtils::DisableKeyBlocking();
+                break;
+          
+            case EAppSrvWindowPointerCursorMode:
+                iReturnValue = gEpocEnv->iDsa != NULL ?
+                 gEpocEnv->iDsa->Session().PointerCursorMode() : KErrNotReady; 
+                break;
+            case EAppSrvDsaStatus:
+            	gEpocEnv->iDsa->Stop();
+                iReturnValue = KErrNone;
+                break;
+            case CDsa::ERequestUpdate:
+            	gEpocEnv->iDsa->UnlockHWSurfaceRequestComplete();
+            	break;
+            case EAppSrvNoop:
+                break;
+            case MSDLObserver::EEventResume:
+            case MSDLObserver::EEventSuspend:
+            case MSDLObserver::EEventScreenSizeChanged:
+            case MSDLObserver::EEventWindowReserved:
+            case MSDLObserver::EEventKeyMapInit:
+            case MSDLObserver::EEventWindowNotAvailable:
+            case MSDLObserver::EEventMainExit:
+            	iReturnValue = ObserverEvent(iService, iReturnValue);
+            	HandleObserverValue(iService, iReturnValue, ETrue);
+            	break;
+            default:
+                PANIC(KErrNotSupported);
+            }
+        iStatus = KRequestPending;
+        iStatusPtr = &iStatus;
+        SetActive();
+        }
+    iSema.Signal();
+    }
+    
+void CSdlAppServ::DoCancel()
+    {
+    iSema.Wait();
+    TRequestStatus* s = &iStatus;
+    iAppThread.RequestComplete(s, KErrCancel); 
+    }
+ 
+
+
+MEventQueue& EpocSdlEnv::EventQueue()
+    {
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    return *gEpocEnv->iEventQueue;
+    }
+
+
+TBool EpocSdlEnv::Flags(TInt aFlag)
+    {
+	const TInt flag = gEpocEnv->iEpocEnvFlags & aFlag;
+	return flag == aFlag;
+    }
+
+TInt EpocSdlEnv::Argc()
+    {
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    return gEpocEnv->iArgc;
+    }
+    
+    
+char** EpocSdlEnv::Argv()
+    {
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    return gEpocEnv->iArgv;
+    }
+    
+    
+TBool EpocSdlEnv::IsDsaAvailable()
+    {
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
+    }
+
+  
+void EpocSdlEnv::WaitDsaAvailable()
+	{
+	EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowNotAvailable, 0);
+	gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);
+	if(EpocSdlEnv::Flags(CSDL::EEnableFocusStop))
+		{
+		EpocSdlEnv::ObserverEvent(MSDLObserver::EEventSuspend, 0);
+		}
+	}
+	
+void EpocSdlEnv::Suspend()
+	{
+	if(gEpocEnv->iDsa->Stopped() || EpocSdlEnv::Flags(CSDL::EEnableFocusStop))
+		{
+	//	gEpocEnv->iDsa->ReleaseStop(); 
+		gEpocEnv->iDsa->SetSuspend(); 
+		RThread().Suspend();
+		EpocSdlEnv::ObserverEvent(MSDLObserver::EEventResume, 0);
+		}
+	}
+	
+void EpocSdlEnv::SetWaitDsa()
+	{
+	if(!IsDsaAvailable())
+		{
+		RThread th;
+		th.Open(gEpocEnv->iId);
+		th.Suspend();
+		th.Close();
+		gEpocEnv->iDsa->SetSuspend(); 
+		}
+	}
+	
+void EpocSdlEnv::Resume()
+	{
+	gEpocEnv->iDsa->Resume();
+	RThread th;
+	th.Open(gEpocEnv->iId);
+	th.Resume();
+	th.Close();
+	
+	const TInt value = gEpocEnv->iAppSrv->ObserverEvent(MSDLObserver::EEventResume, 0);
+	gEpocEnv->iAppSrv->HandleObserverValue(MSDLObserver::EEventResume, value, ETrue);
+	}
+    
+
+TInt EpocSdlEnv::AllocSwSurface(const TSize& aSize, TDisplayMode aMode)
+	{
+	return gEpocEnv->iDsa->AllocSurface(EFalse, aSize, aMode);
+	}
+	
+TInt EpocSdlEnv::AllocHwSurface(const TSize& aSize, TDisplayMode aMode)
+	{
+	return gEpocEnv->iDsa->AllocSurface(ETrue, aSize, aMode);
+	}
+		
+	
+void EpocSdlEnv::UnlockHwSurface()
+	{
+	gEpocEnv->iDsa->UnlockHwSurface();
+	}
+	
+TUint8* EpocSdlEnv::LockHwSurface()
+	{
+	return gEpocEnv->iDsa->LockHwSurface();
+	}
+
+
+void EpocSdlEnv::UpdateSwSurface()
+	{
+	gEpocEnv->iDsa->UpdateSwSurface();
+	}
+	
+TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
+	{
+	return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
+	}
+	
+void EpocSdlEnv::Request(TInt aService)
+    {
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    gEpocEnv->iAppSrv->Request(aService);
+    }
+    
+    
+TSize EpocSdlEnv::WindowSize(const TSize& aRequestedSize)
+    { 
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    if(EpocSdlEnv::Flags(CSDL::EAllowImageResize) && gEpocEnv->iDsa->WindowSize() != aRequestedSize)
+    	{
+    	TRAP_IGNORE(gEpocEnv->iDsa->CreateZoomerL(aRequestedSize));
+    	}
+    return gEpocEnv->iDsa->WindowSize();
+    }
+    
+ TSize EpocSdlEnv::WindowSize()
+    { 
+    __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
+    return gEpocEnv->iDsa->WindowSize();
+    }   
+    
+TDisplayMode EpocSdlEnv::DisplayMode()
+    {
+    return gEpocEnv->iDsa->DisplayMode();
+    }
+    
+TPointerCursorMode EpocSdlEnv::PointerMode()
+    {
+    return static_cast<TPointerCursorMode>
+    (gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWindowPointerCursorMode));
+    }
+    
+TInt EpocSdlEnv::SetPalette(TInt aFirstcolor, TInt aColorCount, TUint32* aPalette)  
+	{
+	return 	gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
+	}
+
+void EpocSdlEnv::PanicMain(TInt aErr)
+    {
+    gEpocEnv->iAppSrv->PanicMain(aErr);
+    }
+    
+    
+TInt EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
+    {
+    TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
+    return err;
+    }
+    
+void EpocSdlEnv::RemoveCleanupItem(TAny* aItem)
+    {
+    for(TInt i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
+        {
+        if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
+            gEpocEnv->iCleanupItems->Delete(i);
+        }
+    }
+    
+void EpocSdlEnv::CleanupItems()     
+	{
+	const TThreadId id = RThread().Id();
+	TInt last = gEpocEnv->iCleanupItems->Count() - 1;
+	TInt i;
+	for(i = last; i >= 0 ; i--)
+        {
+        TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
+        if(item.iThread == id)
+        	{
+        	item.iThread = TThreadId(0); 
+        	item.iOperation(item.iItem);
+        	}
+        }
+    last = gEpocEnv->iCleanupItems->Count() - 1;
+	for(i = last; i >= 0 ; i--)
+        {
+        TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
+        if(item.iThread == TThreadId(0))
+        	{
+        	gEpocEnv->iCleanupItems->Delete(i);
+        	}
+        }
+	}
+	
+void EpocSdlEnv::FreeSurface()
+	{
+	Request(CSdlAppServ::EAppSrvDsaStatus);
+	gEpocEnv->iDsa->Free();
+	}
+  
+void EpocSdlEnv::LockPalette(TBool aLock)
+	{
+	gEpocEnv->iDsa->LockPalette(aLock);
+	}
+    
+void EpocSdlEnv::ObserverEvent(TInt aService, TInt aParam)
+	{
+	const TBool sdlThread = RThread().Id() == gEpocEnv->iId;
+	const TInt valuea = gEpocEnv->iAppSrv->ObserverEvent(aService, aParam);
+	gEpocEnv->iAppSrv->HandleObserverValue(aService, valuea, !sdlThread);
+	if(sdlThread)
+		{
+		gEpocEnv->iAppSrv->SetParam(aParam);
+		const TInt valuet = gEpocEnv->iAppSrv->RequestValue(aService);
+		gEpocEnv->iAppSrv->HandleObserverValue(aService, valuet, EFalse);	
+		}
+	}
+			
+    
+TPoint EpocSdlEnv::WindowCoordinates(const TPoint& aPoint)    
+    {
+    return gEpocEnv->iDsa->WindowCoordinates(aPoint);	
+    }
+    
+void EpocSdlEnv::PanicMain(const TDesC& aInfo, TInt aErr)
+    {
+    gEpocEnv->iAppSrv->PanicMain(aInfo, aErr);
+    }
+//Dsa is a low priority ao, it has to wait if its pending event, but ws
+//event has been prioritized before it
+//this is not called from app thread!
+void EpocSdlEnv::WaitDeviceChange() 
+    {
+  	LockPalette(ETrue);
+    gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWaitDsa);
+    const TSize sz = WindowSize();
+    const TInt param = reinterpret_cast<TInt>(&sz);
+    ObserverEvent(MSDLObserver::EEventScreenSizeChanged, param);
+    	
+   // RThread().Suspend();
+    }  
+    
+LOCAL_C TBool CheckSdl() 
+    {
+    TInt isExit = ETrue;
+    RThread sdl;
+    if(sdl.Open(gEpocEnv->iId) == KErrNone)
+        {
+        if(sdl.ExitType() == EExitPending)
+            {
+            isExit = EFalse;
+            }
+        sdl.Close();
+        }
+    return isExit;
+    }
+    
+void EpocSdlEnvData::Free()
+    {
+    if(RThread().Id() == gEpocEnv->iId)
+    	{
+    	iDsa->Free();
+    	return;
+    	}
+   
+    __ASSERT_ALWAYS(iArgv == NULL || CheckSdl(), PANIC(KErrNotReady));
+        
+    for(TInt i = 0; i < iArgc; i++)
+        User::Free( iArgv[i] );
+        
+    User::Free(iArgv);	
+     
+    
+    delete iEventQueue;
+    
+    if(iDsa != NULL)
+    	iDsa->Free();
+    
+	delete iDsa;
+	delete iAppSrv;
+    }
+
+_LIT(KSDLMain, "SDLMain");
+
+LOCAL_C int MainL()
+    {
+    gEpocEnv->iCleanupItems = new (ELeave) CArrayFixFlat<TSdlCleanupItem>(8);
+    
+    char** envp=0;
+     /* !! process exits here if there is "exit()" in main! */
+    int ret = 0;
+    for(TInt i = 0; i  < 6; i++)
+        {
+        void* f = (void*) gEpocEnv->iMain[i];
+        if(f != NULL)
+            {
+            switch(i)
+                {
+                case 0:
+                    ret = ((mainfunc1)f)(); 
+                    return ret;
+                case 3:
+                    ((mainfunc1)f)(); 
+                    return ret;
+                case 1:
+                    ret = ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
+                    return ret;
+                case 4:
+                    ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
+                    return ret;
+                case 2:
+                    ret = ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
+                    return ret;
+                case 5:
+                    ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
+                    return ret;
+                }
+            }
+        }
+    PANIC(KErrNotFound);
+    return 0;
+    }
+
+LOCAL_C TInt DoMain(TAny* /*aParam*/)
+    {
+    
+    
+    CTrapCleanup* cleanup = CTrapCleanup::New();
+      	
+	TBool fbsconnected = EFalse;
+	if(RFbsSession::GetSession() == NULL)
+	    {
+	    PANIC_IF_ERROR(RFbsSession::Connect());
+	    fbsconnected = ETrue;
+	    }
+	
+ 	gEpocEnv->iAppSrv->Init();	
+
+#ifdef SYMBIANC 
+    // Create stdlib 
+    _REENT;
+#endif
+
+    // Call stdlib main
+    int ret = 0;
+    
+    //completes waiting rendesvous
+    RThread::Rendezvous(KErrNone);
+    
+    TRAPD(err, err = MainL());
+    
+    EpocSdlEnv::ObserverEvent(MSDLObserver::EEventMainExit, err);
+   
+    // Free resources and return
+    
+  	EpocSdlEnv::CleanupItems();
+        
+    gEpocEnv->iCleanupItems->Reset();
+    delete gEpocEnv->iCleanupItems;
+    gEpocEnv->iCleanupItems = NULL;
+    
+    gEpocEnv->Free(); //free up in thread resources 
+    
+#ifdef SYMBIANC    
+    _cleanup(); //this is normally called at exit, I call it here
+#endif
+
+    if(fbsconnected)
+        RFbsSession::Disconnect();
+    
+#ifdef SYMBIANC     
+    CloseSTDLIB();
+#endif
+       
+ //   delete as;
+   	delete cleanup;	
+
+    return err == KErrNone ? ret : err;;
+    }
+    
+
+    
+EXPORT_C CSDL::~CSDL()
+    {
+   	gEpocEnv->Free();
+    User::Free(gEpocEnv);
+    gEpocEnv->iSdl = NULL;
+    }
+
+EXPORT_C CSDL* CSDL::NewL(TInt aFlags)
+    {
+    __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
+    gEpocEnv = (EpocSdlEnvData*) User::AllocL(sizeof(EpocSdlEnvData));
+    Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
+   
+    gEpocEnv->iEpocEnvFlags = aFlags;
+    gEpocEnv->iEventQueue = CEventQueue::NewL();
+   
+    gEpocEnv->iAppSrv = new (ELeave) CSdlAppServ();
+    gEpocEnv->iAppSrv->ConstructL();
+    
+    CSDL* sdl = new (ELeave) CSDL();
+    
+    gEpocEnv->iSdl = sdl;
+    
+    return sdl;
+    }
+    
+  /*  
+EXPORT_C void CSDL::ReInitL(TFlags aFlags)
+	{
+	const TFlags prevFlags = gEpocEnv->iEpocEnvFlags;
+	gEpocEnv->iEpocEnvFlags = aFlags;
+	TInt err = KErrNone;
+	if(((prevFlags & EDrawModeDSB) != (aFlags & EDrawModeDSB)) && gEpocEnv->iDsa)
+		{
+		delete gEpocEnv->iDsa;
+		gEpocEnv->iDsa = NULL;
+		gEpocEnv->iDsa = CDsa::RecreateL(EpocSdlEnv::Flags(CSDL::EDrawModeDSB));
+		}
+	}
+ */
+
+
+EXPORT_C void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
+    {
+    if(gEpocEnv->iDsa == NULL)
+    	gEpocEnv->iDsa = CDsa::CreateL(aSession);
+    gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
+    }
+        
+   
+EXPORT_C TThreadId CSDL::CallMainL(const TMainFunc& aFunc, TRequestStatus* const aStatus, const CDesC8Array* const aArg, TInt aFlags, TInt aStackSize)
+    {
+    ASSERT(gEpocEnv != NULL);
+    gEpocEnv->iMain = aFunc;
+    const TBool args = aArg != NULL;
+    
+    gEpocEnv->iArgc = aArg->Count() + 1;
+    gEpocEnv->iArgv = (char**) User::AllocL(sizeof(char*) * (gEpocEnv->iArgc + 1));  
+      
+    TInt k = 0;
+    const TFileName processName = RProcess().FileName();
+    const TInt len = processName.Length();
+    gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);
+    Mem::Copy(gEpocEnv->iArgv[k], processName.Ptr(), len);
+    gEpocEnv->iArgv[k][len] = 0;
+      
+    for(TInt i =  0; args && (i < aArg->Count()); i++)
+        {
+        k++;
+        const TInt len = aArg->MdcaPoint(i).Length();
+        gEpocEnv->iArgv[k] = (char*) User::AllocL(len + 1);
+        Mem::Copy(gEpocEnv->iArgv[k], aArg->MdcaPoint(i).Ptr(), len);
+        gEpocEnv->iArgv[k][len] = 0;
+        }
+        
+    gEpocEnv->iArgv[gEpocEnv->iArgc] = NULL;
+         
+    RThread thread;
+    User::LeaveIfError(thread.Create(KSDLMain, DoMain, aStackSize, NULL, NULL));
+    
+    if(aStatus != NULL)
+    	{
+    	thread.Logon(*aStatus);
+    	}
+    	
+    gEpocEnv->iId = thread.Id();
+    thread.SetPriority(EPriorityLess);
+    if((aFlags & CSDL::ERequestResume) == 0)
+        {
+        thread.Resume();
+        }
+    thread.Close();
+    return gEpocEnv->iId;
+    }
+    
+EXPORT_C TInt CSDL::AppendWsEvent(const TWsEvent& aEvent)
+    {
+    return EpocSdlEnv::EventQueue().Append(aEvent);
+    }
+    
+EXPORT_C void CSDL::SDLPanic(const TDesC& aInfo, TInt aErr)
+    {
+    EpocSdlEnv::PanicMain(aInfo, aErr);
+    }
+    
+EXPORT_C TInt CSDL::GetSDLCode(TInt aScanCode)
+    {
+    if(aScanCode < 0)
+        return MAX_SCANCODE;
+    if(aScanCode >= MAX_SCANCODE)
+        return -1;
+    return KeyMap()[aScanCode];
+    }
+    
+EXPORT_C TInt CSDL::SDLCodesCount() const
+	{
+	return MAX_SCANCODE;
+	}
+	
+EXPORT_C void CSDL::ResetSDLCodes()
+	{
+	ResetKeyMap();
+	}
+    
+EXPORT_C void CSDL::SetOrientation(TOrientationMode aMode)
+	{
+	gEpocEnv->iDsa->SetOrientation(aMode);
+	}
+    
+EXPORT_C TInt CSDL::SetSDLCode(TInt aScanCode, TInt aSDLCode)
+    {
+    const TInt current = GetSDLCode(aScanCode);
+    if(aScanCode >= 0 && aScanCode < MAX_SCANCODE)
+        KeyMap()[aScanCode] = static_cast<SDLKey>(aSDLCode);
+    return current;
+    }
+
+
+EXPORT_C MSDLObserver* CSDL::Observer()
+	{
+	return gEpocEnv->iAppSrv->Observer();
+	}    
+    
+EXPORT_C void CSDL::SetObserver(MSDLObserver* aObserver)
+	{
+	gEpocEnv->iAppSrv->SetObserver(aObserver);
+	}
+	
+EXPORT_C void CSDL::Resume()
+	{
+	EpocSdlEnv::Resume();
+	}
+	
+EXPORT_C void CSDL::Suspend()
+	{
+	gEpocEnv->iDsa->DoStop();
+	}
+	
+EXPORT_C CSDL::CSDL()
+    {
+    }
+
+EXPORT_C void CSDL::DisableKeyBlocking(CAknAppUi& aAppUi) const
+	{
+	gEpocEnv->iAppUi = &aAppUi;
+	EnvUtils::DisableKeyBlocking();
+	}
+
+EXPORT_C TInt CSDL::SetBlitter(MBlitter* aBlitter)
+	{
+	if(gEpocEnv && gEpocEnv->iDsa)
+		{
+		gEpocEnv->iDsa->SetBlitter(aBlitter);
+		return KErrNone;
+		}
+	return KErrNotReady;
+	}
+		
+	
+EXPORT_C TInt CSDL::AppendOverlay(MOverlay& aOverlay, TInt aPriority)
+	{
+	if(gEpocEnv && gEpocEnv->iDsa)
+		{
+		return gEpocEnv->iDsa->AppendOverlay(aOverlay, aPriority);
+		}
+	return KErrNotReady;
+	}
+
+EXPORT_C TInt CSDL::RemoveOverlay(MOverlay& aOverlay)	
+	{
+	if(gEpocEnv && gEpocEnv->iDsa)
+		{
+		return gEpocEnv->iDsa->RemoveOverlay(aOverlay);
+		}
+	return KErrNotReady;
+	}
+
+EXPORT_C TInt CSDL::RedrawRequest()
+	{
+	if(gEpocEnv && gEpocEnv->iDsa)
+		{
+		return gEpocEnv->iDsa->RedrawRequest();
+		}
+	return KErrNotReady;
+	}
+	
+/*
+EXPORT_C CSDL* CSDL::Current()
+    {
+    return gEpocEnv != NULL ? gEpocEnv->iSdl : NULL;
+    }
+
+    
+EXPORT_C TInt CSDL::SetVolume(TInt aVolume)
+    {
+    return EpocSdlEnv::SetVolume(aVolume);
+    } 
+    
+EXPORT_C TInt CSDL::Volume() const
+    {
+    return EpocSdlEnv::Volume();
+    }     
+	
+EXPORT_C TInt CSDL::MaxVolume() const
+    {
+    return EpocSdlEnv::MaxVolume();
+    } 	
+*/
+			
+void EnvUtils::DisableKeyBlocking()
+	{
+	if(gEpocEnv->iAppUi != NULL)
+		return CCurrentAppUi::Cast(gEpocEnv->iAppUi)->DisableKeyBlocking();
+	}
+	
+TBool EnvUtils::Rendezvous(RThread& aThread, TRequestStatus& aStatus)
+	{
+	if(gEpocEnv->iId != TThreadId(0) &&
+    		 	aThread.Open(gEpocEnv->iId) &&
+    		  	aThread.ExitType() == EExitPending)
+    			{
+    			aThread.Rendezvous(aStatus);
+    			return ETrue;
+    			}
+    return EFalse;
+	}
+	
+	
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA2/sdlexe.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,809 @@
+//  INCLUDES
+#include <aknapp.h>
+#include <aknappui.h>
+#include <eikdoc.h>
+#include <sdlepocapi.h>
+#include <bautils.h>
+#include <eikstart.h>
+#include <badesca.h>
+#include <bautils.h>
+#include <apgcli.h>
+#include <sdlmain.h>
+#include <eikedwin.h>
+#include <eiklabel.h>
+#include <sdlexe.rsg>
+#include <aknglobalmsgquery.h>
+#include <apgwgnam.h> 
+
+
+
+//  FORWARD DECLARATIONS
+class CApaDocument;
+
+
+//const TUid KSDLUID = { 0xF01F605E };
+
+LOCAL_C void MakeCCmdLineL(const TDesC8& aParam, CDesC8Array& aArray)
+    { 
+    
+    const TChar dq('\"');
+
+    TLex8 lex(aParam);
+    TBool in = EFalse;
+
+    lex.SkipSpaceAndMark();
+
+    while(!lex.Eos())
+        {
+        TPtrC8 ptr;
+        if(in)
+            {
+            const TPtrC8 rem = lex.RemainderFromMark();
+            const TInt pos = rem.Locate(dq);
+            if(pos > 0)
+                {
+                lex.Inc(pos);
+                ptr.Set(lex.MarkedToken());
+                lex.SkipAndMark(1);
+                }
+            else
+                {
+                ptr.Set(rem);
+                }
+            in = EFalse;
+            }
+        else
+            {
+            ptr.Set(lex.NextToken());
+            const TInt pos = ptr.Locate(dq);
+            if(pos == 0)
+                {
+                lex.UnGetToMark();
+                lex.SkipAndMark(1);
+                in = ETrue;
+                continue; // back to in brace
+                }
+            else
+                lex.SkipSpaceAndMark();
+            }
+        
+        aArray.AppendL(ptr);
+
+        }
+    }  
+    
+NONSHARABLE_CLASS(TVirtualCursor) : public MOverlay
+	{
+	public:
+		TVirtualCursor();
+		void Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha);
+		void Move(TInt aX, TInt aY);
+		void MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const;
+		void Toggle();
+		TBool IsOn() const;
+	private:
+    	void Draw(CBitmapContext& aGc, const TRect& aTargetRect, const TSize& aSize);
+	private:
+		TRect iRect;
+		TPoint iInc;
+		TPoint iPos;
+		TBool iIsOn;
+		CFbsBitmap* iCBmp;
+		CFbsBitmap* iAlpha;
+	};
+	
+	
+TVirtualCursor::TVirtualCursor() :  iInc(0, 0), iIsOn(EFalse), iCBmp(NULL)
+	{	
+	}
+	
+const TInt KMaxMove = 10;	
+
+void TVirtualCursor::Move(TInt aX, TInt aY)
+	{
+	if(aX > 0 && iInc.iX > 0)
+			++iInc.iX;
+	else if(aX < 0 && iInc.iX < 0)
+			--iInc.iX;
+	else
+		iInc.iX = aX;
+
+	if(aY > 0 && iInc.iY > 0)
+			++iInc.iY;
+	else if(aY < 0 && iInc.iY < 0)
+			--iInc.iY;
+	else
+			iInc.iY = aY;
+	
+	iInc.iX = Min(KMaxMove, iInc.iX); 
+	
+	iInc.iX = Max(-KMaxMove, iInc.iX);
+	
+	iInc.iY = Min(KMaxMove, iInc.iY);
+	
+	iInc.iY =Max(-KMaxMove, iInc.iY);
+	
+	const TPoint pos = iPos + iInc;
+	if(iRect.Contains(pos))
+		{
+		iPos = pos;
+		}
+	else
+		{
+		iInc = TPoint(0, 0);	
+		}
+	}
+	
+	
+void TVirtualCursor::Toggle()
+	{
+	iIsOn = !iIsOn;
+	}
+	
+	
+TBool TVirtualCursor::IsOn() const
+	{
+	return iIsOn;
+	}
+	
+void TVirtualCursor::Set(const TRect& aRect, CFbsBitmap* aBmp, CFbsBitmap* aAlpha)
+	{
+	iRect = aRect;
+	iCBmp = aBmp;
+	iAlpha = aAlpha;
+	}
+	
+		
+void TVirtualCursor::MakeEvent(TWsEvent& aEvent, const TPoint& aBasePos) const
+	{
+ 	aEvent.SetType(EEventPointer),
+	aEvent.SetTimeNow();
+	TPointerEvent& pointer = *aEvent.Pointer();	
+	pointer.iType = TPointerEvent::EButton1Down;
+	pointer.iPosition = iPos;
+	pointer.iParentPosition = aBasePos;
+	}
+	
+	
+void TVirtualCursor::Draw(CBitmapContext& aGc, const TRect& /*aTargetRect*/, const TSize& /*aSize*/)
+	{
+	if(iIsOn && iCBmp != NULL)
+		{
+		const TRect rect(TPoint(0, 0), iCBmp->SizeInPixels());
+		aGc.AlphaBlendBitmaps(iPos, iCBmp, rect, iAlpha, TPoint(0, 0));
+		}
+	
+	}	
+
+NONSHARABLE_CLASS(TSdlClass)
+	{
+	public:
+		TSdlClass();
+		void SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags);
+		TInt SdlFlags() const;
+		const TMainFunc& Main() const;
+		void SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL);
+		TInt AppFlags() const; 
+		void AppFlags(TInt aFlags); 
+	private:
+		TMainFunc iFunc;
+		TInt iSdlFlags;
+		TInt iExeFlags;
+		MSDLMainObs* iObs;
+	};
+	
+	
+void TSdlClass::AppFlags(TInt aFlags)
+	{
+	iExeFlags |= aFlags;
+	}
+	
+void TSdlClass::SendEvent(TInt aEvent, TInt aParam, CSDL* aSDL)
+	{
+	if(iObs != NULL)
+		iObs->SDLMainEvent(aEvent, aParam, aSDL);
+	}
+	
+TInt TSdlClass::AppFlags() const
+	{
+	return iExeFlags;
+	}
+	
+void TSdlClass::SetMain(const TMainFunc& aFunc, TInt aFlags, MSDLMainObs* aObs, TInt aExeFlags)
+	{	
+	iFunc = aFunc;
+	iSdlFlags = aFlags;
+	iExeFlags = aExeFlags;
+	iObs = aObs;
+	}
+	
+const TMainFunc& TSdlClass::Main() const
+	{
+	return iFunc;
+	}
+	
+ 
+ TInt TSdlClass::SdlFlags() const
+ 	{
+ 	return iSdlFlags;
+ 	}
+ 	
+
+ 	
+TSdlClass::TSdlClass()
+	{
+	Mem::FillZ(this, sizeof(this));
+	}
+ 
+TSdlClass gSDLClass;    
+    
+	     
+////////////////////////////////////////////////////////////////    
+
+NONSHARABLE_CLASS(CSDLApplication) : public CAknApplication
+    {
+    public:
+    	CSDLApplication();
+    private:
+        CApaDocument* CreateDocumentL(); 
+        TFileName ResourceFileName() const;
+        TUid AppDllUid() const; 
+      		void FindMeL();
+     		TUid iUid;
+    };
+    
+NONSHARABLE_CLASS(CSDLDocument)  : public CEikDocument
+    {
+    public:
+        CSDLDocument(CEikApplication& aApp);
+     private:
+     	CEikAppUi* CreateAppUiL();
+     
+     };
+     
+ ////////////////////////////////////////////////////////////////////
+ 
+     
+NONSHARABLE_CLASS(MExitWait)
+ 	{
+ 	public:
+ 		virtual void DoExit(TInt aErr) = 0;
+ 	};   
+ 
+///////////////////////////////////////////////////////////////////////// 
+ 	
+NONSHARABLE_CLASS(CExitWait) : public CActive
+ 	{
+ 	public:
+ 		CExitWait(MExitWait& aWait);
+ 		~CExitWait();
+ 	private:
+ 		void RunL();
+ 		void DoCancel();
+ 	private:
+ 		MExitWait& iWait;
+ 		TRequestStatus* iStatusPtr;
+ 	};
+ 	
+//////////////////////////////////////////////////////////////////////// 
+
+ 	
+NONSHARABLE_CLASS(CSDLWin) : public CCoeControl
+	{
+	public:
+		void ConstructL(const TRect& aRect);
+		RWindow& GetWindow() const;
+		void SetNoDraw();
+	private:
+		void Draw(const TRect& aRect) const;
+	private:
+		TBool iNoDraw;
+	}; 	
+	
+
+////////////////////////////////////////////////////////////////////////////	
+     
+NONSHARABLE_CLASS(CSDLAppUi) : public CAknAppUi, public MExitWait, MSDLObserver
+	{
+	public:
+		~CSDLAppUi();
+   	private: // New functions
+ 		void ConstructL(); 
+   	void HandleCommandL(TInt aCommand);
+ 		void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination);
+ 		void HandleResourceChangeL(TInt aType);
+        
+   		void DoExit(TInt aErr);
+   	
+   		TInt SdlEvent(TInt aEvent, TInt aParam);
+    	TInt SdlThreadEvent(TInt aEvent, TInt aParam);
+    
+    	void StartL();
+    	static TBool StartL(TAny* aThis);
+    	
+    	TBool ParamEditorL(TDes& aCheat);
+    	
+    	TBool ProcessCommandParametersL(CApaCommandLine &aCommandLine);
+    	
+    	void PrepareToExit();
+    	void HandleConsoleWindowL();
+    	void HandleConsoleWindow();
+    	void HandleForegroundEventL(TBool aForeground);
+    	
+    	static TBool IdleRequestL(TAny* aThis);
+    	
+    	TBool HandleKeyL(const TWsEvent& aEvent);
+    
+    	
+	private:
+		CExitWait* iWait;
+		CSDLWin* iSDLWin;
+		CSDL* iSdl;
+		CIdle* iStarter;
+		TBool iExitRequest;
+		CDesC8Array* iParams;
+		TInt iResOffset;
+		CIdle* iIdle;
+		TInt iStdOut;
+		TVirtualCursor iCursor;
+		CFbsBitmap*	iCBmp;
+		CFbsBitmap*	iAlpha;
+	//	TTime iLastPress;
+	//	CSDL::TOrientationMode iOrientation;
+	};
+	
+////////////////////////////////////////////////////////////////////////////////////////7
+
+CApaDocument* CSDLApplication::CreateDocumentL()
+	{
+	return new (ELeave) CSDLDocument(*this);
+	}
+	
+TUid CSDLApplication::AppDllUid() const
+	{
+	return iUid;
+	}
+	
+	
+CSDLApplication::CSDLApplication()
+	{
+	TRAPD(err, FindMeL());
+	ASSERT(err == KErrNone);
+	}	
+	
+void CSDLApplication::FindMeL()
+	{
+	RApaLsSession apa;
+	User::LeaveIfError(apa.Connect());
+	CleanupClosePushL(apa);
+	User::LeaveIfError(apa.GetAllApps());
+	TFileName name = RProcess().FileName();
+	TApaAppInfo info;
+	while(apa.GetNextApp(info) == KErrNone)
+		{
+		if(info.iFullName.CompareF(name) == 0)
+			{
+			iUid = info.iUid;
+			break;
+			}
+		}
+	CleanupStack::PopAndDestroy();
+	}
+	
+TFileName CSDLApplication::ResourceFileName() const
+	{
+	return KNullDesC();
+	}
+	
+///////////////////////////////////////////////////////////////////////////////////////////
+
+CExitWait::CExitWait(MExitWait& aWait) : CActive(CActive::EPriorityStandard), iWait(aWait)
+	{
+	CActiveScheduler::Add(this);
+	SetActive();
+	iStatusPtr = &iStatus;
+	}
+	
+CExitWait::~CExitWait()
+	{
+	Cancel();
+	}
+ 
+void CExitWait::RunL()
+	{
+	if(iStatusPtr != NULL )
+		iWait.DoExit(iStatus.Int());
+	}
+	
+void CExitWait::DoCancel()
+	{
+	if(iStatusPtr != NULL )
+		User::RequestComplete(iStatusPtr , KErrCancel);
+	}
+	
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+CSDLDocument::CSDLDocument(CEikApplication& aApp) : CEikDocument(aApp)
+	{}
+    
+CEikAppUi* CSDLDocument::CreateAppUiL()
+	{
+	return new (ELeave) CSDLAppUi;
+	}
+	
+///////////////////////////////////////////////////////////////////////////	
+	
+void CSDLWin:: ConstructL(const TRect& aRect)	
+	{
+	CreateWindowL();
+	SetRect(aRect);
+	ActivateL();
+	}
+	
+	
+RWindow& CSDLWin::GetWindow() const
+	{
+	return Window();
+	}
+	
+
+void CSDLWin::Draw(const TRect& /*aRect*/) const
+	{
+	if(!iNoDraw)
+		{
+		CWindowGc& gc = SystemGc();
+		gc.SetPenStyle(CGraphicsContext::ESolidPen);
+		gc.SetPenColor(KRgbGray);
+		gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+		gc.SetBrushColor(0xaaaaaa);
+		gc.DrawRect(Rect());
+		}
+	}	
+	
+void CSDLWin::SetNoDraw()
+	{
+	iNoDraw = ETrue;
+	}
+
+/////////////////////////////////////////////////////////////////////////			
+	
+CSDLAppUi::~CSDLAppUi()
+	{
+	if(iIdle)
+		iIdle->Cancel();
+	delete iIdle;
+	if(iStarter != NULL)
+		iStarter->Cancel();
+	delete iStarter;
+	delete iWait;
+	delete iSdl;
+	delete iSDLWin;
+	delete iParams;
+	delete iCBmp;
+	delete iAlpha;
+	}
+	
+		
+void CSDLAppUi::ConstructL()
+ 	{
+ 	BaseConstructL(ENoAppResourceFile | ENoScreenFurniture);
+ 	
+ 	
+ 	RLibrary lib;
+ 	User::LeaveIfError(lib.Load(_L("sdlexe.dll")));
+ 	TFileName name = lib.FileName();
+ 	lib.Close();
+ 	name.Replace(3, name.Length() - 3, _L("resource\\apps\\sdlexe.rsc"));
+ 	BaflUtils::NearestLanguageFile(iEikonEnv->FsSession(), name);
+ 	iResOffset = iCoeEnv->AddResourceFileL(name);
+ 	
+ 	name.Replace(name.Length() - 3, 3, _L("mbm"));
+	
+	TEntry e;
+	const TInt err = iEikonEnv->FsSession().Entry(name, e);
+	
+	iCBmp = iEikonEnv->CreateBitmapL(name, 0);
+	iAlpha = iEikonEnv->CreateBitmapL(name, 1);	
+ 	
+ 	iIdle = CIdle::NewL(CActive::EPriorityIdle);
+ 	
+ 	iSDLWin = new (ELeave) CSDLWin;
+ 	iSDLWin->ConstructL(ApplicationRect());
+ 	
+ 	iSdl = CSDL::NewL(gSDLClass.SdlFlags());
+ 	
+ 	gSDLClass.SendEvent(MSDLMainObs::ESDLCreated, 0, iSdl);
+ 	
+ 	iSdl->SetObserver(this);
+ 	iSdl->DisableKeyBlocking(*this);
+ 	iSdl->SetContainerWindowL(
+ 					iSDLWin->GetWindow(), 
+        			iEikonEnv->WsSession(),
+        			*iEikonEnv->ScreenDevice());
+    iSdl->AppendOverlay(iCursor, 0);
+    
+    iCursor.Set(TRect(TPoint(0, 0), iSDLWin->Size()), iCBmp, iAlpha);
+        			
+    iStarter = CIdle::NewL(CActive::EPriorityLow);   
+    iStarter->Start(TCallBack(StartL, this));
+    
+    
+ 	}
+ 	
+
+
+TBool CSDLAppUi::StartL(TAny* aThis)
+	{
+	static_cast<CSDLAppUi*>(aThis)->StartL();
+	return EFalse;
+	}
+	
+	
+void CSDLAppUi::PrepareToExit()
+	{
+	CAknAppUiBase::PrepareToExit(); //aknappu::PrepareToExit crashes
+	iCoeEnv->DeleteResourceFile(iResOffset);
+	}
+	
+TBool CSDLAppUi::ProcessCommandParametersL(CApaCommandLine &aCommandLine)
+	{
+	const TPtrC8 cmdLine = aCommandLine.TailEnd();
+	iParams = new (ELeave) CDesC8ArrayFlat(8);
+	MakeCCmdLineL(cmdLine, *iParams);
+	return EFalse;
+	}
+ 	
+ 
+ TBool CSDLAppUi::ParamEditorL(TDes& aCheat)
+	{
+	CAknTextQueryDialog* query = CAknTextQueryDialog::NewL(aCheat);
+	CleanupStack::PushL(query);
+	query->SetPromptL(_L("Enter parameters"));
+	CleanupStack::Pop();
+	return query->ExecuteLD(R_PARAMEDITOR);
+	}
+ 	
+ void CSDLAppUi::StartL()	
+ 	{ 		
+ 	if(gSDLClass.AppFlags() & SDLEnv::EParamQuery)
+ 		{
+ 		TBuf8<256> cmd;
+ 		RFile file;
+ 		TInt err = file.Open(iEikonEnv->FsSession(), _L("sdl_param.txt"),EFileRead);
+ 		if(err == KErrNone)
+ 			{
+ 			file.Read(cmd);
+ 			file.Close();	
+ 			MakeCCmdLineL(cmd, *iParams);
+ 			}
+ 		if(err != KErrNone || gSDLClass.AppFlags() & (SDLEnv::EParamQueryDialog ^ SDLEnv::EParamQuery))
+ 			{
+ 			TBuf<256> buffer;
+ 			if(ParamEditorL(buffer))
+ 				{
+ 				cmd.Copy(buffer);
+ 				MakeCCmdLineL(cmd, *iParams);
+ 				}	
+ 			}
+ 		}
+ 	iWait = new (ELeave) CExitWait(*this);
+ 	iSdl->CallMainL(gSDLClass.Main(), &iWait->iStatus, iParams, CSDL::ENoParamFlags, 0xA000);
+ 	}
+ 	
+void CSDLAppUi::HandleCommandL(TInt aCommand)
+	{
+	switch(aCommand)
+		{
+		case EAknSoftkeyBack:
+ 		case EAknSoftkeyExit:
+		case EAknCmdExit:
+		case EEikCmdExit:
+			gSDLClass.AppFlags(SDLEnv::EAllowConsoleView); 
+		    if(iWait == NULL || !iWait->IsActive() || iSdl == NULL)
+		    	{
+		    	Exit();
+		    	}	
+			  else if(!iExitRequest)
+			  	{
+			  	iExitRequest = ETrue; //trick how SDL can be closed!
+			  	iSdl->Suspend();
+			  	} 
+			break;
+		}
+	}
+	
+
+	
+TBool CSDLAppUi::HandleKeyL(const TWsEvent& aEvent)
+	{
+	const TInt type = aEvent.Type();
+	if(!(type == EEventKey || type == EEventKeyUp || type == EEventKeyDown))
+ 			{
+ 			return ETrue;
+ 			}
+ 	const TKeyEvent& key = *aEvent.Key();
+	if((key.iScanCode == EStdKeyYes) && (gSDLClass.AppFlags() & SDLEnv::EVirtualMouse))
+ 		{
+ 		if(type == EEventKeyUp)
+ 			{
+ 			iCursor.Toggle();
+ 			iSdl->RedrawRequest();	
+ 			}
+ 		return EFalse;
+		}
+	if(iCursor.IsOn())
+		{
+		switch(key.iScanCode)
+			{
+			case EStdKeyUpArrow:
+				iCursor.Move(0, -1);
+				break;
+			case EStdKeyDownArrow:
+				iCursor.Move(0, 1);
+				break;
+			case EStdKeyLeftArrow:
+				iCursor.Move(-1, 0);
+				break;
+			case EStdKeyRightArrow:
+				iCursor.Move(1, 0);
+				break; 
+			case EStdKeyDevice3:
+				if(type == EEventKeyUp)
+					{
+					TWsEvent event;
+					iCursor.MakeEvent(event, iSDLWin->Position());
+					iSdl->AppendWsEvent(event);
+					}
+				return EFalse;
+			default:
+				return ETrue;
+			}
+		iSdl->RedrawRequest();	
+		return EFalse;
+		}
+	return ETrue;
+	}
+ 		
+ void CSDLAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
+ 	{
+ 	if(iSdl && iWait && HandleKeyL(aEvent))
+ 		iSdl->AppendWsEvent(aEvent);
+ 	CAknAppUi::HandleWsEventL(aEvent, aDestination);
+ 	}
+ 	
+ void CSDLAppUi::HandleResourceChangeL(TInt aType)
+ 	{
+    CAknAppUi::HandleResourceChangeL(aType);
+    if(aType == KEikDynamicLayoutVariantSwitch)
+        {  	
+        iSDLWin->SetRect(ApplicationRect());
+      	iSdl->SetContainerWindowL(
+      				iSDLWin->GetWindow(),
+        			iEikonEnv->WsSession(),
+        			*iEikonEnv->ScreenDevice());
+        }
+ 	}
+ 	
+ 	
+void CSDLAppUi::DoExit(TInt/*Err*/)
+   	{
+   	iExitRequest = ETrue;
+   	Exit();
+   	}
+
+    
+ TInt CSDLAppUi::SdlThreadEvent(TInt aEvent, TInt /*aParam*/)    
+	{
+	switch(aEvent)
+		{
+		case MSDLObserver::EEventResume:
+			break;
+		case MSDLObserver::EEventSuspend:
+			if(iExitRequest)
+				return MSDLObserver::ESuspendNoSuspend;
+			break;
+		case MSDLObserver::EEventWindowReserved:
+			break;
+		case MSDLObserver::EEventWindowNotAvailable:
+			break;
+		case MSDLObserver::EEventScreenSizeChanged:
+            break;
+		}
+	return MSDLObserver::EParameterNone;	
+	}
+	    
+TInt CSDLAppUi::SdlEvent(TInt aEvent, TInt /*aParam*/)    
+	{
+	switch(aEvent)
+		{
+		case MSDLObserver::EEventResume:
+			break;
+		case MSDLObserver::EEventSuspend:
+			if(iExitRequest)
+				return MSDLObserver::ESuspendNoSuspend;
+			break;
+		case MSDLObserver::EEventWindowReserved:
+			break;
+		case MSDLObserver::EEventWindowNotAvailable:
+			{
+			TRAP_IGNORE(HandleConsoleWindowL());
+			}
+			break;
+		case MSDLObserver::EEventScreenSizeChanged:
+     		break;
+		case MSDLObserver::EEventKeyMapInit:
+			break;
+		case MSDLObserver::EEventMainExit:
+			if(iStdOut != 0)
+				{
+				gSDLClass.AppFlags(SDLEnv::EAllowConsoleView); 
+				iEikonEnv->WsSession().SetWindowGroupOrdinalPosition(iStdOut, 0);
+				}
+			break;
+		}
+	return MSDLObserver::EParameterNone;
+	}
+	
+void CSDLAppUi::HandleForegroundEventL(TBool aForeground)
+	{
+	CAknAppUi::HandleForegroundEventL(aForeground);	
+	if(!aForeground)
+		HandleConsoleWindow();
+	}
+	
+void CSDLAppUi::HandleConsoleWindow()
+	{
+	if(!iIdle->IsActive())
+		iIdle->Start(TCallBack(IdleRequestL, this));
+	}
+	
+TBool CSDLAppUi::IdleRequestL(TAny* aThis)
+	{
+	static_cast<CSDLAppUi*>(aThis)->HandleConsoleWindowL();
+	return EFalse;
+	}
+
+void CSDLAppUi::HandleConsoleWindowL()
+	{
+	if(gSDLClass.AppFlags() & SDLEnv::EAllowConsoleView)
+		{
+		return;
+		}
+	RWsSession& ses = iEikonEnv->WsSession();
+	const TInt focus = ses.GetFocusWindowGroup();
+	CApaWindowGroupName* name = CApaWindowGroupName::NewLC(ses, focus);
+	const TPtrC caption = name->Caption();
+	if(0 == caption.CompareF(_L("STDOUT")))
+		{
+		iStdOut = focus;
+		ses.SetWindowGroupOrdinalPosition(iEikonEnv->RootWin().Identifier(), 0);
+		}
+	CleanupStack::PopAndDestroy(); //name
+	}
+	
+	
+////////////////////////////////////////////////////////////////////////
+
+
+CApaApplication* NewApplication()
+    {
+    return new CSDLApplication();
+    }
+
+	
+EXPORT_C TInt SDLEnv::SetMain(const TMainFunc& aFunc, TInt aSdlFlags, MSDLMainObs* aObs, TInt aSdlExeFlags)
+	{
+	gSDLClass.SetMain(aFunc, aSdlFlags, aObs, aSdlExeFlags);
+  	return EikStart::RunApplication(NewApplication);
+	}	
+	
+//////////////////////////////////////////////////////////////////////
+
+TInt SDLUiPrint(const TDesC8& /*aInfo*/)
+    {
+    return KErrNotFound;
+    }    
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA2/sdllib.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,12 @@
+#include<eikstart.h>
+#include<sdlmain.h>
+#include<sdlepocapi.h>
+
+
+GLREF_C TInt E32Main()
+    {
+    return SDLEnv::SetMain(SDL_main, CSDL::EEnableFocusStop | CSDL::EAllowImageResize,
+     NULL, SDLEnv::EParamQuery | SDLEnv::EVirtualMouse);
+    }
+    
+    
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA2/vectorbuffer.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,62 @@
+/*
+    vectorbuffer.cpp
+    yet another circle buffer
+
+    Markus Mertama
+*/
+
+#include"vectorbuffer.h"
+
+
+
+void VectorPanic(TInt aErr, TInt aLine)
+    {
+    TBuf<64> b;
+    b.Format(_L("vector buffer at % d "), aLine);
+    User::Panic(b, aErr);
+    }
+
+void TNodeBuffer::TNode::Terminator(TNodeBuffer::TNode* aNode)
+    {
+    Mem::Copy(iSucc, &aNode, sizeof(TNode*));
+    }
+
+TInt TNodeBuffer::TNode::Size() const
+    {
+    return reinterpret_cast<const TUint8*>(iSucc) - Ptr();
+    }
+
+const TUint8*  TNodeBuffer::TNode::Ptr() const
+    {
+    return reinterpret_cast<const TUint8*>(this) + sizeof(TNode);
+    }
+
+TNodeBuffer::TNode*  TNodeBuffer::TNode::Empty(TUint8* aBuffer)
+    {
+    TNode* node = reinterpret_cast<TNode*>(aBuffer);
+    node->iSucc = node + 1;
+    return node;
+    }
+
+ TNodeBuffer::TNode*  TNodeBuffer::TNode::New(TNode* aPred, const TDesC8& aData)
+    {
+    TNode* node = aPred->Size() == 0 ? aPred : aPred->iSucc;
+
+    
+    TUint8* start = reinterpret_cast<TUint8*>(node) + sizeof(TNode);
+    node->iSucc = reinterpret_cast<TNode*>(start + aData.Size());
+    node->iSucc->iSucc = NULL; //terminator
+
+    __ASSERT_DEBUG(node->Size() == aData.Size(), VECPANIC(KErrCorrupt));
+
+    Mem::Copy(start, aData.Ptr(), aData.Size());
+    return node;
+    }
+    
+
+
+
+
+
+
+    
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/symbian/EKA2/vectorbuffer.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,240 @@
+/*
+    vectorbuffer.cpp
+    yet another circle buffer
+
+    Markus Mertama
+*/
+
+#ifndef __VECTORBUFFER_H__
+#define __VECTORBUFFER_H__
+
+#include<e32std.h>
+#define VLOG(x)
+#define VECPANIC(x) VectorPanic(x, __LINE__)
+void VectorPanic(TInt, TInt);
+
+
+//int DEBUG_INT;
+
+NONSHARABLE_CLASS(TNodeBuffer)
+    {
+    public:
+    protected:
+        NONSHARABLE_CLASS(TNode)
+            {
+            public:
+                static  TNode* Empty(TUint8* iBuffer);
+                static  TNode* New(TNode* aPrev,  const TDesC8& aData);
+                const TUint8* Ptr() const;
+                TInt Size() const;
+                inline TNode* Succ();
+                static void SetSucc(TNode*& aNode);
+                void Terminator(TNode* aNode);
+            private:
+                TNode* iSucc;
+            };
+    };
+
+inline TNodeBuffer::TNode* TNodeBuffer::TNode::Succ()
+    {
+    return iSucc;
+    }
+
+template <TInt C>
+NONSHARABLE_CLASS(TVectorBuffer) : public TNodeBuffer
+    {
+    public:
+        TVectorBuffer();
+        TInt Append(const TDesC8& aData);
+     //   TInt AppendOverwrite(const TDesC8& aData);
+        TPtrC8 Shift();
+        TPtrC8 operator[](TInt aIndex) const;
+        TInt Size() const;
+    private:
+        TInt GetRoom(TInt aSize) const;
+        TInt Unreserved() const;
+    private:
+        TNode* iTop;
+        TNode* iBottom;
+        TInt iSize;
+        TUint8 iBuffer[C];
+    };
+
+template <TInt C>
+TVectorBuffer<C>::TVectorBuffer() : iSize(0)
+    {
+    Mem::FillZ(iBuffer, C);
+    iTop = TNode::Empty(iBuffer); //these points to buffer
+    iBottom = TNode::Empty(iBuffer);
+    }
+
+template<TInt C >
+TInt TVectorBuffer<C>::Unreserved() const
+    {
+    __ASSERT_DEBUG(iBottom < iBottom->Succ(), VECPANIC(KErrCorrupt));
+    const TInt bytesbetween =
+        reinterpret_cast<const TUint8*>(iBottom->Succ()) -
+        reinterpret_cast<const TUint8*>(iTop);
+    const TInt topsize = sizeof(TNode);
+    if(bytesbetween > 0)            //bytesbetween is room between bottom and top 
+        {                           //therefore free room is subracted from free space 
+                    
+        const TInt room = C - bytesbetween - topsize; 
+        return room;
+        }
+    if(bytesbetween == 0)           
+        {
+        
+        if(Size() > 0)              
+            return 0;               
+        else
+            return C - topsize;
+        }
+    const TInt room = -bytesbetween - topsize; //free is space between pointers
+    return room;                     
+    }
+
+template <TInt C>
+TInt TVectorBuffer<C>::GetRoom(TInt aSize) const
+    {
+    const TInt bytesnew = sizeof(TNode) + aSize;
+    const TInt room = Unreserved() - bytesnew;
+    return room;
+    }
+
+template <TInt C>
+TInt TVectorBuffer<C>::Append(const TDesC8& aData) //ei ole ok!
+    {
+    const TInt len = aData.Length();
+    if(GetRoom(len) < 0)
+        {
+        return KErrOverflow;
+        }
+    if(iBottom->Succ()->Ptr() - iBuffer > (C - (len + TInt(sizeof(TNode)))))
+        {
+        VLOG("rc");
+       // RDebug::Print(_L("vector: append"));
+        TNode* p = TNode::Empty(iBuffer);
+        iBottom->Terminator(p);
+      	iBottom = p;
+      	return Append(aData);
+     //	Append();
+     //	iBottom = TNode::New(p, aData); //just append something into end
+        } 
+    
+    //DEBUG_INT++;
+         
+    iBottom = TNode::New(iBottom, aData);
+
+    iSize += len;
+    return KErrNone;
+    }
+
+/*
+template <TInt C>
+TInt TVectorBuffer<C>::AppendOverwrite(const TDesC8& aData) //ei ole ok!
+    {
+    while(Append(aData) == KErrOverflow)
+        {
+        if(iTop->Succ() == NULL)
+            {
+            return KErrUnderflow;
+            }
+        //Shift(); //data is lost
+        }
+    return KErrNone;
+    }
+*/
+template <TInt C>
+TPtrC8 TVectorBuffer<C>::Shift()
+    {
+    __ASSERT_ALWAYS(iTop->Succ() != NULL, VECPANIC(KErrUnderflow)); //can never pass-by bottom
+    TNode* node = iTop;
+    iTop = iTop->Succ();
+    if(iTop > node)
+        {
+      //  DEBUG_INT--;
+        iSize -= node->Size();
+        return TPtrC8(node->Ptr(), node->Size());
+        }
+    else
+        {
+      //  RDebug::Print(_L("vector: shift"));
+        return Shift(); //this happens when buffer is terminated, and data lies in next 
+        }
+    }
+
+template <TInt C>
+TInt TVectorBuffer<C>::Size() const
+    {
+    return iSize;
+    }
+
+template <TInt C>
+TPtrC8 TVectorBuffer<C>::operator[](TInt aIndex) const
+    {
+    TInt index = 0;
+    TNode* t = iTop->Size() > 0 ? iTop : iTop->Succ(); //eliminate terminator
+    while(index < aIndex)
+        {
+        TNode* nt = t->Succ();
+        if(nt < t)
+            {
+            nt = nt->Succ();
+            }
+        t = nt;
+        if(t->Size() > 0)
+        	index++;
+        __ASSERT_ALWAYS(t->Succ() != NULL, VECPANIC(KErrUnderflow)); //can never pass-by bottom
+        }
+    return t->Ptr();
+    }
+
+
+template <class T, TInt C>
+NONSHARABLE_CLASS(TVector) : public TVectorBuffer<C * sizeof(T)>
+    {
+    public:
+        TVector();
+        TInt Append(const T& aData);
+        const T& Shift();
+        TInt Size() const;
+        const T& operator[](TInt aIndex) const;
+    };
+
+template <class T, TInt C>
+TVector<T, C>::TVector() : TVectorBuffer<C * sizeof(T)>()
+    {
+    }
+
+template <class T, TInt C>
+TInt TVector<T, C>::Append(const T& aData)
+    {
+    const TPckgC<T> data(aData);
+    return TVectorBuffer<C * sizeof(T)>::Append(data);
+    }
+
+template <class T, TInt C>
+const T& TVector<T, C>::Shift()
+    {
+    const TPtrC8 ptr = TVectorBuffer<C * sizeof(T)>::Shift();
+    return *(reinterpret_cast<const T*>(ptr.Ptr()));
+    }
+
+
+template <class T, TInt C>
+TInt TVector<T, C>::Size() const
+    {
+    return TVectorBuffer<C * sizeof(T)>::Size() / sizeof(T);
+    }
+
+template <class T, TInt C>
+const T& TVector<T, C>::operator[](TInt aIndex) const
+    {
+    const TPtrC8 ptr = TVectorBuffer<C * sizeof(T)>::operator[](aIndex);
+    return *(reinterpret_cast<const T*>(ptr.Ptr()));
+    }
+
+#endif
+
+
--- a/src/stdlib/SDL_getenv.c	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/stdlib/SDL_getenv.c	Sun Jun 24 18:26:35 2007 +0000
@@ -25,7 +25,7 @@
 
 #ifndef HAVE_GETENV
 
-#if defined(__WIN32__) && !defined(_WIN32_WCE)
+#if defined(__WIN32__) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
--- a/src/thread/SDL_thread_c.h	Thu Jun 21 18:48:13 2007 +0000
+++ b/src/thread/SDL_thread_c.h	Sun Jun 24 18:26:35 2007 +0000
@@ -31,8 +31,6 @@
 #include "beos/SDL_systhread_c.h"
 #elif SDL_THREAD_DC
 #include "dc/SDL_systhread_c.h"
-#elif SDL_THREAD_EPOC
-#include "epoc/SDL_systhread_c.h"
 #elif SDL_THREAD_OS2
 #include "os2/SDL_systhread_c.h"
 #elif SDL_THREAD_PTH
@@ -43,6 +41,8 @@
 #include "irix/SDL_systhread_c.h"
 #elif SDL_THREAD_WIN32
 #include "win32/SDL_systhread_c.h"
+#elif SDL_THREAD_SYMBIAN
+#include "symbian/SDL_systhread_c.h"
 #else
 #error Need thread implementation for this platform
 #include "generic/SDL_systhread_c.h"
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/symbian/SDL_sysmutex.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,130 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_sysmutex.cpp
+
+    Epoc version by Markus Mertama (w@iki.fi)
+*/
+
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id: SDL_sysmutex.c,v 1.1.2.3 2000/06/22 15:25:23 hercules Exp $";
+#endif
+
+/* Mutex functions using the Win32 API */
+
+//#include <stdio.h>
+//#include <stdlib.h>
+
+#include <e32std.h>
+
+#include "epoc_sdl.h"
+
+#include "SDL_error.h"
+#include "SDL_mutex.h"
+
+
+#ifdef EKA2 //???
+struct SDL_mutex
+    {
+    TInt handle;
+    };
+#else
+struct _SDL_mutex
+    {
+    TInt handle;
+    };
+#endif
+
+extern TInt CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny*, TAny*);
+
+TInt NewMutex(const TDesC& aName, TAny* aPtr1, TAny*)
+    {
+    return ((RMutex*)aPtr1)->CreateGlobal(aName);
+    }
+    
+void DeleteMutex(TAny* aMutex)
+    {
+    SDL_DestroyMutex ((SDL_mutex*) aMutex);
+    }
+
+/* Create a mutex */
+SDL_mutex *SDL_CreateMutex(void)
+{
+    RMutex rmutex;
+
+    TInt status = CreateUnique(NewMutex, &rmutex, NULL);
+	if(status != KErrNone)
+	    {
+			SDL_SetError("Couldn't create mutex");
+		}
+    SDL_mutex* mutex = new /*(ELeave)*/ SDL_mutex;
+    mutex->handle = rmutex.Handle();
+    EpocSdlEnv::AppendCleanupItem(TSdlCleanupItem(DeleteMutex, mutex));
+	return(mutex);
+}
+
+/* Free the mutex */
+void SDL_DestroyMutex(SDL_mutex *mutex)
+{
+	if ( mutex ) 
+	{
+    RMutex rmutex;
+    rmutex.SetHandle(mutex->handle);
+    if(rmutex.IsHeld())
+        {
+	    rmutex.Signal();
+        }
+	rmutex.Close();
+	EpocSdlEnv::RemoveCleanupItem(mutex);
+	delete(mutex);
+    mutex = NULL;
+	}
+}
+
+/* Lock the mutex */
+int SDL_mutexP(SDL_mutex *mutex)
+{
+	if ( mutex == NULL ) {
+		SDL_SetError("Passed a NULL mutex");
+		return -1;
+	}
+    RMutex rmutex;
+    rmutex.SetHandle(mutex->handle);
+	rmutex.Wait(); 
+	return(0);
+}
+
+/* Unlock the mutex */
+int SDL_mutexV(SDL_mutex *mutex)
+{
+	if ( mutex == NULL ) {
+		SDL_SetError("Passed a NULL mutex");
+		return -1;
+	}
+	RMutex rmutex;
+    rmutex.SetHandle(mutex->handle);
+	rmutex.Signal();
+	return(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/symbian/SDL_syssem.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,214 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_syssem.cpp
+
+    Epoc version by Markus Mertama  (w@iki.fi)
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id: SDL_syssem.c,v 1.1.2.4 2000/06/22 15:24:48 hercules Exp $";
+#endif
+
+/* Semaphore functions using the Win32 API */
+
+//#include <stdio.h>
+//#include <stdlib.h>
+#include <e32std.h>
+
+#include "SDL_error.h"
+#include "SDL_thread.h"
+
+
+#define SDL_MUTEX_TIMEOUT -2
+
+struct SDL_semaphore
+ {
+ TInt handle;
+ TInt count;
+ };
+
+
+extern TInt CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny*, TAny*);
+#ifndef EKA2
+extern TInt NewThread(const TDesC& aName, TAny* aPtr1, TAny* aPtr2);
+#endif
+
+TInt NewSema(const TDesC& aName, TAny* aPtr1, TAny* aPtr2) 
+    {
+    TInt value = *((TInt*) aPtr2);
+    return ((RSemaphore*)aPtr1)->CreateGlobal(aName, value);
+    }
+
+/* Create a semaphore */
+SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
+{
+   RSemaphore s;
+   TInt status = CreateUnique(NewSema, &s, &initial_value);
+   if(status != KErrNone)
+	 {
+			SDL_SetError("Couldn't create semaphore");
+	}
+    SDL_semaphore* sem = new /*(ELeave)*/ SDL_semaphore;  
+    sem->handle = s.Handle();
+	sem->count = initial_value;
+	return(sem);
+}
+
+/* Free the semaphore */
+void SDL_DestroySemaphore(SDL_sem *sem)
+{
+	if ( sem ) 
+	{
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+	while(--sem->count)
+	    sema.Signal();
+    sema.Close();
+    delete sem;
+	sem = NULL;
+	}
+}
+
+#ifndef EKA2
+
+  struct TInfo
+    {
+        TInfo(TInt aTime, TInt aHandle) : 
+        iTime(aTime), iHandle(aHandle), iVal(0) {}
+        TInt iTime;
+        TInt iHandle;
+        TInt iVal; 
+    };
+
+
+
+TBool ThreadRun(TAny* aInfo)
+    {
+        TInfo* info = STATIC_CAST(TInfo*, aInfo);
+        User::After(info->iTime);
+        RSemaphore sema;
+        sema.SetHandle(info->iHandle);
+        sema.Signal();
+        info->iVal = SDL_MUTEX_TIMEOUT;
+        return 0;
+    }
+    
+#endif 
+    
+    
+void _WaitAll(SDL_sem *sem)
+    {
+       //since SemTryWait may changed the counter.
+       //this may not be atomic, but hopes it works.
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+    sema.Wait();
+    while(sem->count < 0)
+        {
+        sema.Wait();
+        }    
+    }
+
+int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
+{
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL sem");
+		return -1;
+	}
+
+	if ( timeout == SDL_MUTEX_MAXWAIT )
+	    {
+	    _WaitAll(sem);
+		return SDL_MUTEX_MAXWAIT;
+	    } 
+	
+#ifdef EKA2
+
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+    if(KErrNone == sema.Wait(timeout))
+    	return 0;
+    return -1;
+#else
+	RThread thread;
+	
+	TInfo* info = new (ELeave)TInfo(timeout, sem->handle);
+	
+    TInt status = CreateUnique(NewThread, &thread, info);
+  
+	if(status != KErrNone)
+	    return status;
+	
+	thread.Resume();
+	
+	_WaitAll(sem);
+	
+	if(thread.ExitType() == EExitPending)
+	    {
+	        thread.Kill(SDL_MUTEX_TIMEOUT);
+	    }
+	
+	thread.Close();
+	
+	return info->iVal;
+#endif
+}
+
+int SDL_SemTryWait(SDL_sem *sem)
+{
+    if(sem->count > 0)
+        {
+        sem->count--;
+        }
+    return SDL_MUTEX_TIMEOUT;
+}
+
+int SDL_SemWait(SDL_sem *sem) 
+{
+	return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+}
+
+/* Returns the current count of the semaphore */
+Uint32 SDL_SemValue(SDL_sem *sem)
+{
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL sem");
+		return 0;
+	}
+	return sem->count;
+}
+
+int SDL_SemPost(SDL_sem *sem)
+{
+	if ( ! sem ) {
+		SDL_SetError("Passed a NULL sem");
+		return -1;
+	}
+	sem->count++;
+    RSemaphore sema;
+    sema.SetHandle(sem->handle);
+	sema.Signal();
+	return 0;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/symbian/SDL_systhread.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,146 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_systhread.cpp
+    Epoc thread management routines for SDL
+
+    Epoc version by Markus Mertama  (w@iki.fi)
+*/
+
+#include "epoc_sdl.h"
+
+//#include <stdlib.h>
+//#include <stdio.h>
+
+
+
+extern "C" {
+#undef NULL
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "SDL_systhread.h"
+#include "SDL_thread_c.h"
+    }
+
+#include <e32std.h>
+#include "epoc_sdl.h"
+
+
+static int object_count;
+
+int RunThread(TAny* data)
+{
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	TRAPD(err, SDL_RunThread(data));
+	EpocSdlEnv::CleanupItems();
+	delete cleanup;
+	return(err);
+}
+
+
+TInt NewThread(const TDesC& aName, TAny* aPtr1, TAny* aPtr2)
+    {
+    return ((RThread*)(aPtr1))->Create(aName,
+            RunThread,
+            KDefaultStackSize,
+            NULL,
+            aPtr2);
+    }
+
+int CreateUnique(TInt (*aFunc)(const TDesC& aName, TAny*, TAny*), TAny* aPtr1, TAny* aPtr2)
+    {
+    TBuf<16> name;
+    TInt status = KErrNone;
+    do
+        {
+        object_count++;
+        name.Format(_L("SDL_%x"), object_count);
+        status = aFunc(name, aPtr1, aPtr2);
+        }
+        while(status == KErrAlreadyExists);
+    return status;
+    }
+
+
+int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
+{
+    RThread rthread;
+   
+    const TInt status = CreateUnique(NewThread, &rthread, args);
+    if (status != KErrNone) 
+    {
+        delete(((RThread*)(thread->handle)));
+        thread->handle = NULL;
+		SDL_SetError("Not enough resources to create thread");
+		return(-1);
+	}
+	rthread.Resume();
+    thread->handle = rthread.Handle();
+	return(0);
+}
+
+void SDL_SYS_SetupThread(void)
+{
+	return;
+}
+
+Uint32 SDL_ThreadID(void)
+{
+    RThread current;
+    const TThreadId id = current.Id();
+	return id;
+}
+
+void SDL_SYS_WaitThread(SDL_Thread *thread)
+{
+    SDL_TRACE1("Close thread", thread);
+    RThread t;
+    const TInt err = t.Open(thread->threadid);
+    if(err == KErrNone && t.ExitType() == EExitPending)
+        {
+        TRequestStatus status;
+        t.Logon(status);
+        User::WaitForRequest(status);
+        }
+    t.Close();
+    
+  /*  RUndertaker taker;
+    taker.Create();
+    TRequestStatus status;
+    taker.Logon(status, thread->handle);
+    User::WaitForRequest(status);
+    taker.Close();*/
+    SDL_TRACE1("Closed thread", thread);
+}
+
+/* WARNING: This function is really a last resort.
+ * Threads should be signaled and then exit by themselves.
+ * TerminateThread() doesn't perform stack and DLL cleanup.
+ */
+void SDL_SYS_KillThread(SDL_Thread *thread)
+{
+    RThread rthread;
+    rthread.SetHandle(thread->handle);
+	rthread.Kill(0);
+	rthread.Close();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/thread/symbian/SDL_systhread_c.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,30 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_systhread_c.h
+
+    Epoc version by Markus Mertama (w@iki.fi)
+*/
+
+typedef int SYS_ThreadHandle;
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/timer/symbian/SDL_systimer.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,114 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_systimer.cpp
+
+    Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi) 
+    Markus Mertama
+*/
+
+#include <e32std.h>
+#include <e32hal.h>
+
+extern "C" {
+#include "SDL_error.h"
+#include "SDL_thread.h"
+#include "SDL_timer.h"
+#include "SDL_timer_c.h"
+
+static TUint start = 0;
+static TInt tickPeriodMilliSeconds;
+
+
+void SDL_StartTicks(void)
+	{
+	/* Set first ticks value */
+    start = User::TickCount();
+
+    TTimeIntervalMicroSeconds32 period;
+	TInt tmp = UserHal::TickPeriod(period);
+    tickPeriodMilliSeconds = period.Int() / 1000;
+	}
+
+Uint32 SDL_GetTicks(void)
+	{
+    TUint deltaTics = User::TickCount() - start;
+	return(deltaTics * tickPeriodMilliSeconds); 
+	}
+
+void SDL_Delay(Uint32 ms)
+	{     
+    User::After(TTimeIntervalMicroSeconds32(ms*1000));
+	}
+
+/* Data to handle a single periodic alarm */
+static int timer_alive = 0;
+static SDL_Thread *timer = NULL;
+
+static int RunTimer(void *unused)
+	{
+	while ( timer_alive )
+		{
+		if (SDL_timer_running)
+			{
+			SDL_ThreadedTimerCheck();
+			}
+		SDL_Delay(10);
+		}
+	return(0);
+	}
+
+/* This is only called if the event thread is not running */
+int SDL_SYS_TimerInit(void)
+	{
+	if(timer != NULL)
+		return (-1);
+	timer_alive = 1;
+	timer = SDL_CreateThread(RunTimer, NULL);
+	if ( timer == NULL )
+		return(-1);
+	return(SDL_SetTimerThreaded(1));
+	}
+
+void SDL_SYS_TimerQuit(void)
+	{
+	timer_alive = 0;
+	if ( timer ) 
+		{
+		SDL_WaitThread(timer, NULL);
+		timer = NULL;
+		}
+	}
+
+int SDL_SYS_StartTimer(void)
+	{
+	SDL_SetError("Internal logic error: Epoc uses threaded timer");
+	return(-1);
+	}
+
+void SDL_SYS_StopTimer(void)
+	{
+	return;
+	}
+
+} // extern "C"
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA1/SDL_epocevents.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,626 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_epocevents.cpp
+    Handle the event stream, converting Epoc events into SDL events
+
+    Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi)
+*/
+
+
+#include <stdio.h>
+#undef NULL
+extern "C" {
+//#define DEBUG_TRACE_ENABLED
+#include "SDL_error.h"
+#include "SDL_video.h"
+#include "SDL_keysym.h"
+#include "SDL_keyboard.h"
+#include "SDL_events_c.h"
+#include "SDL_timer.h"
+}; /* extern "C" */
+
+#include "SDL_epocvideo.h"
+#include "SDL_epocevents_c.h"
+
+#include<linereader.h>
+#include<bautils.h>
+
+
+#include <hal.h>
+
+extern "C" {
+/* The translation tables from a console scancode to a SDL keysym */
+static SDLKey keymap[MAX_SCANCODE];
+static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
+void DisableKeyBlocking(_THIS);
+}; /* extern "C" */
+
+TBool isCursorVisible = EFalse;
+
+int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
+{
+    int posted = 0;
+    SDL_keysym keysym;
+    
+//    SDL_TRACE1("hws %d", aWsEvent.Type());
+
+    switch (aWsEvent.Type())
+		{    
+    case EEventPointer: /* Mouse pointer events */
+		{
+
+        const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();
+
+        if(mode == EPointerCursorNone) 
+            {
+            return 0; //TODO: Find out why events are get despite of cursor should be off
+            }
+
+        const TPointerEvent* pointerEvent = aWsEvent.Pointer();
+        TPoint mousePos = pointerEvent->iPosition;
+
+        /*!! TODO Pointer do not yet work properly
+        //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!!
+
+        if (Private->EPOC_ShrinkedHeight) {
+            mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height
+        }
+        if (Private->EPOC_ShrinkedWidth) {
+            mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width
+        }
+        */
+
+		posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */
+
+		switch (pointerEvent->iType)
+			{
+        case TPointerEvent::EButton1Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
+			break;
+        case TPointerEvent::EButton1Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
+			break;
+        case TPointerEvent::EButton2Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);
+			break;
+		case TPointerEvent::EButton2Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);
+			break;
+        case TPointerEvent::EButton3Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);
+			break;
+        case TPointerEvent::EButton3Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);
+			break;
+			} // switch
+        break;
+	    }
+    
+    case EEventKeyDown: /* Key events */
+    {
+#ifdef SYMBIAN_CRYSTAL
+		// special case: 9300/9500 rocker down, simulate left mouse button
+		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
+			{
+            const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();
+            if(mode != EPointerCursorNone) 
+                posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
+			}
+#endif
+       (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);
+            
+#ifndef DISABLE_JOYSTICK
+        /* Special handling */
+        switch((int)keysym.sym) {
+        case SDLK_CAPSLOCK:
+            if (!isCursorVisible) {
+                /* Enable virtual cursor */
+	            HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
+            }
+            else {
+                /* Disable virtual cursor */
+                HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
+            }
+            isCursorVisible = !isCursorVisible;
+            break;
+        }
+#endif        
+	    posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+        break;
+	} 
+
+    case EEventKeyUp: /* Key events */
+		{
+#ifdef SYMBIAN_CRYSTAL
+		// special case: 9300/9500 rocker up, simulate left mouse button
+		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
+			{
+            posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
+			}
+#endif
+	    posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
+        break;
+		}
+    
+    case EEventFocusGained: /* SDL window got focus */
+	    {
+        Private->EPOC_IsWindowFocused = ETrue;
+		posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
+        /* Draw window background and screen buffer */
+        DisableKeyBlocking(_this);  //Markus: guess why:-)
+ 
+        RedrawWindowL(_this);  
+        break;
+	    }
+
+    case EEventFocusLost: /* SDL window lost focus */
+		{
+/*        
+        CFbsBitmap* bmp = new (ELeave) CFbsBitmap();
+        bmp->Create(Private->EPOC_ScreenSize, Private->EPOC_DisplayMode);
+        Private->EPOC_WsScreen->CopyScreenToBitmap(bmp);
+        Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow);
+        Private->EPOC_WsWindow.BeginRedraw(TRect(Private->EPOC_WsWindow.Size()));
+	    Private->EPOC_WindowGc->BitBlt(TPoint(0, 0), bmp);
+	    Private->EPOC_WsWindow.EndRedraw();
+	    Private->EPOC_WindowGc->Deactivate();
+        bmp->Save(_L("C:\\scr.mbm"));
+        delete bmp;
+*/       
+
+		Private->EPOC_IsWindowFocused = EFalse;
+
+		posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
+
+        RWsSession s;
+        s.Connect();
+        RWindowGroup g(s);
+        g.Construct(TUint32(&g), EFalse);
+        g.EnableReceiptOfFocus(EFalse);
+        RWindow w(s);
+        w.Construct(g, TUint32(&w));
+        w.SetExtent(TPoint(0, 0), Private->EPOC_WsWindow.Size());
+        w.SetOrdinalPosition(0);
+        w.Activate();
+        w.Close();
+        g.Close();
+        s.Close();
+
+/*
+        Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(Private->EPOC_WsWindowGroupID, -1);
+
+            
+        SDL_Delay(500);
+        TInt focus = -1;
+        while(focus < 0)
+            {
+            const TInt curr = Private->EPOC_WsSession.GetFocusWindowGroup();
+            if(curr != Private->EPOC_WsWindowGroupID)
+                focus = curr;
+            else
+                SDL_Delay(500);
+            }
+
+        if(1 < Private->EPOC_WsSession.GetWindowGroupOrdinalPriority(Private->EPOC_WsWindowGroupID))
+            {
+            Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, -1);
+            SDL_Delay(500);
+            Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, 0);
+            }
+*/
+        /*//and the request redraw
+        TRawEvent redrawEvent;
+        redrawEvent.Set(TRawEvent::ERedraw);
+        Private->EPOC_WsSession.SimulateRawEvent(redrawEvent);
+        Private->EPOC_WsSession.Flush();*/
+#if 0
+        //!! Not used
+        // Wait and eat events until focus is gained again
+	    while (ETrue) {
+            Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
+            User::WaitForRequest(Private->EPOC_WsEventStatus);
+		    Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);
+            TInt eventType = Private->EPOC_WsEvent.Type();
+		    Private->EPOC_WsEventStatus = KRequestPending;
+		    //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
+            if (eventType == EEventFocusGained) {
+                RedrawWindowL(_this);
+                break;
+            }
+	    }
+#endif
+        break;
+	    }
+
+    case EEventModifiersChanged: 
+    {
+	    TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
+        TUint modstate = KMOD_NONE;
+        if (modEvent->iModifiers == EModifierLeftShift)
+            modstate |= KMOD_LSHIFT;
+        if (modEvent->iModifiers == EModifierRightShift)
+            modstate |= KMOD_RSHIFT;
+        if (modEvent->iModifiers == EModifierLeftCtrl)
+            modstate |= KMOD_LCTRL;
+        if (modEvent->iModifiers == EModifierRightCtrl)
+            modstate |= KMOD_RCTRL;
+        if (modEvent->iModifiers == EModifierLeftAlt)
+            modstate |= KMOD_LALT;
+        if (modEvent->iModifiers == EModifierRightAlt)
+            modstate |= KMOD_RALT;
+        if (modEvent->iModifiers == EModifierLeftFunc)
+            modstate |= KMOD_LMETA;
+        if (modEvent->iModifiers == EModifierRightFunc)
+            modstate |= KMOD_RMETA;
+        if (modEvent->iModifiers == EModifierCapsLock)
+            modstate |= KMOD_CAPS;
+        SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
+        break;
+    }
+    default:            
+        break;
+	} 
+	
+    return posted;
+}
+
+extern "C" {
+
+void EPOC_PumpEvents(_THIS)
+{
+    int posted = 0; // !! Do we need this?
+    //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
+	while (Private->EPOC_WsEventStatus != KRequestPending) {
+
+		Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);
+		posted = EPOC_HandleWsEvent(_this, Private->EPOC_WsEvent);
+		Private->EPOC_WsEventStatus = KRequestPending;
+		Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
+	}
+}
+
+
+_LIT(KMapFileName, "C:\\sdl_info\\sdlkeymap.cfg");
+LOCAL_C void ReadL(RFs& aFs, RArray<TInt>& aArray)
+    {
+    TInt drive = -1;
+    TFileName name(KMapFileName);
+    for(TInt i = 'z'; drive < 0 && i >= 'a'; i--)
+        {
+        name[0] = (TUint16)i;
+        if(BaflUtils::FileExists(aFs, name))
+            drive = i;
+        }
+    if(drive < 0)
+        return;
+    CLineReader* reader = CLineReader::NewLC(aFs, name);
+    while(reader->NextL())
+        {
+        TPtrC ln = reader->Current();
+        TLex line(ln);
+        TInt n = 0;
+        for(;;)
+            {
+            const TPtrC token = line.NextToken();
+            if(token.Length() == 0)
+                break;
+            if((n & 1) != 0)
+                {
+                TInt value;
+                TLex lex(token);
+                User::LeaveIfError(lex.Val(value));
+                User::LeaveIfError(aArray.Append(value));
+                }
+            n++;
+            }
+        }
+    CleanupStack::PopAndDestroy();
+    }
+
+
+void EPOC_InitOSKeymap(_THIS)
+{
+	int i;
+
+	/* Initialize the key translation table */
+	for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
+		keymap[i] = SDLK_UNKNOWN;
+
+
+	/* Numbers */
+	for ( i = 0; i<32; ++i ){
+		keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
+	}
+	/* e.g. Alphabet keys */
+	for ( i = 0; i<32; ++i ){
+		keymap['A' + i] = (SDLKey)(SDLK_a+i);
+	}
+
+	keymap[EStdKeyBackspace]    = SDLK_BACKSPACE;
+	keymap[EStdKeyTab]          = SDLK_TAB;
+	keymap[EStdKeyEnter]        = SDLK_RETURN;
+	keymap[EStdKeyEscape]       = SDLK_ESCAPE;
+   	keymap[EStdKeySpace]        = SDLK_SPACE;
+   	keymap[EStdKeyPause]        = SDLK_PAUSE;
+   	keymap[EStdKeyHome]         = SDLK_HOME;
+   	keymap[EStdKeyEnd]          = SDLK_END;
+   	keymap[EStdKeyPageUp]       = SDLK_PAGEUP;
+   	keymap[EStdKeyPageDown]     = SDLK_PAGEDOWN;
+	keymap[EStdKeyDelete]       = SDLK_DELETE;
+	keymap[EStdKeyUpArrow]      = SDLK_UP;
+	keymap[EStdKeyDownArrow]    = SDLK_DOWN;
+	keymap[EStdKeyLeftArrow]    = SDLK_LEFT;
+	keymap[EStdKeyRightArrow]   = SDLK_RIGHT;
+	keymap[EStdKeyCapsLock]     = SDLK_CAPSLOCK;
+	keymap[EStdKeyLeftShift]    = SDLK_LSHIFT;
+	keymap[EStdKeyRightShift]   = SDLK_RSHIFT;
+	keymap[EStdKeyLeftAlt]      = SDLK_LALT;
+	keymap[EStdKeyRightAlt]     = SDLK_RALT;
+	keymap[EStdKeyLeftCtrl]     = SDLK_LCTRL;
+	keymap[EStdKeyRightCtrl]    = SDLK_RCTRL;
+	keymap[EStdKeyLeftFunc]     = SDLK_LMETA;
+	keymap[EStdKeyRightFunc]    = SDLK_RMETA;
+	keymap[EStdKeyInsert]       = SDLK_INSERT;
+	keymap[EStdKeyComma]        = SDLK_COMMA;
+	keymap[EStdKeyFullStop]     = SDLK_PERIOD;
+	keymap[EStdKeyForwardSlash] = SDLK_SLASH;
+	keymap[EStdKeyBackSlash]    = SDLK_BACKSLASH;
+	keymap[EStdKeySemiColon]    = SDLK_SEMICOLON;
+	keymap[EStdKeySingleQuote]  = SDLK_QUOTE;
+	keymap[EStdKeyHash]         = SDLK_HASH;
+	keymap[EStdKeySquareBracketLeft]    = SDLK_LEFTBRACKET;
+	keymap[EStdKeySquareBracketRight]   = SDLK_RIGHTBRACKET;
+	keymap[EStdKeyMinus]        = SDLK_MINUS;
+	keymap[EStdKeyEquals]       = SDLK_EQUALS;
+
+   	keymap[EStdKeyF1]          = SDLK_F1;  /* chr + q */
+   	keymap[EStdKeyF2]          = SDLK_F2;  /* chr + w */
+   	keymap[EStdKeyF3]          = SDLK_F3;  /* chr + e */
+   	keymap[EStdKeyF4]          = SDLK_F4;  /* chr + r */
+   	keymap[EStdKeyF5]          = SDLK_F5;  /* chr + t */
+   	keymap[EStdKeyF6]          = SDLK_F6;  /* chr + y */
+   	keymap[EStdKeyF7]          = SDLK_F7;  /* chr + i */
+   	keymap[EStdKeyF8]          = SDLK_F8;  /* chr + o */
+
+   	keymap[EStdKeyF9]          = SDLK_F9;  /* chr + a */
+   	keymap[EStdKeyF10]         = SDLK_F10; /* chr + s */
+   	keymap[EStdKeyF11]         = SDLK_F11; /* chr + d */
+   	keymap[EStdKeyF12]         = SDLK_F12; /* chr + f */
+
+	#ifndef SYMBIAN_CRYSTAL 
+	//!!7650 additions
+    #ifdef __WINS__
+   	keymap[EStdKeyXXX]         = SDLK_RETURN;	/* "fire" key */
+	#else
+   	keymap[EStdKeyDevice3]     = SDLK_RETURN;	/* "fire" key */
+	#endif
+   	keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK; 
+   	keymap[EStdKeyYes]         = SDLK_HOME;		/* "call" key */
+   	keymap[EStdKeyNo]		   = SDLK_END;		/* "end call" key */
+   	keymap[EStdKeyDevice0]     = SDLK_SPACE;	/* right menu key */
+   	keymap[EStdKeyDevice1]     = SDLK_ESCAPE;	/* left menu key */
+   	keymap[EStdKeyDevice2]     = SDLK_POWER;	/* power key */
+	#endif
+
+ #ifdef SYMBIAN_CRYSTAL 
+    keymap[EStdKeyMenu]        = SDLK_ESCAPE;   // menu key
+    keymap[EStdKeyDevice6]     = SDLK_LEFT;     // Rocker (joystick) left
+    keymap[EStdKeyDevice7]     = SDLK_RIGHT;    // Rocker (joystick) right
+    keymap[EStdKeyDevice8]     = SDLK_UP;       // Rocker (joystick) up
+    keymap[EStdKeyDevice9]     = SDLK_DOWN;     // Rocker (joystick) down
+    keymap[EStdKeyLeftFunc]     = SDLK_LALT;    //chr?
+	keymap[EStdKeyRightFunc]    = SDLK_RALT;
+    keymap[EStdKeyDeviceA]      = SDLK_RETURN;	/* "fire" key */
+#endif
+
+    ///////////////////////////////////////////////////////////
+
+    RFs fs;
+    if(KErrNone == fs.Connect())
+        {
+        RArray<TInt> array;
+        TRAPD(err, ReadL(fs, array));
+        if(err == KErrNone && array.Count() > 0)
+            {
+            
+            SDLKey temp[MAX_SCANCODE];
+            Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
+
+            for(TInt k = 0; k < array.Count(); k+= 2)
+                {
+                const TInt oldval = array[k]; 
+                const TInt newval = array[k + 1]; 
+                if(oldval >=  0 && oldval < MAX_SCANCODE && newval >=  0 && newval < MAX_SCANCODE)
+                    {
+                    keymap[oldval] = temp[newval];
+                    }
+                }
+            }
+        array.Close();
+        }
+
+    fs.Close();
+    ///////////////////////////////////////////////////////////
+
+    /* !!TODO
+	EStdKeyNumLock=0x1b,
+	EStdKeyScrollLock=0x1c,
+
+	EStdKeyNkpForwardSlash=0x84,
+	EStdKeyNkpAsterisk=0x85,
+	EStdKeyNkpMinus=0x86,
+	EStdKeyNkpPlus=0x87,
+	EStdKeyNkpEnter=0x88,
+	EStdKeyNkp1=0x89,
+	EStdKeyNkp2=0x8a,
+	EStdKeyNkp3=0x8b,
+	EStdKeyNkp4=0x8c,
+	EStdKeyNkp5=0x8d,
+	EStdKeyNkp6=0x8e,
+	EStdKeyNkp7=0x8f,
+	EStdKeyNkp8=0x90,
+	EStdKeyNkp9=0x91,
+	EStdKeyNkp0=0x92,
+	EStdKeyNkpFullStop=0x93,
+    EStdKeyMenu=0x94,
+    EStdKeyBacklightOn=0x95,
+    EStdKeyBacklightOff=0x96,
+    EStdKeyBacklightToggle=0x97,
+    EStdKeyIncContrast=0x98,
+    EStdKeyDecContrast=0x99,
+    EStdKeySliderDown=0x9a,
+    EStdKeySliderUp=0x9b,
+    EStdKeyDictaphonePlay=0x9c,
+    EStdKeyDictaphoneStop=0x9d,
+    EStdKeyDictaphoneRecord=0x9e,
+    EStdKeyHelp=0x9f,
+    EStdKeyOff=0xa0,
+    EStdKeyDial=0xa1,
+    EStdKeyIncVolume=0xa2,
+    EStdKeyDecVolume=0xa3,
+    EStdKeyDevice0=0xa4,
+    EStdKeyDevice1=0xa5,
+    EStdKeyDevice2=0xa6,
+    EStdKeyDevice3=0xa7,
+    EStdKeyDevice4=0xa8,
+    EStdKeyDevice5=0xa9,
+    EStdKeyDevice6=0xaa,
+    EStdKeyDevice7=0xab,
+    EStdKeyDevice8=0xac,
+    EStdKeyDevice9=0xad,
+    EStdKeyDeviceA=0xae,
+    EStdKeyDeviceB=0xaf,
+    EStdKeyDeviceC=0xb0,
+    EStdKeyDeviceD=0xb1,
+    EStdKeyDeviceE=0xb2,
+    EStdKeyDeviceF=0xb3,
+    EStdKeyApplication0=0xb4,
+    EStdKeyApplication1=0xb5,
+    EStdKeyApplication2=0xb6,
+    EStdKeyApplication3=0xb7,
+    EStdKeyApplication4=0xb8,
+    EStdKeyApplication5=0xb9,
+    EStdKeyApplication6=0xba,
+    EStdKeyApplication7=0xbb,
+    EStdKeyApplication8=0xbc,
+    EStdKeyApplication9=0xbd,
+    EStdKeyApplicationA=0xbe,
+    EStdKeyApplicationB=0xbf,
+    EStdKeyApplicationC=0xc0,
+    EStdKeyApplicationD=0xc1,
+    EStdKeyApplicationE=0xc2,
+    EStdKeyApplicationF=0xc3,
+    EStdKeyYes=0xc4,
+    EStdKeyNo=0xc5,
+    EStdKeyIncBrightness=0xc6,
+    EStdKeyDecBrightness=0xc7, 
+    EStdKeyCaseOpen=0xc8,
+    EStdKeyCaseClose=0xc9
+    */
+
+}
+
+
+
+static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
+{
+//    char debug[256];
+    //SDL_TRACE1("SDL: TranslateKey, scancode=%d", scancode); //!!
+
+	/* Set the keysym information */ 
+
+	keysym->scancode = scancode;
+
+    if ((scancode >= MAX_SCANCODE) && 
+        ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
+        SDL_SetError("Too big scancode");
+        keysym->scancode = SDLK_UNKNOWN;
+	    keysym->mod = KMOD_NONE; 
+        return keysym;
+    }
+
+	keysym->mod = SDL_GetModState();
+
+    /* Handle function keys: F1, F2, F3 ... */
+    if (keysym->mod & KMOD_META) {
+        if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
+            switch(scancode) {
+                case 'Q': scancode = EStdKeyF1; break;
+                case 'W': scancode = EStdKeyF2; break;
+                case 'E': scancode = EStdKeyF3; break;
+                case 'R': scancode = EStdKeyF4; break;
+                case 'T': scancode = EStdKeyF5; break;
+                case 'Y': scancode = EStdKeyF6; break;
+                case 'U': scancode = EStdKeyF7; break;
+                case 'I': scancode = EStdKeyF8; break;
+                case 'A': scancode = EStdKeyF9; break;
+                case 'S': scancode = EStdKeyF10; break;
+                case 'D': scancode = EStdKeyF11; break;
+                case 'F': scancode = EStdKeyF12; break;
+            }
+            keysym->sym = keymap[scancode];
+        }
+    }
+
+    if (scancode >= ENonCharacterKeyBase) {
+        // Non character keys
+	    keysym->sym = keymap[scancode - 
+            ENonCharacterKeyBase + 0x0081]; // !!hard coded
+    } else {
+	    keysym->sym = keymap[scancode];
+    }
+
+	/* Remap the arrow keys if the device is rotated */
+	if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
+		switch(keysym->sym) {
+			case SDLK_UP:	keysym->sym = SDLK_LEFT;  break;
+			case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
+			case SDLK_LEFT: keysym->sym = SDLK_DOWN;  break;
+			case SDLK_RIGHT:keysym->sym = SDLK_UP;    break;
+		}
+	}
+
+	/* If UNICODE is on, get the UNICODE value for the key */
+	keysym->unicode = 0;
+
+#if 0 // !!TODO:unicode
+
+	if ( SDL_TranslateUNICODE ) 
+    {
+		/* Populate the unicode field with the ASCII value */
+		keysym->unicode = scancode;
+	}
+#endif
+
+    //!!
+    //sprintf(debug, "SDL: TranslateKey: keysym->scancode=%d, keysym->sym=%d, keysym->mod=%d",
+    //    keysym->scancode, keysym->sym, keysym->mod);
+    //SDL_TRACE(debug); //!!
+
+	return(keysym);
+}
+
+}; /* extern "C" */
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA1/SDL_epocvideo.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,1356 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_epocvideo.cpp
+    Epoc based SDL video driver implementation
+
+    Thanks to Peter van Sebille, the author of EMame. It is a great example of 
+    low level graphics coding in Epoc.
+
+    Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi)
+	Assembler routines by Kimmo Kinnunen
+*/
+
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+extern "C" {
+#include "SDL_error.h"
+#include "SDL_timer.h"
+#include "SDL_video.h"
+#undef NULL
+#include "SDL_pixels_c.h"
+#include "SDL.h"
+};
+
+#include "SDL_epocvideo.h"
+#include "SDL_epocevents_c.h"
+
+#include "sdl_epocruntime.h"
+
+#include <hal.h>
+#include <coedef.h>
+#include <flogger.h>
+
+#ifdef SYMBIAN_QUARTZ
+SDL_VideoDevice* _thisDevice;
+#endif
+
+_LIT(KLibName, "SDL");
+
+/* For debugging */
+
+//if old SOS, from 7.x this is public!
+class CLockable : public CFbsBitmap
+    {
+    public:
+        static  CLockable* Lockable(CFbsBitmap* aBmp) {return static_cast<CLockable*>(aBmp);}
+        void Lock() {LockHeap();}
+        void Unlock() {UnlockHeap();}
+    };
+#define LockHeap(x) CLockable::Lockable(x)->Lock()
+#define UnlockHeap(x) CLockable::Lockable(x)->Unlock()
+
+void RDebug_Print_b(char* error_str, void* param)
+    {
+    TBuf8<128> error8((TUint8*)error_str);
+    TBuf<128> error;
+    error.Copy(error8);
+
+#ifndef TRACE_TO_FILE
+    if (param) //!! Do not work if the parameter is really 0!!
+        RDebug::Print(error, param);
+    else 
+        RDebug::Print(error);
+#else
+    if (param) //!! Do not work if the parameter is really 0!!
+        RFileLogger::WriteFormat(KLibName, _L("SDL.txt"), EFileLoggingModeAppend, error, param);
+    else 
+        RFileLogger::Write(KLibName, _L("SDL.txt"), EFileLoggingModeAppend, error);
+#endif
+
+    }
+
+extern "C" void RDebug_Print(char* error_str, void* param)
+    {
+    RDebug_Print_b(error_str, param);
+    }
+
+
+int Debug_AvailMem2()
+    {
+    //User::CompressAllHeaps();
+    TMemoryInfoV1Buf membuf; 
+    User::LeaveIfError(UserHal::MemoryInfo(membuf));
+    TMemoryInfoV1 minfo = membuf();
+	return(minfo.iFreeRamInBytes);
+    }
+
+extern "C" int Debug_AvailMem()
+    {
+    return(Debug_AvailMem2());
+    }
+
+
+extern "C" {
+
+/* Initialization/Query functions */
+
+static int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat);
+static SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
+static SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int EPOC_SetColors(_THIS, int firstcolor, int ncolors,
+			  SDL_Color *colors);
+static void EPOC_VideoQuit(_THIS);
+
+/* Hardware surface functions */
+
+static int EPOC_AllocHWSurface(_THIS, SDL_Surface *surface);
+static int EPOC_LockHWSurface(_THIS, SDL_Surface *surface);
+static int EPOC_FlipHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_UnlockHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_FreeHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
+
+static int EPOC_Available(void);
+static SDL_VideoDevice *EPOC_CreateDevice(int devindex);
+
+void DrawBackground(_THIS);
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer);
+void DirectDrawRotated(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer);
+
+/* Mouse functions */
+
+static WMcursor *EPOC_CreateWMCursor(_THIS, Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
+static void EPOC_FreeWMCursor(_THIS, WMcursor *cursor);
+static int EPOC_ShowWMCursor(_THIS, WMcursor *cursor);
+
+
+
+/* !!For 12 bit screen HW. Table for fast conversion from 8 bit to 12 bit */
+// TUint16 is enough, but using TUint32 so we can use better instruction selection on ARMI
+static TUint32 EPOC_HWPalette_256_to_Screen[256];
+
+VideoBootStrap EPOC_bootstrap = {
+	"epoc", "EPOC system",
+    EPOC_Available, EPOC_CreateDevice
+};
+
+const TUint32 WindowClientHandle = 9210; //!! const
+
+/* Epoc video driver bootstrap functions */
+
+static int EPOC_Available(void)
+{
+    return 1; /* Always available */
+}
+
+static void EPOC_DeleteDevice(SDL_VideoDevice *device)
+{
+	free(device->hidden);
+	free(device);
+}
+
+static SDL_VideoDevice *EPOC_CreateDevice(int /*devindex*/)
+{
+	SDL_VideoDevice *device;
+
+	SDL_TRACE("SDL:EPOC_CreateDevice");
+
+	/* Allocate all variables that we free on delete */
+	device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
+	if ( device ) {
+		memset(device, 0, (sizeof *device));
+		device->hidden = (struct SDL_PrivateVideoData *)
+				malloc((sizeof *device->hidden));
+	}
+	if ( (device == NULL) || (device->hidden == NULL) ) {
+		SDL_OutOfMemory();
+		if ( device ) {
+			free(device);
+		}
+		return(0);
+	}
+	memset(device->hidden, 0, (sizeof *device->hidden));
+
+	/* Set the function pointers */
+	device->VideoInit = EPOC_VideoInit;
+	device->ListModes = EPOC_ListModes;
+	device->SetVideoMode = EPOC_SetVideoMode;
+	device->SetColors = EPOC_SetColors;
+	device->UpdateRects = NULL;
+	device->VideoQuit = EPOC_VideoQuit;
+	device->AllocHWSurface = EPOC_AllocHWSurface;
+	device->CheckHWBlit = NULL;
+	device->FillHWRect = NULL;
+	device->SetHWColorKey = NULL;
+	device->SetHWAlpha = NULL;
+	device->LockHWSurface = EPOC_LockHWSurface;
+	device->UnlockHWSurface = EPOC_UnlockHWSurface;
+	device->FlipHWSurface = EPOC_FlipHWSurface;
+	device->FreeHWSurface = EPOC_FreeHWSurface;
+	device->SetIcon = NULL;
+	device->SetCaption = NULL;
+	device->GetWMInfo = NULL;
+	device->FreeWMCursor = EPOC_FreeWMCursor;
+	device->CreateWMCursor = EPOC_CreateWMCursor;
+	device->ShowWMCursor = EPOC_ShowWMCursor;
+	device->WarpWMCursor = NULL;
+	device->InitOSKeymap = EPOC_InitOSKeymap;
+	device->PumpEvents = EPOC_PumpEvents;
+	device->free = EPOC_DeleteDevice;
+
+	return device;
+}
+
+
+int GetBpp(TDisplayMode displaymode)
+{
+    /*TInt numColors = TDisplayModeUtils::NumDisplayModeColors(displaymode);
+    TInt bitsPerPixel = 1;
+    for (TInt32 i = 2; i < numColors; i <<= 1, bitsPerPixel++);
+    return bitsPerPixel;*/
+    return  TDisplayModeUtils::NumDisplayModeBitsPerPixel(displaymode);   
+}
+
+
+void DisableKeyBlocking(_THIS)
+    {
+    // Disable key blocking
+    TRawEvent event;
+    event.Set((TRawEvent::TType)/*EDisableKeyBlock*/51); // !!EDisableKeyBlock not found in epoc32\include!
+    Private->EPOC_WsSession.SimulateRawEvent(event);
+    }
+
+void ConstructWindowL(_THIS)
+{
+	TInt	error;
+
+	SDL_TRACE("SDL:ConstructWindowL");
+	error = Private->EPOC_WsSession.Connect();
+	User::LeaveIfError(error);
+	Private->EPOC_WsScreen=new(ELeave) CWsScreenDevice(Private->EPOC_WsSession);
+	User::LeaveIfError(Private->EPOC_WsScreen->Construct());
+	User::LeaveIfError(Private->EPOC_WsScreen->CreateContext(Private->EPOC_WindowGc));
+
+	Private->EPOC_WsWindowGroup=RWindowGroup(Private->EPOC_WsSession);
+	User::LeaveIfError(Private->EPOC_WsWindowGroup.Construct(WindowClientHandle));
+	Private->EPOC_WsWindowGroup.SetOrdinalPosition(0);
+
+	// Set window group name (the same as process name)) !!Gives always "EPOC" in WINS
+	RProcess thisProcess;
+	TParse exeName;
+	exeName.Set(thisProcess.FileName(), NULL, NULL);
+    TBuf<32> winGroupName;
+    winGroupName.Append(0);
+    winGroupName.Append(0);
+    winGroupName.Append(0);// uid
+    winGroupName.Append(0);
+    winGroupName.Append(exeName.Name()); // caption
+    winGroupName.Append(0);
+    winGroupName.Append(0); //doc name
+	Private->EPOC_WsWindowGroup.SetName(winGroupName); 
+
+	Private->EPOC_WsWindow=RWindow(Private->EPOC_WsSession);
+  // Markus, it was:
+  // User::LeaveIfError(Private->EPOC_WsWindow.Construct(Private->EPOC_WsWindowGroup,WindowClientHandle ));
+  // but SOS 7.0s debug does not accept same window handle twice
+	User::LeaveIfError(Private->EPOC_WsWindow.Construct(Private->EPOC_WsWindowGroup,WindowClientHandle - 1));
+	Private->EPOC_WsWindow.SetBackgroundColor(KRgbWhite);
+    Private->EPOC_WsWindow.Activate();
+	Private->EPOC_WsWindow.SetSize(Private->EPOC_WsScreen->SizeInPixels()); 
+	Private->EPOC_WsWindow.SetVisible(ETrue);
+
+    Private->EPOC_WsWindowGroupID = Private->EPOC_WsWindowGroup.Identifier();
+    Private->EPOC_IsWindowFocused = EFalse;
+
+    DisableKeyBlocking(_this); //disable key blocking
+}
+
+int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat)
+{
+    // !!TODO:handle leave functions!
+
+    int i;
+
+	SDL_TRACE("SDL:EPOC_VideoInit");
+
+	/* Initialize all variables that we clean on shutdown */   
+
+	for ( i=0; i<SDL_NUMMODES; ++i ) {
+		Private->SDL_modelist[i] = (SDL_Rect *)malloc(sizeof(SDL_Rect));
+		Private->SDL_modelist[i]->x = Private->SDL_modelist[i]->y = 0;
+	}
+
+	/* Modes sorted largest to smallest */
+	Private->SDL_modelist[0]->w = 800; Private->SDL_modelist[0]->h = 250;
+	Private->SDL_modelist[1]->w = 640; Private->SDL_modelist[1]->h = 480;
+	Private->SDL_modelist[2]->w = 480; Private->SDL_modelist[2]->h = 600;
+	Private->SDL_modelist[3]->w = 640; Private->SDL_modelist[3]->h = 400;
+	Private->SDL_modelist[4]->w = 352; Private->SDL_modelist[4]->h = 416;
+	Private->SDL_modelist[5]->w = 416; Private->SDL_modelist[5]->h = 352;
+	Private->SDL_modelist[6]->w = 416; Private->SDL_modelist[6]->h = 312;
+	Private->SDL_modelist[7]->w = 352; Private->SDL_modelist[7]->h = 264;
+	Private->SDL_modelist[8]->w = 800; Private->SDL_modelist[8]->h = 240; //for doom all these..
+	Private->SDL_modelist[9]->w = 640; Private->SDL_modelist[9]->h = 240; 
+	Private->SDL_modelist[10]->w = 480; Private->SDL_modelist[10]->h = 240; 
+	Private->SDL_modelist[11]->w = 640; Private->SDL_modelist[11]->h = 240; 
+	Private->SDL_modelist[12]->w = 352; Private->SDL_modelist[12]->h = 240; 
+	Private->SDL_modelist[13]->w = 416; Private->SDL_modelist[13]->h = 240; 
+	Private->SDL_modelist[14]->w = 416; Private->SDL_modelist[14]->h = 240; 
+	Private->SDL_modelist[15]->w = 352; Private->SDL_modelist[15]->h = 240; 
+    Private->SDL_modelist[16]->w = 640; Private->SDL_modelist[16]->h = 200; 
+	Private->SDL_modelist[17]->w = 320; Private->SDL_modelist[17]->h = 240; //...for doom, currently engine renders no-higher windows :-(, propably should get fixed 
+	Private->SDL_modelist[18]->w = 320; Private->SDL_modelist[18]->h = 200;
+	Private->SDL_modelist[19]->w = 256; Private->SDL_modelist[19]->h = 192;
+	Private->SDL_modelist[20]->w = 176; Private->SDL_modelist[20]->h = 208;
+	Private->SDL_modelist[21]->w = 208; Private->SDL_modelist[21]->h = 176; // Rotated
+	Private->SDL_modelist[22]->w = 160; Private->SDL_modelist[22]->h = 144; 
+
+    Private->SDL_modelist[23]->w = 640; Private->SDL_modelist[2]->h = 200;  //s80 some new modes 
+    Private->SDL_modelist[24]->w = 640; Private->SDL_modelist[2]->h = 320;  //s90 modes are added
+    Private->SDL_modelist[25]->w = 640; Private->SDL_modelist[2]->h = 240;  //here
+	Private->SDL_modelist[26]->w = 640; Private->SDL_modelist[4]->h = 200;  //now
+
+	Private->SDL_modelist[27] = NULL;
+
+    /* Construct Epoc window */
+
+    ConstructWindowL(_this);
+
+    /* Initialise Epoc frame buffer */
+
+    TDisplayMode displayMode = Private->EPOC_WsScreen->DisplayMode();
+
+#if !defined(__WINS__) && !defined(TEST_BM_DRAW)
+
+    TScreenInfoV01 screenInfo;
+	TPckg<TScreenInfoV01> sInfo(screenInfo);
+	UserSvr::ScreenInfo(sInfo);
+
+	Private->EPOC_ScreenSize		= screenInfo.iScreenSize; 
+	Private->EPOC_DisplayMode		= displayMode;
+    Private->EPOC_HasFrameBuffer	= screenInfo.iScreenAddressValid;
+	Private->EPOC_FrameBuffer		= Private->EPOC_HasFrameBuffer ? (TUint8*) screenInfo.iScreenAddress : NULL;
+	Private->EPOC_BytesPerPixel	    = ((GetBpp(displayMode)-1) / 8) + 1;
+	
+    Private->EPOC_BytesPerScanLine	= screenInfo.iScreenSize.iWidth * Private->EPOC_BytesPerPixel;
+	Private->EPOC_BytesPerScreen	= Private->EPOC_BytesPerScanLine * Private->EPOC_ScreenSize.iHeight;
+
+    SDL_TRACE1("Screen width %d", screenInfo.iScreenSize.iWidth);
+    SDL_TRACE1("Screen height %d", screenInfo.iScreenSize.iHeight);
+    SDL_TRACE1("Screen dmode %d", displayMode);
+    SDL_TRACE1("Screen valid %d", screenInfo.iScreenAddressValid);
+
+    SDL_TRACE1("bpp %d", Private->EPOC_BytesPerPixel);
+    SDL_TRACE1("bpsl %d", Private->EPOC_BytesPerScanLine);
+    SDL_TRACE1("bps %d", Private->EPOC_BytesPerScreen);
+
+
+    /* It seems that in SA1100 machines for 8bpp displays there is a 512 palette table at the 
+     * beginning of the frame buffer. E.g. Series 7 and Netbook.
+     * In 12 bpp machines the table has 16 entries.
+	 */
+	if (Private->EPOC_HasFrameBuffer && GetBpp(displayMode) == 8)
+        {
+		Private->EPOC_FrameBuffer += 512;
+        }
+	else
+        {
+        Private->EPOC_FrameBuffer += 32;
+        }
+        /*if (Private->EPOC_HasFrameBuffer && GetBpp(displayMode) == 12)
+		Private->EPOC_FrameBuffer += 16 * 2;
+    if (Private->EPOC_HasFrameBuffer && GetBpp(displayMode) == 16)
+		Private->EPOC_FrameBuffer += 16 * 2;
+    */
+#else /* defined __WINS__ */
+    
+    /* Create bitmap, device and context for screen drawing */
+    Private->EPOC_ScreenSize        = Private->EPOC_WsScreen->SizeInPixels();
+
+	Private->EPOC_Bitmap = new (ELeave) CWsBitmap(Private->EPOC_WsSession);
+	Private->EPOC_Bitmap->Create(Private->EPOC_ScreenSize, displayMode);
+
+	Private->EPOC_DisplayMode	    = displayMode;
+    Private->EPOC_HasFrameBuffer    = ETrue;
+    Private->EPOC_FrameBuffer       = NULL; /* Private->EPOC_Bitmap->DataAddress() can change any time */
+	Private->EPOC_BytesPerPixel	    = ((GetBpp(displayMode)-1) / 8) + 1;
+	Private->EPOC_BytesPerScanLine  = Private->EPOC_WsScreen->SizeInPixels().iWidth * Private->EPOC_BytesPerPixel;
+
+#endif /* __WINS__ */
+
+#ifndef SYMBIAN_CRYSTAL
+	// Get draw device for updating the screen
+	TScreenInfoV01 screenInfo2;
+    
+    Epoc_Runtime::GetScreenInfo(screenInfo2);
+
+	TRAPD(status, Private->EPOC_DrawDevice = CFbsDrawDevice::NewScreenDeviceL(screenInfo2, displayMode));
+	User::LeaveIfError(status);
+#endif
+
+    /* The "best" video format should be returned to caller. */
+
+    vformat->BitsPerPixel       = /*!!GetBpp(displayMode) */ 8;
+    vformat->BytesPerPixel      = /*!!Private->EPOC_BytesPerPixel*/ 1;
+
+    /* Activate events for me */
+
+	Private->EPOC_WsEventStatus = KRequestPending;
+	Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
+
+    SDL_TRACE("SDL:WsEventStatus");
+    User::WaitForRequest(Private->EPOC_WsEventStatus); //Markus: I added this and ...
+
+	Private->EPOC_RedrawEventStatus = KRequestPending;
+	Private->EPOC_WsSession.RedrawReady(&Private->EPOC_RedrawEventStatus);
+    
+    SDL_TRACE("SDL:RedrawEventStatus");
+    User::WaitForRequest(Private->EPOC_RedrawEventStatus); //...this, if not catches a stray event is risen
+                                                           //if there are active objects used, or confucing
+                                                           //actions with User::WaitForAnyRequest
+    Private->EPOC_WsWindow.PointerFilter(EPointerFilterDrag, 0); 
+
+    Private->EPOC_ScreenOffset = TPoint(0, 0);
+
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	LockHeap(Private->EPOC_Bitmap); // Lock bitmap heap
+#endif
+
+    SDL_TRACE("SDL:DrawBackground");
+	DrawBackground(_this); // Clear screen
+
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	UnlockHeap(Private->EPOC_Bitmap); // Unlock bitmap heap
+#endif
+    //!! TODO: error handling
+    //if (ret != KErrNone)
+    //    return(-1);
+    //else
+	    return(0);
+}
+
+
+SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 /*flags*/)
+{
+    if (format->BitsPerPixel == 12 || format->BitsPerPixel == 8)
+        return Private->SDL_modelist;
+    return NULL;
+}
+
+int EPOC_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+{
+	if ((firstcolor+ncolors) > 256)
+		return -1;
+//    SDL_TRACE1("colors %d", (TDisplayModeUtils::NumDisplayModeColors(Private->EPOC_DisplayMode)));
+    if(TDisplayModeUtils::NumDisplayModeColors(Private->EPOC_DisplayMode) == 4096)
+        {
+	// Set 12 bit palette
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+	        // 4k value: 0000 rrrr gggg bbbb
+	        TUint32 color4K	 = (colors[i].r & 0x0000f0) << 4;
+	        color4K			|= (colors[i].g & 0x0000f0);      
+	        color4K			|= (colors[i].b & 0x0000f0) >> 4;
+            EPOC_HWPalette_256_to_Screen[i] = color4K;
+            }
+        }
+    else if(TDisplayModeUtils::NumDisplayModeColors(Private->EPOC_DisplayMode) == 65536)
+        {
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+			// 64k-colour displays effectively support RGB values
+			// with 5 bits allocated to red, 6 to green and 5 to blue
+			// 64k value: rrrr rggg gggb bbbb
+	        TUint32 color64K = (colors[i].r & 0x0000f8) << 8;
+	        color64K		|= (colors[i].g & 0x0000fc) << 3;
+	        color64K		|= (colors[i].b & 0x0000f8) >> 3;
+            EPOC_HWPalette_256_to_Screen[i] = color64K;
+            }
+        }
+    else if(TDisplayModeUtils::NumDisplayModeColors(Private->EPOC_DisplayMode) == 16777216)
+        {
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+			// 16M-colour
+            //0000 0000 rrrr rrrr gggg gggg bbbb bbbb
+	        TUint32 color16M = colors[i].r << 16;
+	        color16M		|= colors[i].g << 8;
+	        color16M		|= colors[i].b;
+            EPOC_HWPalette_256_to_Screen[i] = color16M;
+            }
+        }
+    else
+        {
+        return -2;
+        }
+	return(0);
+}
+
+
+SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current,
+				int width, int height, int bpp, Uint32 /*flags*/)
+{
+	SDL_TRACE("SDL:EPOC_SetVideoMode");
+    /* Check parameters */
+#ifdef SYMBIAN_CRYSTAL
+   if (! (bpp == 8 || bpp == 12 || bpp == 16) &&
+		 (
+		  (width == 640 && height == 200) ||
+          (width == 640 && height == 400) || 
+          (width == 640 && height == 480) || 
+          (width == 320 && height == 200) || 
+          (width == 320 && height == 240)
+		 )) {
+		SDL_SetError("Requested video mode is not supported");
+        return NULL;
+    }
+#else // SYMBIAN_SERIES60
+   if (! (bpp == 8 || bpp == 12 || bpp == 16) &&
+		 (
+		  (width == 320 && height == 200) || 
+          (width == 320 && height == 240) ||
+		  (width == 256 && height == 192) ||  
+		  (width == 176 && height == 208) || 
+		  (width == 208 && height == 176) || // Rotated
+		  (width == 160 && height == 144)    
+		 )) {
+		SDL_SetError("Requested video mode is not supported");
+        return NULL;
+    }
+#endif
+
+    if (current && current->pixels) {
+        free(current->pixels);
+        current->pixels = NULL;
+    }
+	if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) {
+		return(NULL);
+	}
+
+    /* Set up the new mode framebuffer */
+    if (bpp == 8) 
+	    current->flags = (SDL_FULLSCREEN|SDL_SWSURFACE|SDL_PREALLOC|SDL_HWPALETTE); 
+    else // 12 bpp, 16 bpp
+	    current->flags = (SDL_FULLSCREEN|SDL_SWSURFACE|SDL_PREALLOC); 
+	current->w = width;
+	current->h = height;
+    int numBytesPerPixel = ((bpp-1)>>3) + 1;   
+	current->pitch = numBytesPerPixel * width; // Number of bytes in scanline 
+	current->pixels = malloc(width * height * numBytesPerPixel);
+	memset(current->pixels, 0, width * height * numBytesPerPixel);
+
+	/* Set the blit function */
+	_this->UpdateRects = EPOC_DirectUpdate;
+
+    /*
+     *  Logic for getting suitable screen dimensions, offset, scaling and orientation
+     */
+
+	int w = current->w;
+	int h = current->h;
+	
+	// Rotate, if the screen does not fit horizontally and it is landscape screen
+/*
+	if ((width>Private->EPOC_ScreenSize.iWidth) &&  (width>height)) {
+		Private->EPOC_ScreenOrientation = CFbsBitGc::EGraphicsOrientationRotated270;
+		w = current->h; 
+		h = current->w; 
+	}
+*/
+	// Get nearest stepwise scale values for width and height. The smallest supported scaled screen is 1/2.
+	TInt scaleValue = 0;
+	Private->EPOC_ScreenXScaleValue = 1;
+	Private->EPOC_ScreenYScaleValue = 1;
+	if (w > Private->EPOC_ScreenSize.iWidth) {
+		// Find the biggest scale value that result the width that fits in the screen HW
+		for (scaleValue = 2; scaleValue++;) {
+			TInt scaledWidth = (w * (scaleValue-1))/scaleValue;
+			if (scaledWidth > Private->EPOC_ScreenSize.iWidth)
+				break;
+		}
+		Private->EPOC_ScreenXScaleValue = Max(2, scaleValue - 1);
+		w = (w * (Private->EPOC_ScreenXScaleValue-1))/Private->EPOC_ScreenXScaleValue;
+	}
+	if (h > Private->EPOC_ScreenSize.iHeight) {
+		// Find the biggest scale value that result the height that fits in the screen HW
+		for (scaleValue = 2; scaleValue++;) {
+			TInt scaledHeight = (h * (scaleValue-1))/scaleValue;
+			if (scaledHeight > Private->EPOC_ScreenSize.iHeight)
+				break;
+		}
+		Private->EPOC_ScreenYScaleValue = Max(2, scaleValue - 1);
+		h = (h * (Private->EPOC_ScreenYScaleValue-1))/Private->EPOC_ScreenYScaleValue;
+	}
+
+    /* Centralize game window on device screen  */
+    Private->EPOC_ScreenOffset.iX = (Private->EPOC_ScreenSize.iWidth - w) / 2;
+	if (Private->EPOC_ScreenOffset.iX < 0)
+		Private->EPOC_ScreenOffset.iX = 0;
+    Private->EPOC_ScreenOffset.iY = (Private->EPOC_ScreenSize.iHeight - h) / 2;
+	if (Private->EPOC_ScreenOffset.iY < 0)
+		Private->EPOC_ScreenOffset.iY = 0;
+
+
+    SDL_TRACE1("View width %d", w);
+    SDL_TRACE1("View height %d", h);
+    SDL_TRACE1("View bmode %d", bpp);
+    SDL_TRACE1("View s %d", scaleValue);
+    SDL_TRACE1("View x %d", Private->EPOC_ScreenOffset.iX);
+    SDL_TRACE1("View y %d", Private->EPOC_ScreenOffset.iY);
+
+	/* We're done */
+	return(current);
+}
+
+
+void RedrawWindowL(_THIS)
+{
+
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	    LockHeap(Private->EPOC_Bitmap); // Lock bitmap heap
+	    Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow);
+#endif
+
+    int w = _this->screen->w;
+    int h = _this->screen->h;
+	if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
+		w = _this->screen->h;
+		h = _this->screen->w;
+	}
+    if ((w < Private->EPOC_ScreenSize.iWidth)
+        || (h < Private->EPOC_ScreenSize.iHeight)) {
+		DrawBackground(_this);
+    }
+
+    /* Tell the system that something has been drawn */
+	TRect  rect = TRect(Private->EPOC_WsWindow.Size());
+  	Private->EPOC_WsWindow.Invalidate(rect);
+
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	Private->EPOC_WsWindow.BeginRedraw(rect);
+	Private->EPOC_WindowGc->BitBlt(TPoint(), Private->EPOC_Bitmap);
+	Private->EPOC_WsWindow.EndRedraw();
+	Private->EPOC_WindowGc->Deactivate();
+    UnlockHeap(Private->EPOC_Bitmap);; // Unlock bitmap heap
+	Private->EPOC_WsSession.Flush();
+#endif
+
+    /* Draw current buffer */
+    SDL_Rect fullScreen;
+    fullScreen.x = 0;
+    fullScreen.y = 0;
+    fullScreen.w = _this->screen->w;
+    fullScreen.h = _this->screen->h;
+    EPOC_DirectUpdate(_this, 1, &fullScreen);
+}
+
+
+void DrawBackground(_THIS)
+{
+	/* Draw background */
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	//warning heap is not locked! - a function calling must ensure that it's ok
+    TUint16* screenBuffer = (TUint16*)Private->EPOC_Bitmap->DataAddress();
+#else
+    TUint16* screenBuffer = (TUint16*)Private->EPOC_FrameBuffer;
+#endif
+	// Draw black background
+	Mem::FillZ(screenBuffer, Private->EPOC_BytesPerScreen);
+
+#if 0
+    for (int y = 0; y < Private->EPOC_ScreenSize.iHeight; y++) {
+		for (int x = 0; x < Private->EPOC_ScreenSize.iWidth; x++) {
+#ifdef SYMBIAN_CRYSTAL
+			const TUint16 color = 0; // ((x+y)>>1) & 0xf; /* Draw blue stripes pattern, because in e.g. 320x200 mode there is a big background area*/
+#else // SYMBIAN_SERIES60
+            const TUint16 color = 0; /* Draw black background */
+#endif
+            *screenBuffer++ = color;
+		}
+	}
+#endif
+}
+
+
+/* We don't actually allow hardware surfaces other than the main one */
+static int EPOC_AllocHWSurface(_THIS, SDL_Surface* /*surface*/)
+{
+	return(-1);
+}
+static void EPOC_FreeHWSurface(_THIS, SDL_Surface* /*surface*/)
+{
+	return;
+}
+
+static int EPOC_LockHWSurface(_THIS, SDL_Surface* /*surface*/)
+{
+	return(0);
+}
+static void EPOC_UnlockHWSurface(_THIS, SDL_Surface* /*surface*/)
+{
+	return;
+}
+
+static int EPOC_FlipHWSurface(_THIS, SDL_Surface* /*surface*/)
+{
+	return(0);
+}
+
+static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
+{
+    //TInt focusWindowGroupId = Private->EPOC_WsSession.GetFocusWindowGroup();//these are async services
+   // if (focusWindowGroupId != Private->EPOC_WsWindowGroupID) {              //for that cannot be called from
+                                                                            //SDL threads ???
+    if (!Private->EPOC_IsWindowFocused)
+        {
+        /* Force focus window to redraw again for cleaning away SDL screen graphics */
+/*
+        TInt pos = Private->EPOC_WsWindowGroup.OrdinalPosition();
+        Private->EPOC_WsWindowGroup.SetOrdinalPosition(0, KMaxTInt);
+       	TRect  rect = TRect(Private->EPOC_WsWindow.Size());
+        Private->EPOC_WsWindow.Invalidate(rect);
+        Private->EPOC_WsWindowGroup.SetOrdinalPosition(pos, ECoeWinPriorityNormal);
+       */ /* If this is not the topmost window, wait here! Sleep for 1 second to give cpu time to 
+           multitasking and poll for being the topmost window.
+        */
+    //    if (Private->EPOC_WsSession.GetFocusWindowGroup() != Private->EPOC_WsWindowGroupID) {
+           
+		   /* !!TODO: Could call GetRedraw() etc. for WsSession and redraw the screen if needed. That might be 
+		      needed if a small dialog comes in front of Game screen.
+		   */
+           // while (Private->EPOC_WsSession.GetFocusWindowGroup() != Private->EPOC_WsWindowGroupID)
+        
+        SDL_PauseAudio(1);
+        SDL_Delay(1000);
+        return;
+      //  }
+
+    //    RedrawWindowL(_this);  
+    }
+
+    SDL_PauseAudio(0);
+
+	// if we are not focused, do not draw
+//	if (!Private->EPOC_IsWindowFocused)
+//		return;
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	TBitmapUtil lock(Private->EPOC_Bitmap);	
+    lock.Begin(TPoint(0,0)); // Lock bitmap heap
+	Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow);
+    TUint16* screenBuffer = (TUint16*)Private->EPOC_Bitmap->DataAddress();
+#else
+    TUint16* screenBuffer = (TUint16*)Private->EPOC_FrameBuffer;
+#endif
+
+	if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270)
+		DirectDrawRotated(_this, numrects, rects, screenBuffer);
+	else
+		DirectDraw(_this, numrects, rects, screenBuffer);
+    
+   
+#if defined(__WINS__) || defined(TEST_BM_DRAW)
+
+	TRect  rect = TRect(Private->EPOC_WsWindow.Size());
+	Private->EPOC_WsWindow.Invalidate(rect);
+	Private->EPOC_WsWindow.BeginRedraw(rect);
+	Private->EPOC_WindowGc->BitBlt(TPoint(), Private->EPOC_Bitmap);
+	Private->EPOC_WsWindow.EndRedraw();
+	Private->EPOC_WindowGc->Deactivate();
+    lock.End(); // Unlock bitmap heap
+	Private->EPOC_WsSession.Flush();
+#else
+#ifndef SYMBIAN_CRYSTAL
+	// This is not needed in Crystal. What is the performance penalty in SERIES60?
+    TRect  rect2 = TRect(Private->EPOC_WsWindow.Size());
+    
+    Private->EPOC_DrawDevice->UpdateRegion(rect2); // Should we update rects parameter area only??
+    Private->EPOC_DrawDevice->Update();
+#endif
+#endif
+
+    /* Update virtual cursor. !!Do not yet work properly
+    Private->EPOC_WsSession.SetPointerCursorPosition(Private->EPOC_WsSession.PointerCursorPosition());
+    */
+
+    /*static int foo = 1;
+
+    	for ( int i=0; i < numrects; ++i ) {
+        const SDL_Rect& currentRect = rects[i];
+        SDL_Rect rect2;
+        rect2.x = currentRect.x;
+        rect2.y = currentRect.y;
+        rect2.w = currentRect.w;
+        rect2.h = currentRect.h;
+
+        if (rect2.w <= 0 || rect2.h <= 0) 
+            continue;
+
+    
+    foo++;
+    if((foo % 200) == 0)
+        {
+        SDL_TRACE1("foo %d", foo);
+        CFbsBitmap* b = new (ELeave) CFbsBitmap;
+        SDL_TRACE1("bee %d", (int)b);
+        int e = b->Create(TSize(currentRect.w, currentRect.h), Private->EPOC_DisplayMode);
+        
+        SDL_TRACE1("err %d", e);
+        if(e != KErrNone)
+            User::Panic(_L("damn"), e);
+
+        TBitmapUtil u(b);
+        u.Begin(TPoint(0, 0));
+        TUint32* d = b->DataAddress();
+        
+        SDL_TRACE1("addr %d", (int)d);
+
+        for(TInt o = 0; o < currentRect.h; o++)
+            for(TInt p = 0; p < currentRect.w; p++)
+                {
+                u.SetPos(TPoint(p, o));
+                u.SetPixel(0xFFFF);
+                }
+
+        SDL_TRACE1("w %d", (int)currentRect.w);
+        SDL_TRACE1("h %d", (int)currentRect.h);
+
+        SDL_TRACE1("addr %d", (int)Private->EPOC_DisplayMode);
+
+        
+        const TUint f = (TUint)Private->EPOC_FrameBuffer;
+        const TUint y = (TUint)Private->EPOC_BytesPerScreen;
+
+        
+        SDL_TRACE1("frame %u", f);
+        SDL_TRACE1("bytes %u", y);
+
+        Mem::Copy(d, Private->EPOC_FrameBuffer, Private->EPOC_BytesPerScreen);
+
+        SDL_TRACE("kopied");
+
+        u.End();
+        TBuf<32> name;
+        name.Format(_L("C:\\nokia\\images\\doom%d.mbm"), (foo / 200));
+        e= b->Save(name);
+        if(e != KErrNone)
+            User::Panic(_L("damned"), e);
+        delete b;
+            }}*/
+}
+
+
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer)
+{
+	TInt i;
+
+    const TInt sourceNumBytesPerPixel = ((_this->screen->format->BitsPerPixel-1)>>3) + 1;   
+    const TPoint fixedOffset = Private->EPOC_ScreenOffset;   
+    const TInt screenW = _this->screen->w;
+    const TInt screenH = _this->screen->h;
+    const TInt sourceScanlineLength = screenW;
+    const TInt targetScanlineLength = Private->EPOC_ScreenSize.iWidth;
+
+	/* Render the rectangles in the list */
+
+	for ( i=0; i < numrects; ++i ) {
+        const SDL_Rect& currentRect = rects[i];
+        SDL_Rect rect2;
+        rect2.x = currentRect.x;
+        rect2.y = currentRect.y;
+        rect2.w = currentRect.w;
+        rect2.h = currentRect.h;
+
+        if (rect2.w <= 0 || rect2.h <= 0) /* sanity check */
+            continue;
+
+        /* All variables are measured in pixels */
+
+        /* Check rects validity, i.e. upper and lower bounds */
+        TInt maxX = Min(screenW - 1, rect2.x + rect2.w - 1);
+        TInt maxY = Min(screenH - 1, rect2.y + rect2.h - 1);
+        if (maxX < 0 || maxY < 0) /* sanity check */
+            continue;
+		/* Clip from bottom */
+        maxY = Min(maxY, Private->EPOC_ScreenSize.iHeight-1); 
+		/* TODO: Clip from the right side */
+
+        const TInt sourceRectWidth = maxX - rect2.x + 1;
+        const TInt sourceRectWidthInBytes = sourceRectWidth * sourceNumBytesPerPixel;
+        const TInt sourceRectHeight = maxY - rect2.y + 1;
+        const TInt sourceStartOffset = rect2.x + rect2.y * sourceScanlineLength;
+		const TUint skipValue = 1; // no skip
+
+        TInt targetStartOffset = fixedOffset.iX + rect2.x + (fixedOffset.iY +rect2.y) * targetScanlineLength;   
+        
+        // Nokia7650 native mode: 12 bpp --> 12 bpp
+        //
+
+        switch (_this->screen->format->BitsPerPixel)
+			{
+		case 12:
+			{
+			TUint16* bitmapLine = (TUint16*)_this->screen->pixels + sourceStartOffset;
+			TUint16* screenMemory = screenBuffer + targetStartOffset;
+			if (skipValue == 1)
+				{
+				for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					{
+					Mem::Copy(screenMemory, bitmapLine, sourceRectWidthInBytes);
+					}
+					bitmapLine += sourceScanlineLength;
+					screenMemory += targetScanlineLength;
+				}
+			else
+				{
+				for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					{
+					//TODO: optimize: separate loops for 1, 2 and n skip. Mem::Copy() can be used in unscaled case.
+					TUint16* bitmapPos = bitmapLine; /* 2 bytes per pixel */
+					TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+					for(TInt x = 0 ; x < sourceRectWidth ; x++)
+						{					
+						__ASSERT_DEBUG(screenMemory < (screenBuffer + Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight), User::Panic(_L("SDL"), KErrCorrupt));
+						__ASSERT_DEBUG(screenMemory >= screenBuffer, User::Panic(_L("SDL"), KErrCorrupt));
+						__ASSERT_DEBUG(bitmapLine < ((TUint16*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+						__ASSERT_DEBUG(bitmapLine >=  (TUint16*)_this->screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));
+                    
+						*screenMemoryLinePos++ = *bitmapPos;
+						bitmapPos+=skipValue;
+						}
+					bitmapLine += sourceScanlineLength;
+					screenMemory += targetScanlineLength;
+					}
+				}
+			}
+			break;
+        // 256 color paletted mode: 8 bpp  --> 12 bpp
+        //
+		default:
+			{
+            if(Private->EPOC_BytesPerPixel <= 2)
+                {
+			    TUint8* bitmapLine = (TUint8*)_this->screen->pixels + sourceStartOffset;
+                TUint16* screenMemory = screenBuffer + targetStartOffset;
+				    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					    {
+					    TUint8* bitmapPos = bitmapLine; /* 1 byte per pixel */
+					    TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+					    /* Convert each pixel from 256 palette to 4k color values */
+					    for(TInt x = 0 ; x < sourceRectWidth ; x++)
+						    {
+						    __ASSERT_DEBUG(screenMemoryLinePos < (screenBuffer + (Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight)), User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(screenMemoryLinePos >= screenBuffer, User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(bitmapPos < ((TUint8*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(bitmapPos >= (TUint8*)_this->screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));               
+						    *screenMemoryLinePos++ = EPOC_HWPalette_256_to_Screen[*bitmapPos++];
+    //						bitmapPos+=skipValue; //TODO: optimize: separate loops for 1, 2 and n skip
+						    }
+					    bitmapLine += sourceScanlineLength;
+					    screenMemory += targetScanlineLength;
+					    }
+                }
+            else
+                {
+                TUint8* bitmapLine = (TUint8*)_this->screen->pixels + sourceStartOffset;
+                TUint32* screenMemory = reinterpret_cast<TUint32*>(screenBuffer + targetStartOffset);
+				    for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					    {
+					    TUint8* bitmapPos = bitmapLine; /* 1 byte per pixel */
+					    TUint32* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+					    /* Convert each pixel from 256 palette to 4k color values */
+					    for(TInt x = 0 ; x < sourceRectWidth ; x++)
+						    {
+						    __ASSERT_DEBUG(screenMemoryLinePos < (reinterpret_cast<TUint32*>(screenBuffer) + (Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight)), User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(screenMemoryLinePos >= reinterpret_cast<TUint32*>(screenBuffer), User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(bitmapPos < ((TUint8*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(_L("SDL"), KErrCorrupt));
+						    __ASSERT_DEBUG(bitmapPos >= (TUint8*)_this->screen->pixels, User::Panic(_L("SDL"), KErrCorrupt));               
+						    *screenMemoryLinePos++ = EPOC_HWPalette_256_to_Screen[*bitmapPos++];
+    //						bitmapPos+=skipValue; //TODO: optimize: separate loops for 1, 2 and n skip
+						    }
+					    bitmapLine += sourceScanlineLength;
+					    screenMemory += targetScanlineLength;
+					    }
+                }
+			}
+		} // switch
+	} // for
+}
+
+/*
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer)
+{
+	TInt i;
+    const TInt sourceNumBytesPerPixel = ((_this->screen->format->BitsPerPixel-1)>>3) + 1;   
+    const TPoint fixedOffset = Private->EPOC_ScreenOffset;   
+    const TInt screenW = _this->screen->w;
+    const TInt screenH = _this->screen->h;
+    const TInt sourceScanlineLength = screenW;
+    const TInt targetScanlineLength = Private->EPOC_ScreenSize.iWidth;
+
+	/* Render the rectangles in the list */
+
+/*	for ( i=0; i < numrects; ++i ) {
+        const SDL_Rect& currentRect = rects[i];
+        SDL_Rect rect2;
+        rect2.x = currentRect.x;
+        rect2.y = currentRect.y;
+        rect2.w = currentRect.w;
+        rect2.h = currentRect.h;
+
+        if (rect2.w <= 0 || rect2.h <= 0) /* sanity check */
+/*            continue;
+
+        /* All variables are measured in pixels */
+
+        /* Check rects validity, i.e. upper and lower bounds */
+/*        TInt maxX = Min(screenW - 1, rect2.x + rect2.w - 1);
+        TInt maxY = Min(screenH - 1, rect2.y + rect2.h - 1);
+        if (maxX < 0 || maxY < 0) /* sanity check */
+/*            continue;
+		/* Clip from bottom */
+/*        maxY = Min(maxY, Private->EPOC_ScreenSize.iHeight-1); 
+		/* TODO: Clip from the right side */
+
+/*		TInt sourceRectWidth = maxX - rect2.x + 1;
+        const TInt sourceRectWidthInBytes = sourceRectWidth * sourceNumBytesPerPixel;
+        const TInt sourceRectHeight = maxY - rect2.y + 1;
+        const TInt sourceStartOffset = rect2.x + rect2.y * sourceScanlineLength;
+		const TUint skipValue = Private->EPOC_ScreenXScaleValue; //1; // no skip
+
+		const TInt targetStartOffset = // = (fixedOffset.iX + (rect2.x / skipValue) + (fixedOffset.iY + rect2.y) * targetScanlineLength ) ;
+			(skipValue > 1 ? 
+			(fixedOffset.iX + (rect2.x / skipValue) + (fixedOffset.iY + rect2.y) * targetScanlineLength ) : 
+			(fixedOffset.iX +  rect2.x              + (fixedOffset.iY + rect2.y) * targetScanlineLength ));
+
+		__ASSERT_DEBUG(skipValue >= 1, User::Panic(KLibName, KErrArgument));
+
+        // Nokia7650 native mode: 12 bpp --> 12 bpp
+        //
+        switch (_this->screen->format->BitsPerPixel)
+			{
+		case 12:
+			{
+			TUint16* bitmapLine = (TUint16*)_this->screen->pixels + sourceStartOffset;
+			TUint16* screenMemory = screenBuffer + targetStartOffset;
+			if (skipValue == 1)
+				{
+				for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					{
+					Mem::Copy(screenMemory, bitmapLine, sourceRectWidthInBytes);
+					}
+					bitmapLine += sourceScanlineLength;
+					screenMemory += targetScanlineLength;
+				}
+			else
+				{
+				for(TInt y = 0 ; y < sourceRectHeight ; y++)
+					{
+					//TODO: optimize: separate loops for 1, 2 and n skip. Mem::Copy() can be used in unscaled case.
+					TUint16* bitmapPos = bitmapLine; /* 2 bytes per pixel */
+/*					TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+/*					for(TInt x = 0 ; x < sourceRectWidth ; x++)
+						{					
+						__ASSERT_DEBUG(screenMemory < (screenBuffer + Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight), User::Panic(KLibName, KErrCorrupt));
+						__ASSERT_DEBUG(screenMemory >= screenBuffer, User::Panic(KLibName, KErrCorrupt));
+						__ASSERT_DEBUG(bitmapLine < ((TUint16*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(KLibName, KErrCorrupt));
+						__ASSERT_DEBUG(bitmapLine >=  (TUint16*)_this->screen->pixels, User::Panic(KLibName, KErrCorrupt));
+                    
+						*screenMemoryLinePos++ = *bitmapPos;
+						bitmapPos+=skipValue;
+						}
+					bitmapLine += sourceScanlineLength;
+					screenMemory += targetScanlineLength;
+					}
+				}
+			}
+			break;
+        // 256 color paletted mode: 8 bpp  --> 12 bpp
+        //
+		default:
+			{
+			TUint8* bitmapLine = (TUint8*)_this->screen->pixels + sourceStartOffset;
+            TUint16* screenMemory = screenBuffer + targetStartOffset;
+			if (skipValue > 1)
+				sourceRectWidth /= skipValue;
+#if defined __MARM_ARMI__
+			__asm volatile("
+				mov		%4, %4, lsl #1	@ targetScanLineLength is in pixels, we need it in bytes
+			1:
+				mov		r6, %0			@ bitmapLine
+				mov		r7, %2			@ screenMemory
+				mov		r8, %6			@ sourceRectWidth
+			2:
+				ldrb	r4, [%0], %7			@ r4 = *bitmapPos; bitmapPos += skipValue
+				ldr		r5, [%1, r4, lsl #2]	@ only 16 lower bits actually used
+				subs	r8, r8, #1				@ x--
+				strh	r5, [%2], #2			@ *screenMemoryLinePos++ = r4
+				bne		2b
+
+				add		%0, r6, %3		@ bitmapLine += sourceScanlineLength
+				add		%2, r7, %4		@ screenMemory += targetScanlineLength
+				subs    %5, %5, #1		@ sourceRectHeight--
+				bne		1b
+				"
+				: // no output
+				//		%0								%1							%2						%3							%4						%5							%6					%7
+				: "r" (bitmapLine), "r" (&EPOC_HWPalette_256_to_Screen[0]), "r" (screenMemory), "r" (sourceScanlineLength), "r" (targetScanlineLength), "r" (sourceRectHeight), "r" (sourceRectWidth), "r" (skipValue)
+				: "r4", "r5", "r6", "r7", "r8"
+			);
+#else
+			for(TInt y = 0 ; y < sourceRectHeight ; y++)
+				{
+				TUint8* bitmapPos = bitmapLine; /* 1 byte per pixel */
+/*				TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+				/* Convert each pixel from 256 palette to 4k color values */
+/*				for (TInt x = 0 ; x < sourceRectWidth ; x++)
+					{
+					//__ASSERT_DEBUG(screenMemoryLinePos < (screenBuffer + (Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight)), User::Panic(KLibName, KErrCorrupt));
+					//__ASSERT_DEBUG(screenMemoryLinePos >= screenBuffer, User::Panic(KLibName, KErrCorrupt));
+					//__ASSERT_DEBUG(bitmapPos < ((TUint8*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(KLibName, KErrCorrupt));
+					//__ASSERT_DEBUG(bitmapPos >= (TUint8*)_this->screen->pixels, User::Panic(KLibName, KErrCorrupt));
+            
+					*screenMemoryLinePos++ = EPOC_HWPalette_256_to_Screen[*bitmapPos];
+					bitmapPos += skipValue;
+					}
+				bitmapLine += sourceScanlineLength;
+				screenMemory += targetScanlineLength;
+				}
+//#endif
+			}
+		} // switch
+	} // for
+}
+*/
+
+void DirectDrawRotated(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer)
+{
+	TInt i;
+//    TInt sourceNumBytesPerPixel = ((_this->screen->format->BitsPerPixel-1)>>3) + 1;   
+    TPoint fixedScreenOffset = Private->EPOC_ScreenOffset;   
+    TInt bufferW = _this->screen->w;
+    TInt bufferH = _this->screen->h;
+    TInt ScreenW = Private->EPOC_ScreenSize.iWidth;
+//    TInt ScreenH = Private->EPOC_ScreenSize.iWidth;
+    TInt sourceW = bufferW;
+    TInt sourceH = bufferH;
+    TInt targetW = ScreenW - fixedScreenOffset.iX * 2;
+//    TInt targetH = ScreenH - fixedScreenOffset.iY * 2;
+	TInt sourceScanlineLength = bufferW;
+    TInt targetScanlineLength = Private->EPOC_ScreenSize.iWidth;
+
+	/* Render the rectangles in the list */
+
+	for ( i=0; i < numrects; ++i ) {
+        SDL_Rect rect2;
+        const SDL_Rect& currentRect = rects[i];
+        rect2.x = currentRect.x;
+        rect2.y = currentRect.y;
+        rect2.w = currentRect.w;
+        rect2.h = currentRect.h;
+
+        if (rect2.w <= 0 || rect2.h <= 0) /* sanity check */
+            continue;
+
+        /* All variables are measured in pixels */
+
+        /* Check rects validity, i.e. upper and lower bounds */
+        TInt maxX = Min(sourceW - 1, rect2.x + rect2.w - 1);
+        TInt maxY = Min(sourceH - 1, rect2.y + rect2.h - 1);
+        if (maxX < 0 || maxY < 0) /* sanity check */
+            continue;
+		/* Clip from bottom */
+        //maxX = Min(maxX, Private->EPOC_ScreenSize.iHeight-1); 
+		/* TODO: Clip from the right side */
+
+        TInt sourceRectWidth = maxX - rect2.x + 1;
+//        TInt sourceRectWidthInBytes = sourceRectWidth * sourceNumBytesPerPixel;
+        TInt sourceRectHeight = maxY - rect2.y + 1;
+        TInt sourceStartOffset = rect2.x + rect2.y * sourceScanlineLength;
+        TInt targetStartOffset = fixedScreenOffset.iX + (targetW-1 - rect2.y) + (fixedScreenOffset.iY +rect2.x) * targetScanlineLength;   
+        
+        // Nokia7650 native mode: 12 bpp --> 12 bpp
+        if (_this->screen->format->BitsPerPixel == 12) { 
+            
+            /* !!TODO: not yet implemented
+
+	        TUint16* bitmapLine = (TUint16*)_this->screen->pixels + sourceStartOffset;
+            TUint16* screenMemory = screenBuffer + targetStartOffset;
+            for(TInt y = 0 ; y < sourceRectHeight ; y++) {
+				//TODO: optimize: separate loops for 1, 2 and n skip
+		        //Mem::Copy(screenMemory, bitmapLine, sourceRectWidthInBytes);
+                TUint16* bitmapPos = bitmapLine; // 2 bytes per pixel 
+                TUint16* screenMemoryLinePos = screenMemory; // 2 bytes per pixel 
+				for(TInt x = 0 ; x < sourceRectWidth ; x++) {
+
+					__ASSERT_DEBUG(screenMemory < (screenBuffer + Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight), User::Panic(KLibName, KErrCorrupt));
+					__ASSERT_DEBUG(screenMemory >= screenBuffer, User::Panic(KLibName, KErrCorrupt));
+					__ASSERT_DEBUG(bitmapLine < ((TUint16*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(KLibName, KErrCorrupt));
+					__ASSERT_DEBUG(bitmapLine >=  (TUint16*)_this->screen->pixels, User::Panic(KLibName, KErrCorrupt));
+                    
+                      *screenMemoryLinePos = *bitmapPos;
+                    bitmapPos++;
+                    screenMemoryLinePos += targetScanlineLength;
+                }
+		        bitmapLine += sourceScanlineLength;
+		        screenMemory--;
+            }
+
+            */
+        }
+        // 256 color paletted mode: 8 bpp  --> 12 bpp
+        else { 
+	        TUint8* bitmapLine = (TUint8*)_this->screen->pixels + sourceStartOffset;
+            TUint16* screenMemory = screenBuffer + targetStartOffset;
+			TInt screenXScaleValue = Private->EPOC_ScreenXScaleValue;
+			TInt debug_ycount=0;
+            for(TInt y = 0 ; y < sourceRectHeight ; y++) {
+				if(--screenXScaleValue) {
+					TUint8* bitmapPos = bitmapLine; /* 1 byte per pixel */
+					TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */
+					TInt screenYScaleValue = Private->EPOC_ScreenYScaleValue;
+					TInt debug_xcount=0;
+					/* Convert each pixel from 256 palette to 4k color values */
+					for(TInt x = 0 ; x < sourceRectWidth ; x++) {
+						if(--screenYScaleValue) {
+							
+                            __ASSERT_DEBUG(screenMemoryLinePos < (screenBuffer + (Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight)), User::Panic(KLibName, KErrCorrupt));
+							__ASSERT_DEBUG(screenMemoryLinePos >= screenBuffer, User::Panic(KLibName, KErrCorrupt));
+							__ASSERT_DEBUG(bitmapPos < ((TUint8*)_this->screen->pixels + (_this->screen->w * _this->screen->h)), User::Panic(KLibName, KErrCorrupt));
+							__ASSERT_DEBUG(bitmapPos >= (TUint8*)_this->screen->pixels, User::Panic(KLibName, KErrCorrupt));
+							
+                            *screenMemoryLinePos = TUint16(EPOC_HWPalette_256_to_Screen[*bitmapPos]);
+							screenMemoryLinePos += targetScanlineLength; debug_xcount++;
+						}
+						else
+							screenYScaleValue = Private->EPOC_ScreenYScaleValue;
+						bitmapPos++; 
+					}
+					screenMemory--; debug_ycount++;
+				} // endif
+				else
+					screenXScaleValue = Private->EPOC_ScreenXScaleValue;
+				bitmapLine += sourceScanlineLength;
+             }
+	    }
+    }    
+}
+
+
+/* Note:  If we are terminated, this could be called in the middle of
+   another SDL video routine -- notably UpdateRects.
+*/
+void EPOC_VideoQuit(_THIS)
+{
+	int i;
+
+	/* Free video mode lists */
+	for ( i=0; i<SDL_NUMMODES; ++i ) {
+		if ( Private->SDL_modelist[i] != NULL ) {
+			free(Private->SDL_modelist[i]);
+			Private->SDL_modelist[i] = NULL;
+		}
+	}
+	
+    if ( _this->screen && (_this->screen->flags & SDL_HWSURFACE) ) {
+		/* Direct screen access, no memory buffer */
+		_this->screen->pixels = NULL;
+	}
+
+    if (_this->screen && _this->screen->pixels) {
+        free(_this->screen->pixels);
+        _this->screen->pixels = NULL;
+    }
+
+    /* Free Epoc resources */
+
+    /* Disable events for me */
+	if (Private->EPOC_WsEventStatus != KRequestPending)
+		Private->EPOC_WsSession.EventReadyCancel();
+	if (Private->EPOC_RedrawEventStatus != KRequestPending)
+		Private->EPOC_WsSession.RedrawReadyCancel();
+
+	#if defined(__WINS__) || defined(TEST_BM_DRAW)
+	delete Private->EPOC_Bitmap;
+	Private->EPOC_Bitmap = NULL;
+	#else
+    #endif
+
+#ifndef SYMBIAN_CRYSTAL
+	free(Private->EPOC_DrawDevice);
+#endif
+
+	if (Private->EPOC_WsWindow.WsHandle())
+		Private->EPOC_WsWindow.Close();
+
+	if (Private->EPOC_WsWindowGroup.WsHandle())
+		Private->EPOC_WsWindowGroup.Close();
+
+	delete Private->EPOC_WindowGc;
+	Private->EPOC_WindowGc = NULL;
+
+	delete Private->EPOC_WsScreen;
+	Private->EPOC_WsScreen = NULL;
+
+	if (Private->EPOC_WsSession.WsHandle())
+		Private->EPOC_WsSession.Close();
+}
+
+
+WMcursor *EPOC_CreateWMCursor(_THIS, Uint8* /*data*/, Uint8* /*mask*/, int /*w*/, int /*h*/, int /*hot_x*/, int /*hot_y*/)
+{
+	return (WMcursor *) 9210; // it's ok to return something unuseful but true
+}
+
+void EPOC_FreeWMCursor(_THIS, WMcursor* /*cursor*/)
+{
+    /* Disable virtual cursor */
+    HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
+    Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNone);
+}
+
+int EPOC_ShowWMCursor(_THIS, WMcursor *cursor)
+{
+
+    if (cursor ==  (WMcursor *)9210) {
+        /* Enable virtual cursor */
+	    Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNormal);
+        if (isCursorVisible)
+	        HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
+        else
+            Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNone);
+    }
+    else {
+        /* Disable virtual cursor */
+        HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
+        Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNone);
+    }
+
+	return(1);
+}
+
+}; // extern "C"
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA1/SDL_epocvideo.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,34 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifndef _SDL_epocvideo_h
+#define _SDL_epocvideo_h
+
+#ifndef EKA2
+#include"SDL_epocvideo_org.h"
+#else
+#include"SDL_epocvideo2.h"
+#endif
+
+
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA2/SDL_epocevents.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,521 @@
+#include "epoc_sdl.h"
+
+#include <stdio.h>
+#undef NULL
+extern "C" {
+//#define DEBUG_TRACE_ENABLED
+#include "SDL_error.h"
+#include "SDL_video.h"
+#include "SDL_keysym.h"
+#include "SDL_keyboard.h"
+#include "SDL_events_c.h"
+#include "SDL_timer.h"
+} /* extern "C" */
+
+#include "SDL_epocvideo.h"
+#include "SDL_epocevents_c.h"
+
+#include "sdlepocapi.h"
+
+#include <eikenv.h>
+
+#include<bautils.h>
+
+
+extern "C"
+	{
+	static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
+	}
+
+//extern "C" {
+/* The translation tables from a console scancode to a SDL keysym */
+static SDLKey keymap[MAX_SCANCODE];
+static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
+void DisableKeyBlocking(_THIS);
+//} /* extern "C" */
+
+SDLKey* KeyMap()
+	{
+	return keymap;
+	}
+	
+TBool isCursorVisible = EFalse;
+
+void ResetKeyMap()
+	{
+	int i;
+
+	/* Initialize the key translation table */
+	for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
+		keymap[i] = SDLK_UNKNOWN;
+
+
+	/* Numbers */
+	for ( i = 0; i<32; ++i ){
+		keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
+	}
+	/* e.g. Alphabet keys */
+	for ( i = 0; i<32; ++i ){
+		keymap['A' + i] = (SDLKey)(SDLK_a+i);
+	}
+
+	keymap[EStdKeyBackspace]    = SDLK_BACKSPACE;
+	keymap[EStdKeyTab]          = SDLK_TAB;
+	keymap[EStdKeyEnter]        = SDLK_RETURN;
+	keymap[EStdKeyEscape]       = SDLK_ESCAPE;
+   	keymap[EStdKeySpace]        = SDLK_SPACE;
+   	keymap[EStdKeyPause]        = SDLK_PAUSE;
+   	keymap[EStdKeyHome]         = SDLK_HOME;
+   	keymap[EStdKeyEnd]          = SDLK_END;
+   	keymap[EStdKeyPageUp]       = SDLK_PAGEUP;
+   	keymap[EStdKeyPageDown]     = SDLK_PAGEDOWN;
+	keymap[EStdKeyDelete]       = SDLK_DELETE;
+	keymap[EStdKeyUpArrow]      = SDLK_UP;
+	keymap[EStdKeyDownArrow]    = SDLK_DOWN;
+	keymap[EStdKeyLeftArrow]    = SDLK_LEFT;
+	keymap[EStdKeyRightArrow]   = SDLK_RIGHT;
+	keymap[EStdKeyCapsLock]     = SDLK_CAPSLOCK;
+	keymap[EStdKeyLeftShift]    = SDLK_LSHIFT;
+	keymap[EStdKeyRightShift]   = SDLK_RSHIFT;
+	keymap[EStdKeyLeftAlt]      = SDLK_LALT;
+	keymap[EStdKeyRightAlt]     = SDLK_RALT;
+	keymap[EStdKeyLeftCtrl]     = SDLK_LCTRL;
+	keymap[EStdKeyRightCtrl]    = SDLK_RCTRL;
+	keymap[EStdKeyLeftFunc]     = SDLK_LMETA;
+	keymap[EStdKeyRightFunc]    = SDLK_RMETA;
+	keymap[EStdKeyInsert]       = SDLK_INSERT;
+	keymap[EStdKeyComma]        = SDLK_COMMA;
+	keymap[EStdKeyFullStop]     = SDLK_PERIOD;
+	keymap[EStdKeyForwardSlash] = SDLK_SLASH;
+	keymap[EStdKeyBackSlash]    = SDLK_BACKSLASH;
+	keymap[EStdKeySemiColon]    = SDLK_SEMICOLON;
+	keymap[EStdKeySingleQuote]  = SDLK_QUOTE;
+	keymap[EStdKeyHash]         = SDLK_HASH;
+	keymap[EStdKeySquareBracketLeft]    = SDLK_LEFTBRACKET;
+	keymap[EStdKeySquareBracketRight]   = SDLK_RIGHTBRACKET;
+	keymap[EStdKeyMinus]        = SDLK_MINUS;
+	keymap[EStdKeyEquals]       = SDLK_EQUALS;
+
+   	keymap[EStdKeyF1]          = SDLK_F1;  
+   	keymap[EStdKeyF2]          = SDLK_F2;  
+   	keymap[EStdKeyF3]          = SDLK_F3;  
+   	keymap[EStdKeyF4]          = SDLK_F4; 
+   	keymap[EStdKeyF5]          = SDLK_F5;  
+   	keymap[EStdKeyF6]          = SDLK_F6;  
+   	keymap[EStdKeyF7]          = SDLK_F7;  
+   	keymap[EStdKeyF8]          = SDLK_F8;  
+
+   	keymap[EStdKeyF9]          = SDLK_F9;  
+   	keymap[EStdKeyF10]         = SDLK_F10; 
+   	keymap[EStdKeyF11]         = SDLK_F11; 
+   	keymap[EStdKeyF12]         = SDLK_F12; 
+
+
+   	keymap[EStdKeyXXX]         = SDLK_RETURN;	/* "fire" key */
+
+   	keymap[EStdKeyDevice3]     = SDLK_RETURN;	/* "fire" key */
+   	keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK; 
+   	keymap[EStdKeyYes]         = SDLK_HOME;		/* "call" key */
+   	keymap[EStdKeyNo]		   = SDLK_END;		/* "end call" key */
+   	keymap[EStdKeyDevice0]     = SDLK_SPACE;	/* right menu key */
+   	keymap[EStdKeyDevice1]     = SDLK_ESCAPE;	/* left menu key */
+   	keymap[EStdKeyDevice2]     = SDLK_POWER;	/* power key */
+
+    keymap[EStdKeyMenu]        = SDLK_MENU;   	// menu key
+    keymap[EStdKeyDevice6]     = SDLK_LEFT;     // Rocker (joystick) left
+    keymap[EStdKeyDevice7]     = SDLK_RIGHT;    // Rocker (joystick) right
+    keymap[EStdKeyDevice8]     = SDLK_UP;       // Rocker (joystick) up
+    keymap[EStdKeyDevice9]     = SDLK_DOWN;     // Rocker (joystick) down
+    keymap[EStdKeyLeftFunc]     = SDLK_LALT;    //chr?
+	keymap[EStdKeyRightFunc]    = SDLK_RALT;
+    keymap[EStdKeyDeviceA]      = SDLK_RETURN;	/* "fire" key */
+    
+    
+    
+
+
+    ///////////////////////////////////////////////////////////
+    /*
+    RFs fs;
+    if(KErrNone == fs.Connect())
+        {
+        RArray<TInt> array;
+        TRAPD(err, ReadL(fs, array));
+        if(err == KErrNone && array.Count() > 0)
+            {
+            
+            SDLKey temp[MAX_SCANCODE];
+            Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
+
+            for(TInt k = 0; k < array.Count(); k+= 2)
+                {
+                const TInt oldval = array[k]; 
+                const TInt newval = array[k + 1]; 
+                if(oldval >=  0 && oldval < MAX_SCANCODE && newval >=  0 && newval < MAX_SCANCODE)
+                    {
+                    keymap[oldval] = temp[newval];
+                    }
+                }
+            }
+        array.Close();
+        }
+
+    fs.Close();*/
+    ///////////////////////////////////////////////////////////
+
+    
+	keymap[EStdKeyNumLock] = SDLK_NUMLOCK;
+	keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK;
+	
+	keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE;
+	keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY;
+	keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS;
+	keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS;
+	keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER;
+	keymap[EStdKeyNkp1] = SDLK_KP1;
+	keymap[EStdKeyNkp2] = SDLK_KP2;
+	keymap[EStdKeyNkp3] = SDLK_KP3;
+	keymap[EStdKeyNkp4] = SDLK_KP4;
+	keymap[EStdKeyNkp5] = SDLK_KP5;
+	keymap[EStdKeyNkp6] = SDLK_KP6;
+	keymap[EStdKeyNkp7] = SDLK_KP7;
+	keymap[EStdKeyNkp8] = SDLK_KP8;
+	keymap[EStdKeyNkp9] = SDLK_KP9;
+	keymap[EStdKeyNkp0] = SDLK_KP0;
+	keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD;
+    /*
+    keymap[EStdKeyMenu] = SDLK_MENU; should be, but not yet
+    keymap[EStdKeyBacklightOn] =
+    keymap[EStdKeyBacklightOff] =
+    keymap[EStdKeyBacklightToggle] =
+    keymap[EStdKeyIncContrast] =
+    keymap[EStdKeyDecContrast] =
+    keymap[EStdKeySliderDown] =
+    keymap[EStdKeySliderUp] =
+    keymap[EStdKeyDictaphonePlay] =
+    keymap[EStdKeyDictaphoneStop] =
+    keymap[EStdKeyDictaphoneRecord] =
+    keymap[EStdKeyHelp] =
+    keymap[EStdKeyOff] =
+    keymap[EStdKeyDial] =
+    keymap[EStdKeyIncVolume] =
+    keymap[EStdKeyDecVolume] =
+    keymap[EStdKeyDevice0] =
+    keymap[EStdKeyDevice1] =
+    keymap[EStdKeyDevice2] =
+    keymap[EStdKeyDevice3] =
+    keymap[EStdKeyDevice4] =
+    keymap[EStdKeyDevice5] =
+    keymap[EStdKeyDevice6] =
+    keymap[EStdKeyDevice7] =
+    keymap[EStdKeyDevice8] =
+    keymap[EStdKeyDevice9] =
+    keymap[EStdKeyDeviceA] =
+    keymap[EStdKeyDeviceB] =
+    keymap[EStdKeyDeviceC] =
+    keymap[EStdKeyDeviceD] =
+    keymap[EStdKeyDeviceE] =
+    keymap[EStdKeyDeviceF] =
+    keymap[EStdKeyApplication0] =
+    keymap[EStdKeyApplication1] =
+    keymap[EStdKeyApplication2] =
+    keymap[EStdKeyApplication3] =
+    keymap[EStdKeyApplication4] =
+    keymap[EStdKeyApplication5] =
+    keymap[EStdKeyApplication6] =
+    keymap[EStdKeyApplication7] =
+    keymap[EStdKeyApplication8] =
+    keymap[EStdKeyApplication9] =
+    keymap[EStdKeyApplicationA] =
+    keymap[EStdKeyApplicationB] =
+    keymap[EStdKeyApplicationC] =
+    keymap[EStdKeyApplicationD] =
+    keymap[EStdKeyApplicationE] =
+    keymap[EStdKeyApplicationF] =
+    keymap[EStdKeyYes] =
+    keymap[EStdKeyNo] =
+    keymap[EStdKeyIncBrightness] =
+    keymap[EStdKeyDecBrightness] = 
+    keymap[EStdKeyCaseOpen] =
+    keymap[EStdKeyCaseClose] =  */
+    
+
+
+}
+
+
+int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
+{
+    int posted = 0;
+    SDL_keysym keysym;
+    
+//    SDL_TRACE1("hws %d", aWsEvent.Type());
+
+    switch (aWsEvent.Type())
+		{    
+    case EEventPointer: /* Mouse pointer events */
+		{
+/*        const TPointerCursorMode mode = EpocSdlEnv::PointerMode();
+        
+
+        if(mode == EPointerCursorNone) 
+            {
+            return 0; //TODO: Find out why events are get despite of cursor should be off
+            }
+*/
+        const TPointerEvent* pointerEvent = aWsEvent.Pointer();
+        const TPoint mousePos = EpocSdlEnv::WindowCoordinates(pointerEvent->iPosition);
+
+        /*!! TODO Pointer do not yet work properly
+        //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!!
+
+        if (Private->EPOC_ShrinkedHeight) {
+            mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height
+        }
+        if (Private->EPOC_ShrinkedWidth) {
+            mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width
+        }
+        */
+
+		posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */
+
+		switch (pointerEvent->iType)
+			{
+        case TPointerEvent::EButton1Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
+			break;
+        case TPointerEvent::EButton1Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
+			break;
+        case TPointerEvent::EButton2Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);
+			break;
+		case TPointerEvent::EButton2Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);
+			break;
+        case TPointerEvent::EButton3Down:
+            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);
+			break;
+        case TPointerEvent::EButton3Up:
+			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);
+			break;
+			} // switch
+        break;
+	    }
+    
+    case EEventKeyDown: /* Key events */
+    {
+#ifdef SYMBIAN_CRYSTAL
+		// special case: 9300/9500 rocker down, simulate left mouse button
+		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
+			{
+            const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();
+            if(mode != EPointerCursorNone) 
+                posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
+			}
+#endif
+       (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);
+            
+#ifndef DISABLE_JOYSTICK
+        /* Special handling */
+        switch((int)keysym.sym) {
+        case SDLK_CAPSLOCK:
+            if (!isCursorVisible) {
+                /* Enable virtual cursor */
+	            HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
+            }
+            else {
+                /* Disable virtual cursor */
+                HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
+            }
+            isCursorVisible = !isCursorVisible;
+            break;
+        }
+#endif        
+	    posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+        break;
+	} 
+
+    case EEventKeyUp: /* Key events */
+		{
+#ifdef SYMBIAN_CRYSTAL
+		// special case: 9300/9500 rocker up, simulate left mouse button
+		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
+			{
+            posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
+			}
+#endif
+	    posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
+        break;
+		}
+    
+    case EEventFocusGained: /* SDL window got focus */
+	    {
+        Private->iIsWindowFocused = ETrue;
+		posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
+        /* Draw window background and screen buffer */
+        DisableKeyBlocking(_this);  //Markus: guess why:-)
+ 
+        //RedrawWindowL(_this);  
+        break;
+	    }
+
+    case EEventFocusLost: /* SDL window lost focus */
+		{
+
+		Private->iIsWindowFocused = EFalse;
+
+		posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
+
+       
+        break;
+	    }
+
+    case EEventModifiersChanged: 
+    {
+	    TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
+        TUint modstate = KMOD_NONE;
+        if (modEvent->iModifiers == EModifierLeftShift)
+            modstate |= KMOD_LSHIFT;
+        if (modEvent->iModifiers == EModifierRightShift)
+            modstate |= KMOD_RSHIFT;
+        if (modEvent->iModifiers == EModifierLeftCtrl)
+            modstate |= KMOD_LCTRL;
+        if (modEvent->iModifiers == EModifierRightCtrl)
+            modstate |= KMOD_RCTRL;
+        if (modEvent->iModifiers == EModifierLeftAlt)
+            modstate |= KMOD_LALT;
+        if (modEvent->iModifiers == EModifierRightAlt)
+            modstate |= KMOD_RALT;
+        if (modEvent->iModifiers == EModifierLeftFunc)
+            modstate |= KMOD_LMETA;
+        if (modEvent->iModifiers == EModifierRightFunc)
+            modstate |= KMOD_RMETA;
+        if (modEvent->iModifiers == EModifierCapsLock)
+            modstate |= KMOD_CAPS;
+        SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
+        break;
+    }
+	case EEventScreenDeviceChanged:
+	        {
+	        EpocSdlEnv::WaitDeviceChange();  
+	        }
+	    break;
+    default:            
+        break;
+	} 
+	
+    return posted;
+}
+
+extern "C" {
+
+void EPOC_PumpEvents(_THIS)
+    {
+    MEventQueue& events = EpocSdlEnv::EventQueue();
+    while(events.HasData())
+        {
+        events.Lock();
+       
+       //there have to be a copy, so we can release
+       //lock immediately. HandleWsEvent may cause
+       //deadlock otherwise.
+        
+        const TWsEvent event = events.Shift();
+		events.Unlock();
+//        const TWsEvent& event = events.Top();
+		EPOC_HandleWsEvent(_this, event);
+//		events.Shift();
+	    }
+    }
+
+
+
+void EPOC_InitOSKeymap(_THIS)
+	{
+	ResetKeyMap();
+	EpocSdlEnv::ObserverEvent(MSDLObserver::EEventKeyMapInit ,0);
+	}
+
+static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
+{
+//    char debug[256];
+    //SDL_TRACE1("SDL: TranslateKey, scancode=%d", scancode); //!!
+
+	/* Set the keysym information */ 
+
+	keysym->scancode = scancode;
+
+    if ((scancode >= MAX_SCANCODE) && 
+        ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
+        SDL_SetError("Too big scancode");
+        keysym->scancode = SDLK_UNKNOWN;
+	    keysym->mod = KMOD_NONE; 
+        return keysym;
+    }
+
+	keysym->mod = SDL_GetModState();
+
+    /* Handle function keys: F1, F2, F3 ... */
+    if (keysym->mod & KMOD_META) {
+        if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
+            switch(scancode) {
+                case 'Q': scancode = EStdKeyF1; break;
+                case 'W': scancode = EStdKeyF2; break;
+                case 'E': scancode = EStdKeyF3; break;
+                case 'R': scancode = EStdKeyF4; break;
+                case 'T': scancode = EStdKeyF5; break;
+                case 'Y': scancode = EStdKeyF6; break;
+                case 'U': scancode = EStdKeyF7; break;
+                case 'I': scancode = EStdKeyF8; break;
+                case 'A': scancode = EStdKeyF9; break;
+                case 'S': scancode = EStdKeyF10; break;
+                case 'D': scancode = EStdKeyF11; break;
+                case 'F': scancode = EStdKeyF12; break;
+            }
+            keysym->sym = keymap[scancode];
+        }
+    }
+
+    if (scancode >= ENonCharacterKeyBase) {
+        // Non character keys
+	    keysym->sym = keymap[scancode - 
+            ENonCharacterKeyBase + 0x0081]; // !!hard coded
+    } else {
+	    keysym->sym = keymap[scancode];
+    }
+
+	/* Remap the arrow keys if the device is rotated */
+/*
+	if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
+		switch(keysym->sym) {
+			case SDLK_UP:	keysym->sym = SDLK_LEFT;  break;
+			case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
+			case SDLK_LEFT: keysym->sym = SDLK_DOWN;  break;
+			case SDLK_RIGHT:keysym->sym = SDLK_UP;    break;
+		}
+	}
+*/
+	/* If UNICODE is on, get the UNICODE value for the key */
+	keysym->unicode = 0;
+
+#if 0 // !!TODO:unicode
+
+	if ( SDL_TranslateUNICODE ) 
+    {
+		/* Populate the unicode field with the ASCII value */
+		keysym->unicode = scancode;
+	}
+#endif
+
+    //!!
+    //sprintf(debug, "SDL: TranslateKey: keysym->scancode=%d, keysym->sym=%d, keysym->mod=%d",
+    //    keysym->scancode, keysym->sym, keysym->mod);
+    //SDL_TRACE(debug); //!!
+
+	return(keysym);
+}
+
+} /* extern "C" */
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA2/SDL_epocvideo.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,594 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+/*
+    SDL_epocvideo.cpp
+    Epoc based SDL video driver implementation
+
+    Markus Mertama
+*/
+
+
+
+#include "epoc_sdl.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+extern "C" {
+#include "SDL_error.h"
+#include "SDL_timer.h"
+#include "SDL_video.h"
+#undef NULL
+#include "SDL_pixels_c.h"
+#include "SDL.h"
+#include "SDL_mouse.h"
+}
+
+#include "SDL_epocvideo.h"
+#include "SDL_epocevents_c.h"
+
+
+
+#include <coedef.h>
+#include <flogger.h>
+
+#include <eikenv.h>
+#include <eikappui.h>
+#include <eikapp.h>
+#include "sdlepocapi.h"
+
+
+////////////////////////////////////////////////////////////////
+
+
+
+
+_LIT(KLibName, "SDL");
+
+void RDebug_Print_b(char* error_str, void* param)
+    {
+    TBuf8<128> error8((TUint8*)error_str);
+    TBuf<128> error;
+    error.Copy(error8);
+
+#ifndef TRACE_TO_FILE
+    if (param) //!! Do not work if the parameter is really 0!!
+        RDebug::Print(error, param);
+    else 
+        RDebug::Print(error);
+#else
+    if (param) //!! Do not work if the parameter is really 0!!
+        RFileLogger::WriteFormat(KLibName, _L("SDL.txt"), EFileLoggingModeAppend, error, param);
+    else 
+        RFileLogger::Write(KLibName, _L("SDL.txt"), EFileLoggingModeAppend, error);
+#endif
+
+    }
+
+extern "C" void RDebug_Print(char* error_str, void* param)
+    {
+    RDebug_Print_b(error_str, param);
+    }
+
+/*
+int Debug_AvailMem2()
+    {
+    //User::CompressAllHeaps();
+    TMemoryInfoV1Buf membuf; 
+    User::LeaveIfError(UserHal::MemoryInfo(membuf));
+    TMemoryInfoV1 minfo = membuf();
+	return(minfo.iFreeRamInBytes);
+    }
+
+extern "C" int Debug_AvailMem()
+    {
+    return(Debug_AvailMem2());
+    }
+    
+*/
+
+extern "C" {
+
+/* Initialization/Query functions */
+
+static int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat);
+static SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
+static SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int EPOC_SetColors(_THIS, int firstcolor, int ncolors,
+			  SDL_Color *colors);
+static void EPOC_VideoQuit(_THIS);
+
+/* Hardware surface functions */
+
+static int EPOC_AllocHWSurface(_THIS, SDL_Surface *surface);
+static int EPOC_LockHWSurface(_THIS, SDL_Surface *surface);
+static int EPOC_FlipHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_UnlockHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_FreeHWSurface(_THIS, SDL_Surface *surface);
+static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
+
+static int EPOC_Available(void);
+static SDL_VideoDevice *EPOC_CreateDevice(int devindex);
+
+void DrawBackground(_THIS);
+void DirectDraw(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer);
+void DirectDrawRotated(_THIS, int numrects, SDL_Rect *rects, TUint16* screenBuffer);
+
+/* Mouse functions */
+
+static WMcursor *EPOC_CreateWMCursor(_THIS, Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
+static void EPOC_FreeWMCursor(_THIS, WMcursor *cursor);
+static int EPOC_ShowWMCursor(_THIS, WMcursor *cursor);
+}
+
+
+extern "C"
+	{
+	struct WMcursor
+		{
+		};
+	}
+
+/* Epoc video driver bootstrap functions */
+
+
+static int EPOC_Available(void)
+    {
+    return 1; /* Always available */
+    }
+
+static void EPOC_DeleteDevice(SDL_VideoDevice *device)
+    {
+	User::Free(device->hidden);
+	User::Free(device);
+    }
+
+static SDL_VideoDevice *EPOC_CreateDevice(int /*devindex*/)
+    {
+	SDL_VideoDevice *device;
+
+	SDL_TRACE("SDL:EPOC_CreateDevice");
+
+	/* Allocate all variables that we free on delete */
+	device = static_cast<SDL_VideoDevice*>(User::Alloc(sizeof(SDL_VideoDevice)));
+	if ( device ) 
+	    {
+		Mem::FillZ(device, (sizeof *device));
+		device->hidden = static_cast<struct SDL_PrivateVideoData*>
+				(User::Alloc((sizeof *device->hidden)));
+	    }
+	if ( (device == NULL) || (device->hidden == NULL) )
+	    {
+		SDL_OutOfMemory();
+		if ( device ) {
+		User::Free(device);
+		}
+		return(0);
+	}
+	Mem::FillZ(device->hidden, (sizeof *device->hidden));
+
+	/* Set the function pointers */
+	device->VideoInit = EPOC_VideoInit;
+	device->ListModes = EPOC_ListModes;
+	device->SetVideoMode = EPOC_SetVideoMode;
+	device->SetColors = EPOC_SetColors;
+	device->UpdateRects = NULL;
+	device->VideoQuit = EPOC_VideoQuit;
+	device->AllocHWSurface = EPOC_AllocHWSurface;
+	device->CheckHWBlit = NULL;
+	device->FillHWRect = NULL;
+	device->SetHWColorKey = NULL;
+	device->SetHWAlpha = NULL;
+	device->LockHWSurface = EPOC_LockHWSurface;
+	device->UnlockHWSurface = EPOC_UnlockHWSurface;
+	device->FlipHWSurface = EPOC_FlipHWSurface;
+	device->FreeHWSurface = EPOC_FreeHWSurface;
+	device->SetIcon = NULL;
+	device->SetCaption = NULL;
+	device->GetWMInfo = NULL;
+	device->FreeWMCursor = EPOC_FreeWMCursor;
+	device->CreateWMCursor = EPOC_CreateWMCursor;
+	device->ShowWMCursor = EPOC_ShowWMCursor;
+	device->WarpWMCursor = NULL;
+	device->InitOSKeymap = EPOC_InitOSKeymap;
+	device->PumpEvents = EPOC_PumpEvents;
+	device->free = EPOC_DeleteDevice;
+
+	return device;
+}
+
+
+VideoBootStrap EPOC_bootstrap = {
+	"epoc\0\0\0", "EPOC system",
+    EPOC_Available, EPOC_CreateDevice
+};
+
+
+
+void DisableKeyBlocking(_THIS)
+    {
+    EpocSdlEnv::Request(EpocSdlEnv::EDisableKeyBlocking);
+    }
+
+void ConstructWindowL(_THIS)
+	{
+	SDL_TRACE("SDL:ConstructWindowL");
+	DisableKeyBlocking(_this); //disable key blocking
+	}
+		
+
+int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat)
+	{
+    /* Construct Epoc window */
+
+    ConstructWindowL(_this);
+
+    /* Initialise Epoc frame buffer */
+
+  
+    const TDisplayMode displayMode = EpocSdlEnv::DisplayMode();
+
+    /* The "best" video format should be returned to caller. */
+
+    vformat->BitsPerPixel 	= TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode);
+    vformat->BytesPerPixel  = TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode) / 8;
+
+    
+ //??   Private->iWindow->PointerFilter(EPointerFilterDrag, 0); 
+
+    Private->iScreenPos = TPoint(0, 0);
+    
+    Private->iRect.x = Private->iScreenPos.iX;
+    Private->iRect.y = Private->iScreenPos.iY;
+    
+    const TSize sz = EpocSdlEnv::WindowSize();
+    
+    Private->iRect.w = sz.iWidth;
+    Private->iRect.h = sz.iHeight;
+	Private->iRectPtr = &Private->iRect;
+
+	return(0);
+	}
+
+
+SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+	{
+	if(flags & SDL_HWSURFACE)
+		{
+		if(format->BytesPerPixel != 4) //in HW only full color is supported
+			return NULL;
+		}
+	if(flags & SDL_FULLSCREEN)
+		{
+		return &Private->iRectPtr;
+		}
+    return (SDL_Rect **)(-1); //everythingisok, unless too small shoes
+	}
+
+
+int EPOC_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+	{
+	if ((firstcolor+ncolors) > 256)
+		return -1;
+	TUint32 palette[256];
+	const TDisplayMode mode = EpocSdlEnv::DisplayMode();
+    if(TDisplayModeUtils::NumDisplayModeColors(mode) == 4096)
+        {
+	// Set 12 bit palette
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+	        // 4k value: 0000 rrrr gggg bbbb
+	        TUint32 color4K	 = (colors[i].r & 0x0000f0) << 4;
+	        color4K			|= (colors[i].g & 0x0000f0);      
+	        color4K			|= (colors[i].b & 0x0000f0) >> 4;
+            palette[i] = color4K;
+            }
+        }
+    else if(TDisplayModeUtils::NumDisplayModeColors(mode) == 65536)
+        {
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+			// 64k-colour displays effectively support RGB values
+			// with 5 bits allocated to red, 6 to green and 5 to blue
+			// 64k value: rrrr rggg gggb bbbb
+	        TUint32 color64K = (colors[i].r & 0x0000f8) << 8;
+	        color64K		|= (colors[i].g & 0x0000fc) << 3;
+	        color64K		|= (colors[i].b & 0x0000f8) >> 3;
+            palette[i] = color64K;
+            }
+        }
+    else if(TDisplayModeUtils::NumDisplayModeColors(mode) == 16777216)
+        {
+        for(int i = firstcolor; i < ncolors; i++)
+            {
+			// 16M-colour
+            //0000 0000 rrrr rrrr gggg gggg bbbb bbbb
+	        TUint32 color16M = colors[i].r << 16;
+	        color16M		|= colors[i].g << 8;
+	        color16M		|= colors[i].b;
+            palette[i] = color16M;
+            }
+        }
+    else
+        {
+        return -2;
+        }
+    if(EpocSdlEnv::SetPalette(firstcolor, ncolors, palette) == KErrNone)
+    	return 0;
+	return -1;
+	}
+
+
+/*	
+void AllocHWSurfaceL(CFbsBitmap*& aBitmap, const TDisplayMode& aMode, const TSize& aSize)
+	{
+	aBitmap = new (ELeave) CFbsBitmap();	
+	if(KErrNone != aBitmap->CreateHardwareBitmap(aSize, aMode,
+		EpocSdlEnv::EikonEnv().EikAppUi()->Application()->AppDllUid())) 
+	//...if it fails - should we use wsbitmaps???
+		{//the good reason to use hw bitmaps is that they wont need lock heap
+		PANIC_IF_ERROR(aBitmap->Create(aSize, aMode));
+		}
+	}
+	
+int CreateSurfaceL(_THIS, SDL_Surface* surface)
+    {
+    __ASSERT_ALWAYS(Private->iFrame == NULL, PANIC(KErrAlreadyExists));
+;
+	TInt dmode = EColorLast;
+	
+	TDisplayMode displayMode;
+	EpocSdlEnv::GetDiplayMode(displayMode);
+	
+	if(
+	TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode)
+	== surface->format->BitsPerPixel)
+		{
+		dmode = displayMode;
+		}
+	else
+		{
+		--dmode;
+		while(TDisplayModeUtils::IsDisplayModeColor(TDisplayMode(dmode)) &&
+			TDisplayModeUtils::NumDisplayModeBitsPerPixel(TDisplayMode(dmode)) !=
+			surface->format->BitsPerPixel)
+			--dmode;
+		}
+
+	__ASSERT_ALWAYS(TDisplayModeUtils::IsDisplayModeColor(TDisplayMode(dmode)), PANIC(KErrNotSupported));
+	TRAPD(err, AllocHWSurfaceL(Private->iFrame, TDisplayMode(dmode), TSize(surface->w, surface->h)));
+	return err == KErrNone ? 0 : -1;
+    }
+*/
+
+TDisplayMode GetDisplayMode(TInt aBitsPerPixel)
+	{
+	const TDisplayMode displayMode = EpocSdlEnv::DisplayMode();
+	TInt dmode = EColorLast;
+	if(
+	TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode)
+	== aBitsPerPixel)
+		{
+		dmode = displayMode;
+		}
+	else
+		{
+		--dmode;
+		while(TDisplayModeUtils::IsDisplayModeColor(TDisplayMode(dmode)) &&
+			TDisplayModeUtils::NumDisplayModeBitsPerPixel(TDisplayMode(dmode)) !=
+			aBitsPerPixel)
+			--dmode;
+		}
+	return TDisplayMode(dmode);
+	}
+
+SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current,
+				int width, int height, int bpp, Uint32 flags)
+	{
+	const TSize screenSize = EpocSdlEnv::WindowSize(TSize(width, height));
+	if(width > screenSize.iWidth || height > screenSize.iHeight)
+	    {
+	    if(flags & SDL_FULLSCREEN)
+	        {
+	        width = screenSize.iWidth;
+	        height = screenSize.iHeight;
+	        }
+	    else    
+		    return NULL;
+	    }
+
+    if(current && current->pixels)
+    	{
+      //  free(current->pixels);
+        current->pixels = NULL;
+    	}
+    	
+	if(!SDL_ReallocFormat(current, bpp, 0, 0, 0, 0))
+	 	{
+		return(NULL);
+	 	}
+
+	current->flags = 0;
+	if(width == screenSize.iWidth && height == screenSize.iHeight)
+		current->flags |= SDL_FULLSCREEN;
+	
+	const int numBytesPerPixel = ((bpp-1)>>3) + 1;   
+	current->pitch = numBytesPerPixel * width; // Number of bytes in scanline 
+
+    /* Set up the new mode framebuffer */
+   	current->flags |= SDL_PREALLOC;
+   	
+   	if(bpp <= 8)
+   		current->flags |= SDL_HWPALETTE;
+   	
+   	User::Free(Private->iSwSurface);
+   	current->pixels = NULL;
+   	Private->iSwSurface = NULL;
+   	
+   	if(flags & SDL_HWSURFACE)
+   	    {
+   	    current->flags |= SDL_HWSURFACE;
+   	   //	current->pixels = NULL;
+   	   // 	Private->iSwSurface = NULL;
+   	    }
+   	else
+   	    {
+   	    current->flags |= SDL_SWSURFACE;
+   	    const TInt surfacesize = width * height * numBytesPerPixel;  
+   	   	Private->iSwSurfaceSize = TSize(width, height);
+   	   	delete Private->iSwSurface;
+   	   	Private->iSwSurface = NULL;
+   	  	current->pixels = (TUint8*) User::AllocL(surfacesize);
+   	  	Private->iSwSurface = (TUint8*) current->pixels;
+   	  	const TInt err = EpocSdlEnv::AllocSwSurface
+   	  		(TSize(width, height), GetDisplayMode(current->format->BitsPerPixel));
+	    if(err != KErrNone)
+	    	return NULL;
+	    }
+	
+	current->w = width;
+	current->h = height;
+	
+  
+	
+	/* Set the blit function */
+	_this->UpdateRects = EPOC_DirectUpdate;
+
+    /*
+     *  Logic for getting suitable screen dimensions, offset, scaling and orientation
+     */
+
+
+    /* Centralize game window on device screen  */
+   
+    
+    Private->iScreenPos.iX = Max(0, (screenSize.iWidth  - width)  / 2);
+    Private->iScreenPos.iY = Max(0, (screenSize.iHeight - height) / 2);
+    
+ //   delete (Private->iFrame);
+//	Private->iFrame = NULL;
+	
+  //  TRAPD(err, CreateSurfaceL(_this, current));
+  //  PANIC_IF_ERROR(err);
+    
+    SDL_TRACE1("View width %d", width);
+    SDL_TRACE1("View height %d", height);
+    SDL_TRACE1("View bmode %d", bpp);
+    SDL_TRACE1("View x %d", Private->iScreenPos.iX);
+    SDL_TRACE1("View y %d", Private->iScreenPos.iY);
+
+	EpocSdlEnv::LockPalette(EFalse);
+	/* We're done */
+	return(current);
+}
+
+
+
+static int EPOC_AllocHWSurface(_THIS, SDL_Surface* surface)
+	{
+	return KErrNone == EpocSdlEnv::AllocHwSurface(TSize(surface->w, surface->h), GetDisplayMode(surface->format->BitsPerPixel));
+	}
+	
+static void EPOC_FreeHWSurface(_THIS, SDL_Surface* /*surface*/)
+	{
+	}
+
+static int EPOC_LockHWSurface(_THIS, SDL_Surface* surface)
+	{
+	if(EpocSdlEnv::IsDsaAvailable())
+		{
+		TUint8* address = EpocSdlEnv::LockHwSurface();
+		if(address != NULL)
+			{
+			surface->pixels = address;
+			return 1;
+			}
+		}
+	return 0;
+	}
+static void EPOC_UnlockHWSurface(_THIS, SDL_Surface* /*surface*/)
+	{
+	EpocSdlEnv::UnlockHwSurface();
+	}
+
+static int EPOC_FlipHWSurface(_THIS, SDL_Surface* /*surface*/)
+	{
+	return(0);
+	}
+
+static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
+	{
+	if(EpocSdlEnv::IsDsaAvailable())
+		{
+		if(Private->iSwSurface)
+		    {
+		    const TRect target(Private->iScreenPos, Private->iSwSurfaceSize);
+		    for(TInt i = 0; i < numrects ;i++)
+		    	{
+		    	const TRect rect(TPoint(rects[i].x, rects[i].y),
+		    		TSize(rects[i].w, rects[i].h));
+		    	if(!EpocSdlEnv::AddUpdateRect(Private->iSwSurface, rect, target))
+		    		return; //not succesful
+		    	}
+		    EpocSdlEnv::UpdateSwSurface();
+		    }
+		SDL_PauseAudio(0);
+		}
+    else
+    	{                                                      
+     	SDL_PauseAudio(1);
+    	EpocSdlEnv::WaitDsaAvailable();              
+		}
+	}
+
+
+/* Note:  If we are terminated, this could be called in the middle of
+   another SDL video routine -- notably UpdateRects.
+*/
+void EPOC_VideoQuit(_THIS)
+	{
+//	delete Private->iFrame;
+//	Private->iFrame = NULL;
+	User::Free(Private->iSwSurface);
+	Private->iSwSurface = NULL;
+	EpocSdlEnv::FreeSurface();
+	}
+	
+	
+
+
+WMcursor *EPOC_CreateWMCursor(_THIS, Uint8* /*data*/, Uint8* /*mask*/, int /*w*/, int /*h*/, int /*hot_x*/, int /*hot_y*/)
+    {
+    return (WMcursor*) 1; //hii! prevents SDL to view a std cursor
+    }
+
+void EPOC_FreeWMCursor(_THIS, WMcursor* /*cursor*/)
+    {
+    }
+
+int EPOC_ShowWMCursor(_THIS, WMcursor *cursor)
+    {
+    return true;  
+    }
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA2/SDL_epocvideo.h	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,51 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifndef EPOCVIDEO_H
+#define EPOCVIDEO_H
+
+#include<w32std.h>
+
+/* Hidden "this" pointer for the video functions */
+#define _THIS	SDL_VideoDevice *_this
+#define Private	_this->hidden
+
+class CFbsBitmap;
+
+struct SDL_VideoDevice;
+void DisableKeyBlocking(SDL_VideoDevice*);
+
+struct SDL_PrivateVideoData 
+    {
+    TPoint					iScreenPos;
+    TBool                   iIsWindowFocused;
+    TSize                   iSwSurfaceSize;
+    TUint8*                 iSwSurface;
+    SDL_Rect				iRect; //same info in SDL format
+    SDL_Rect* 				iRectPtr;
+    };
+    
+#endif    
+
+
+
+    
\ No newline at end of file
--- /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
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/symbian/EKA2/dsa_new.cpp	Sun Jun 24 18:26:35 2007 +0000
@@ -0,0 +1,1443 @@
+#include "dsa.h"
+#include "sdlepocapi.h"
+#include <cdsb.h>
+
+
+LOCAL_C TInt BytesPerPixel(TDisplayMode aMode)
+	{
+	return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1; 
+	}
+
+
+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 CDsa
+	{
+	public:
+		CDsaA(RWsSession& aSession);
+	private:
+		~CDsaA();
+		TUint8* LockSurface();
+		void UnlockHWSurfaceRequestComplete();
+		void UnlockHwSurface();
+		void CreateSurfaceL();
+		void Wipe(TInt aLength);
+		void Free();
+		void Update(CFbsBitmap& aBmp);
+		void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
+		TInt ExternalUpdate();
+	//	void ExternalUpdate();
+	protected:
+		CFbsBitmap* iBmp;
+		CFbsBitmap* iCopyBmp;
+	};
+	
+	
+CDsaA::CDsaA(RWsSession& aSession) : CDsa(aSession)
+	{
+	}
+	
+	
+void CDsaA::Free()
+	{
+	delete iBmp;
+	iBmp = NULL;
+	}
+
+CDsaA::~CDsaA()
+	{
+	__ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));
+	delete iCopyBmp;
+	}
+	
+TUint8* CDsaA::LockSurface()
+	{
+	iBmp->LockHeap();
+	return reinterpret_cast<TUint8*>(iBmp->DataAddress());
+	}
+
+void CDsaA::UnlockHWSurfaceRequestComplete()
+	{
+	PANIC(KErrNotSupported);
+	}
+
+void CDsaA::UnlockHwSurface()
+	{
+	iBmp->UnlockHeap();
+	SetUpdating(EFalse);
+	Update(*iBmp);
+	}
+	
+void CDsaA::Update(CFbsBitmap& aBmp)
+	{
+	if(!Blitter(aBmp))
+		{
+		if(SwSize() == HwRect().Size())
+			Dsa().Gc()->BitBlt(HwRect().iTl, &aBmp);
+		else
+			Dsa().Gc()->DrawBitmap(HwRect(), &aBmp);
+		}
+	DrawOverlays();
+	Dsa().ScreenDevice()->Update();	
+	}
+void CDsaA::CreateSurfaceL()
+	{
+	delete iBmp;
+	iBmp = NULL;
+	iBmp  = new (ELeave) CFbsBitmap();
+	User::LeaveIfError(iBmp->Create(SwSize(), DisplayMode()));
+	}
+
+void CDsaA::Wipe(TInt aLength) //dont call in drawing
+	{
+	iBmp->LockHeap();
+	Mem::FillZ(iBmp->DataAddress(), aLength);
+	iBmp->UnlockHeap();
+	}
+	
+
+		
+TInt CDsaA::ExternalUpdate()
+	{
+	if(iCopyBmp->Handle() == 0)
+		{
+		const TInt err = iCopyBmp->Duplicate(iBmp->Handle());
+		if(err != KErrNone)
+			return err;
+		}
+	Update(*iCopyBmp);
+	return KErrNone;
+	}
+	
+void CDsaA::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)		
+	{
+	iCopyBmp = new (ELeave) CFbsBitmap();
+	CDsa::ConstructL(aWindow, aDevice);
+	}
+	
+	
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+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 CDsa, 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) : CDsa(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();	
+	CDsa::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::EDrawModeDSBIncrentalUpdate))
+			flags |= CDirectScreenBitmap::EIncrementalUpdate;
+		return new (ELeave) CDsaB(aSession, flags);
+		}
+    else
+        return new (ELeave) 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::ReleaseStop()
+	{
+	iStateFlags &= ~ESdlThreadExplicitStop;
+	}
+
+
+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()
+    {
+    if(iDsa != NULL)
+        {
+        iDsa->Cancel();
+        }
+    iOverlays.Close();
+    delete iDsa;
+    User::Free(iLut256);
+    }
+         
+void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
+    {
+    if(iDsa != NULL)
+    	{
+    	iDsa->Cancel();
+    	delete iDsa;
+    	iDsa = NULL;
+    	}
+    	
+    iDsa = CDirectScreenAccess::NewL(
+    				iSession,
+					aDevice,
+					aWindow,
+					*this);				
+
+	if(iLut256 == NULL)
+		iLut256 = (TUint32*) User::AllocL(256 * sizeof(TUint32));
+	iTargetMode = aWindow.DisplayMode();
+	iTargetBpp = BytesPerPixel(DisplayMode());
+	iScreenRect = TRect(aWindow.Position(), aWindow.Size());
+	SetTargetRect();
+    RestartL();
+    }
+    
+void CDsa::DrawOverlays()
+	{
+	const TInt last = iOverlays.Count() - 1;
+	for(TInt i = last; i >= 0 ; i--)
+		iOverlays[i].iOverlay->Draw(*iDsa->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;
+	}
+	
+	
+
+void CDsa::RestartL()
+    {
+    //const TBool active = iDsa->IsActive();
+    
+    //if(!active)
+    
+    iDsa->StartL();	
+    
+    const RRegion* r = iDsa->DrawingRegion();
+    const TRect rect = r->BoundingRect();
+    iDsa->Gc()->SetClippingRegion(r);	
+   
+    if(rect != iScreenRect)
+    	{
+    //	iDsa->Cancel();
+    	return ;	
+   	 	}
+   	 	
+     
+    	
+    //iScreenRect = rect; //to ensure properly set, albeit may not(?) match to value SDL has - therefore may has to clip
+	//targetrect shall no change
+	SetTargetRect();
+	RecreateL();
+
+    iStateFlags |= ERunning;
+    
+    ReleaseStop();
+    if(iStateFlags & ESdlThreadSuspend)
+    	{
+    	EpocSdlEnv::Resume();
+    	iStateFlags &= ~ ESdlThreadSuspend;
+    	}	
+    EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);	
+    }
+    
+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 ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TPoint& aTargetPos)
+	{
+	const TInt iSourceBpp = 1;
+	const TInt iTargetBpp = 4;
+	const TInt iScanLineWidth = 800; 
+	
+	TUint8* target = aTarget;
+	const TUint8* source = aSource;
+	const TInt lineWidth = aRect.Width();
+	source += iSourceBpp * (aRect.iTl.iY * lineWidth); 
+	const TInt sourceStartOffset = iSourceBpp *  aRect.iTl.iX;
+	source += sourceStartOffset;
+	target += iTargetBpp * ((aTargetPos.iY + aRect.iTl.iY ) * lineWidth); 
+	const TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iX);
+	target += targetStartOffset;
+	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);
+	const TInt targetWidth = iScanLineWidth >> 2;
+	const TInt height = aRect.Height(); 
+	}	
+*/
+/*
+void CDsa::ClipCopy(TUint8* aTarget,
+ 					const TUint8* aSource,
+ 					const TRect& aUpdateRect,
+ 					const TRect& aSourceRect) const
+	{
+	//TUint8* target = aTarget;
+	const TUint32* source = (const TUint32*) aSource;
+	const TInt lineWidth = aSourceRect.Width();
+	
+	source +=  (aUpdateRect.iTl.iY * lineWidth); 
+	const TInt sourceStartOffset =   aUpdateRect.iTl.iX;
+	source += sourceStartOffset;
+	
+	TUint32* targetPtr = reinterpret_cast<TUint32*>(aTarget);
+	
+	targetPtr +=  (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * SwSize().iWidth; 
+	const TInt targetStartOffset =  (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);
+	
+	targetPtr += targetStartOffset;
+	
+//	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);
+	
+	const TInt targetWidth32 = SwSize().iWidth;
+	
+	const TInt height = aUpdateRect.Height(); 
+		
+	const TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth;
+	const TInt copyLen = aUpdateRect.Width();
+	
+	
+	if(iStateFlags & EOrientation180)
+		{
+		
+		targetPtr += targetWidth32 *  (height - 1);
+	
+		for(TInt i = 0; i < height; i++) //source is always smaller
+			{
+			iCopyFunction(*this, targetPtr, (TUint8*)source, copyLen, height);
+			source += lineMove;
+			targetPtr -= targetWidth32;
+			}
+		}
+	else
+		{
+		
+		
+		for(TInt i = 0; i < height; i++) //source is always smaller
+			{
+			iCopyFunction(*this, targetPtr, (TUint8*)source, copyLen, height);
+			source += lineMove;
+			targetPtr += targetWidth32; // >> 2;
+			}
+		}
+
+	}
+	
+*/
+
+void CDsa::ClipCopy(TUint8* aTarget, const TUint8* aSource, const TRect& aRect, const TPoint& aTargetPos) const
+	{
+	TUint8* target = aTarget;
+	const TUint8* source = aSource;
+	const TInt lineWidth = aRect.Width();
+	source += iSourceBpp * (aRect.iTl.iY * lineWidth); 
+	TInt sourceStartOffset = iSourceBpp *  aRect.iTl.iX;
+	source += sourceStartOffset;
+	target += iTargetBpp * ((aTargetPos.iY + aRect.iTl.iY ) * lineWidth); 
+	TInt targetStartOffset = iTargetBpp * (aRect.iTl.iX + aTargetPos.iX);
+	target += targetStartOffset;
+	TUint32* targetPtr = reinterpret_cast<TUint32*>(target);
+	const TInt targetWidth = iScanLineWidth >> 2;
+	const TInt height = aRect.Height(); 
+	
+	TInt lineMove = iStateFlags & EOrientation90 ? 1 : lineWidth;
+	
+	if(iStateFlags & EOrientation180)
+		{
+		
+		targetPtr += targetWidth *  (height - 1);
+	
+		for(TInt i = 0; i < height; i++) //source is always smaller
+			{
+			iCopyFunction(*this, targetPtr, source, lineWidth, height);
+			source += lineMove;
+			targetPtr -= targetWidth;
+			}
+		}
+	else
+		{
+		
+		
+		for(TInt i = 0; i < height; i++) //source is always smaller
+			{
+			iCopyFunction(*this, targetPtr, source, lineWidth, height);
+			source += lineMove;
+			targetPtr += targetWidth;
+			}
+		}
+
+	}
+	
+		
+	
+	/*
+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;
+	}
+	*/
+	
+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 = Rect();
+	TRect sourceRect = aRect;
+	TRect updateRect = aUpdateRect;
+	
+	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.iTl);
+		}
+	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::Resume()	
+	{
+	if(Stopped())
+		Restart(RDirectScreenAccess::ETerminateRegion);
+	}
+	
+void CDsa::DoStop()
+	{
+	if(IsDsaAvailable())
+		iStateFlags |= ESdlThreadExplicitStop;
+	Stop();
+	}
+	
+void CDsa::Stop()
+	{
+	iStateFlags &= ~ERunning;
+//	Cancel(); //can be called only from main!
+	iDsa->Cancel();
+	}
+	
+void CDsa::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
+	{
+//	iStateFlags |= EChangeNotify;
+	Stop();
+	}
+	
+void CDsa::Restart(RDirectScreenAccess::TTerminationReasons aReason)
+	{
+	if(aReason == RDirectScreenAccess::ETerminateRegion) //auto restart
+		{												
+		TRAPD(err, RestartL());
+		PANIC_IF_ERROR(err);
+		}
+	}
+	
+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();
+//	iScanLineWidth = /*iTargetBpp **/ SwSize().iWidth;
+	}
+		
+/*)
+TBool CDsa::ChangeTrigger()
+	{
+	const TBool change = iStateFlags & EChangeNotify;
+	iStateFlags &= ~EChangeNotify;
+	return change;
+	}
+*/	
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+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)