src/video/symbian/SDL_epocvideo.cpp

   1 /*
   2    SDL - Simple DirectMedia Layer
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 of the License, or (at your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with this library; if not, write to the Free
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19    Sam Lantinga
  20    slouken@devolution.com
  21    */
  22
  23 #include "epoc_sdl.h"
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 extern "C" {
  29 #include "SDL_error.h"
  30 #include "SDL_timer.h"
  31 #include "SDL_video.h"
  32 #undef NULL
  33 #include "SDL_pixels_c.h"
  34 #include "SDL.h"
  35 #include "SDL_mouse.h"
  36 }
  37
  38 #include "SDL_epocvideo.h"
  39 #include "SDL_epocevents_c.h"
  40 #include <coedef.h>
  41 #include <flogger.h>
  42 #include <eikenv.h>
  43 #include <eikappui.h>
  44 #include <eikapp.h>
  45 #include "sdlepocapi.h"
  46 #include <SDL_gliop.h>
  47 #include <egl.h>
  48 #include "gles_armv5_def.h"
  49
  50 _LIT(KLibName, "SDL");
  51
  52 extern "C" {
  53
  54         /* Initialization/Query functions */
  55
  56         static int S60_VideoInit(_THIS, SDL_PixelFormat *vformat);
  57         static SDL_Rect **S60_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  58         static SDL_Surface *S60_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  59         static int S60_SetColors(_THIS, int firstcolor, int ncolors,
  60                         SDL_Color *colors);
  61         static void S60_VideoQuit(_THIS);
  62
  63         /* Hardware surface functions */
  64
  65         static int S60_AllocHWSurface(_THIS, SDL_Surface *surface);
  66         static int S60_LockHWSurface(_THIS, SDL_Surface *surface);
  67         static int S60_FlipHWSurface(_THIS, SDL_Surface *surface);
  68         static void S60_UnlockHWSurface(_THIS, SDL_Surface *surface);
  69         static void S60_FreeHWSurface(_THIS, SDL_Surface *surface);
  70         static void S60_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
  71
  72         static int S60_Available(void);
  73         static SDL_VideoDevice *S60_CreateDevice(int devindex);
  74
  75         /* Mouse functions */
  76         static WMcursor *S60_CreateWMCursor(_THIS, Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
  77         static void S60_FreeWMCursor(_THIS, WMcursor *cursor);
  78         static int S60_ShowWMCursor(_THIS, WMcursor *cursor);
  79
  80         /*GL Functions*/
  81         static int S60_GlesLoadLibrary(_THIS, const char* path);
  82         static void* S60_GlesGetProcAddress(_THIS, const char *proc);
  83         static int S60_GlesGetAttribute(_THIS, SDL_GLattr attrib, int* value);
  84         static int S60_GlesMakeCurrent(_THIS);
  85         static void S60_GlesSwapBuffers(_THIS);
  86 }
  87
  88 extern "C"
  89 {
  90         struct WMcursor
  91         {
  92         };
  93 }
  94
  95 static TSize GetScreenSize()
  96 {
  97         CWsScreenDevice *sd = new CWsScreenDevice(CEikonEnv::Static()->WsSession());
  98         sd->Construct();
  99         const TSize sz(sd->SizeInPixels());
 100         delete sd;
 101
 102         return sz;
 103 }
 104
 105 /* Epoc video driver bootstrap functions */
 106 static int S60_Available(void)
 107 {
 108         return 1; /* Always available */
 109 }
 110
 111 static void S60_DeleteDevice(SDL_VideoDevice *device)
 112 {
 113         delete device->gl_data;
 114         delete device->hidden;
 115         delete device;
 116 }
 117
 118 static SDL_VideoDevice *S60_CreateDevice(int /*devindex*/)
 119 {
 120         SDL_VideoDevice *device;
 121
 122         /* Allocate all variables that we free on delete */
 123         device = new SDL_VideoDevice;
 124         if (device)
 125         {
 126                 Mem::FillZ(device, (sizeof *device));
 127                 device->hidden = new SDL_PrivateVideoData;
 128                 device->gl_data = new SDL_PrivateGLData;
 129         }
 130         else
 131         {
 132                 SDL_OutOfMemory();
 133                 return 0;
 134         }
 135         if((device->hidden == NULL) || (device->gl_data == NULL))
 136         {
 137                 SDL_OutOfMemory();
 138                 delete device->hidden;
 139                 delete device->gl_data;
 140                 delete device;
 141                 return 0;
 142         }
 143
 144         Mem::FillZ(device->hidden, (sizeof *device->hidden));
 145
 146         /* Set the function pointers */
 147         device->VideoInit = S60_VideoInit;
 148         device->ListModes = S60_ListModes;
 149         device->SetVideoMode = S60_SetVideoMode;
 150         device->SetColors = S60_SetColors;
 151         device->UpdateRects = NULL;
 152         device->VideoQuit = S60_VideoQuit;
 153         device->AllocHWSurface = S60_AllocHWSurface;
 154         device->CheckHWBlit = NULL;
 155         device->FillHWRect = NULL;
 156         device->SetHWColorKey = NULL;
 157         device->SetHWAlpha = NULL;
 158         device->LockHWSurface = S60_LockHWSurface;
 159         device->UnlockHWSurface = S60_UnlockHWSurface;
 160         device->FlipHWSurface = S60_FlipHWSurface;
 161         device->FreeHWSurface = S60_FreeHWSurface;
 162         device->SetIcon = NULL;
 163         device->SetCaption = NULL;
 164         device->GetWMInfo = NULL;
 165         device->FreeWMCursor = S60_FreeWMCursor;
 166         device->CreateWMCursor = S60_CreateWMCursor;
 167         device->ShowWMCursor = S60_ShowWMCursor;
 168         device->WarpWMCursor = NULL;
 169         device->InitOSKeymap = EPOC_InitOSKeymap;
 170         device->PumpEvents = EPOC_PumpEvents;
 171         device->free = S60_DeleteDevice;
 172
 173         /*gles funtions*/
 174         device->GL_LoadLibrary          = S60_GlesLoadLibrary;
 175         device->GL_GetProcAddress       = S60_GlesGetProcAddress;
 176         device->GL_GetAttribute         = S60_GlesGetAttribute;
 177         device->GL_MakeCurrent          = S60_GlesMakeCurrent;
 178         device->GL_SwapBuffers          = S60_GlesSwapBuffers;
 179
 180         device->gl_data->iLibrary.SetHandle(0);
 181
 182         return device;
 183 }
 184
 185 VideoBootStrap EPOC_bootstrap = {
 186         "epoc\0\0\0", "EPOC system",
 187         S60_Available, S60_CreateDevice
 188 };
 189
 190 int S60_VideoInit(_THIS, SDL_PixelFormat *vformat)
 191 {
 192         /* Initialise Epoc frame buffer */
 193
 194         const TDisplayMode displayMode = EpocSdlEnv::DisplayMode();
 195
 196         /* The "best" video format should be returned to caller. */
 197
 198         vformat->BitsPerPixel   = TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode);
 199         vformat->BytesPerPixel  = TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode) / 8;
 200
 201         Private->iRect = new SDL_Rect*[3];
 202         Private->iRect[0] = new SDL_Rect;
 203         Private->iRect[1] = new SDL_Rect;
 204         Private->iRect[2] = NULL;
 205
 206         Private->iScreenPos = TPoint(0, 0);
 207
 208         Private->iRect[0]->x = Private->iScreenPos.iX;
 209         Private->iRect[0]->y = Private->iScreenPos.iY;
 210
 211         Private->iRect[1]->x = Private->iScreenPos.iX;
 212         Private->iRect[1]->y = Private->iScreenPos.iY;
 213
 214         const TSize sz = GetScreenSize();
 215
 216         Private->iRect[0]->w = sz.iWidth;
 217         Private->iRect[0]->h = sz.iHeight;
 218
 219         Private->iRect[1]->w = sz.iHeight;
 220         Private->iRect[1]->h = sz.iWidth;
 221
 222         Private->iOrientation = new CAknAppUi::TAppUiOrientation[2];
 223
 224         if(sz.iWidth < sz.iHeight)
 225         {
 226                 Private->iOrientation[0] = CAknAppUi::EAppUiOrientationPortrait;
 227                 Private->iOrientation[1] = CAknAppUi::EAppUiOrientationLandscape;
 228         }
 229         else
 230         {
 231                 Private->iOrientation[0] = CAknAppUi::EAppUiOrientationLandscape;
 232                 Private->iOrientation[1] = CAknAppUi::EAppUiOrientationPortrait;
 233         }
 234
 235         return(0);
 236 }
 237
 238 SDL_Rect **S60_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
 239 {
 240         if(flags & SDL_HWSURFACE)
 241         {
 242                 if(format->BytesPerPixel != 4) //in HW only full color is supported
 243                         return NULL;
 244         }
 245         if(flags & SDL_FULLSCREEN)
 246         {
 247                 return Private->iRect;
 248         }
 249
 250         return (SDL_Rect **)(-1); //everythingisok, but too small shoes
 251 }
 252
 253 int S60_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
 254 {
 255         if ((firstcolor+ncolors) > 256)
 256                 return -1;
 257         TUint32 palette[256];
 258         const TDisplayMode mode = EpocSdlEnv::DisplayMode();
 259         int c = 0;
 260
 261         if(TDisplayModeUtils::NumDisplayModeColors(mode) == 4096)
 262         {
 263                 // Set 12 bit palette
 264                 for(int i = firstcolor; i < firstcolor+ncolors; i++)
 265                 {
 266                         // 4k value: 0000 rrrr gggg bbbb
 267                         TUint32 color4K  = (colors[c].r & 0x0000f0) << 4;
 268                         color4K                 |= (colors[c].g & 0x0000f0);
 269                         color4K                 |= (colors[c].b & 0x0000f0) >> 4;
 270                         palette[i] = color4K;
 271                         c++;
 272                 }
 273         }
 274         else if(TDisplayModeUtils::NumDisplayModeColors(mode) == 65536)
 275         {
 276                 for(int i = firstcolor; i < firstcolor+ncolors; i++)
 277                 {
 278                         // 64k-colour displays effectively support RGB values
 279                         // with 5 bits allocated to red, 6 to green and 5 to blue
 280                         // 64k value: rrrr rggg gggb bbbb
 281                         TUint32 color64K = (colors[c].r & 0x0000f8) << 8;
 282                         color64K                |= (colors[c].g & 0x0000fc) << 3;
 283                         color64K                |= (colors[c].b & 0x0000f8) >> 3;
 284                         palette[i] = color64K;
 285                         c++;
 286                 }
 287         }
 288         else if(TDisplayModeUtils::NumDisplayModeColors(mode) == 16777216)
 289         {
 290                 for(int i = firstcolor; i < firstcolor+ncolors; i++)
 291                 {
 292                         // 16M-colour
 293                         //0000 0000 rrrr rrrr gggg gggg bbbb bbbb
 294                         TUint32 color16M = colors[c].r << 16;
 295                         color16M                |= colors[c].g << 8;
 296                         color16M                |= colors[c].b;
 297                         palette[i] = color16M;
 298                         c++;
 299                 }
 300         }
 301         else
 302         {
 303                 return -2;
 304         }
 305         if(EpocSdlEnv::SetPalette(firstcolor, ncolors, palette) == KErrNone)
 306         {
 307                 // palette has been updated, redraw whole screen to include changes
 308                 EpocSdlEnv::UpdateWholeScreen(true);
 309
 310                 return 0;
 311         }
 312         return -1;
 313 }
 314
 315 int S60_GlesLoadLibrary(SDL_VideoDevice* _this, const char* path)
 316 {
 317         if(_this->gl_data->iLibrary.Handle() != 0)
 318                 return KErrAlreadyExists; //already loaded
 319         const char* const gles_lib[] = {"libgles_cm.dll", "libSWGLES.dll"};
 320         int err = KErrNotFound;
 321         for(int i = 0; i < 2 && err != KErrNone; i++)
 322         {
 323                 const char* name8 = path == NULL ? gles_lib[i] : path;
 324                 TFileName lib;
 325                 lib.Copy(TPtrC8((unsigned char*)name8));
 326                 err = _this->gl_data->iLibrary.Load(lib);
 327         }
 328         if(err == KErrNone)
 329                 _this->gl_config.driver_loaded = 1;
 330         return err;
 331 }
 332
 333 typedef int (*Ftp)(...);
 334 #define DC(x) ((Ftp) S60_GlesGetProcAddress(_this, #x))
 335
 336 const char* const OpenGL[] = //these funtions are in gl, but not in gles, at least in all in all versions...
 337 {
 338         "glBegin",
 339         "glEnd",
 340         "glOrtho",
 341         "glPopAttrib",
 342         "glPopClientAttrib",
 343         "glPushAttrib",
 344         "glPushClientAttrib",
 345         "glTexCoord2f",
 346         "glVertex2i",
 347         "glTexParameteri"
 348 };
 349
 350 int NotSupported()
 351 {
 352         User::Panic(_L("SDL, Gles"), KErrNotSupported);
 353         return 0;
 354 }
 355
 356 void* S60_GlesGetProcAddress(_THIS, const char *proc)
 357 {
 358         if(_this->gl_data->iLibrary.Handle() == 0)
 359                 return NULL; //not loaded
 360         TLibraryFunction f = NULL;
 361         for(int i = 0; i < G_ordinals_count; i++)
 362         {
 363                 if(strcmp(G_ordinals[i].name, proc) == 0)
 364                 {
 365                         f = _this->gl_data->iLibrary.Lookup(G_ordinals[i].ord);
 366                         break;
 367                 }
 368         }
 369
 370         if(f != NULL) /*Lookup may fail*/
 371                 return  (void*) f;
 372
 373         for(int i = 0; i < sizeof(OpenGL) / sizeof(char*); i++)
 374         {
 375                 if(strcmp(OpenGL[i], proc) == 0)
 376                         return (void*) NotSupported;
 377         }
 378
 379         return NULL;
 380 }
 381
 382 int S60_GlesGetAttribute(_THIS, SDL_GLattr aAttrib, int* aValue)
 383 {
 384         EGLint attrib;
 385         switch(aAttrib)
 386         {
 387                 /*todo*/
 388                 case SDL_GL_RED_SIZE: attrib = EGL_RED_SIZE; break;
 389                 case SDL_GL_GREEN_SIZE: attrib = EGL_GREEN_SIZE; break;
 390                 case SDL_GL_BLUE_SIZE:attrib = EGL_BLUE_SIZE; break;
 391                 case SDL_GL_ALPHA_SIZE: attrib = EGL_ALPHA_SIZE; break;
 392                 case SDL_GL_BUFFER_SIZE: attrib = EGL_BUFFER_SIZE; break;
 393                 case SDL_GL_DOUBLEBUFFER: *aValue = 1; return 0; //always
 394                 case SDL_GL_DEPTH_SIZE: attrib = EGL_DEPTH_SIZE; break;
 395                 case SDL_GL_STENCIL_SIZE: attrib = EGL_STENCIL_SIZE; break;
 396                 case SDL_GL_ACCUM_RED_SIZE:
 397                 case SDL_GL_ACCUM_GREEN_SIZE:
 398                 case SDL_GL_ACCUM_BLUE_SIZE:
 399                 case SDL_GL_ACCUM_ALPHA_SIZE:
 400                 case SDL_GL_STEREO:
 401                 case SDL_GL_MULTISAMPLEBUFFERS:
 402                 case SDL_GL_MULTISAMPLESAMPLES:
 403                 case SDL_GL_ACCELERATED_VISUAL:
 404                 case SDL_GL_SWAP_CONTROL:
 405                                           *aValue = 0;
 406                                           return -1;
 407         }
 408         const int success = DC(eglGetConfigAttrib)
 409                 (
 410                  _this->gl_data->iDisplay,
 411                  _this->gl_data->iConfig,
 412                  attrib,
 413                  aValue);
 414         return success == EGL_FALSE ? -1 : 0;
 415 }
 416
 417
 418 int S60_GlesMakeCurrent(_THIS)
 419 {
 420         DC(eglMakeCurrent)
 421                 (_this->gl_data->iDisplay,
 422                  _this->gl_data->iSurface,
 423                  _this->gl_data->iSurface,
 424                  _this->gl_data->iContext);
 425         return DC(eglGetError)();
 426 }
 427
 428 void S60_GlesSwapBuffers(_THIS)
 429 {
 430         DC(eglSwapBuffers)(
 431                         _this->gl_data->iDisplay,
 432                         _this->gl_data->iSurface);
 433 }
 434
 435 TDisplayMode GetDisplayMode(int aBitsPerPixel)
 436 {
 437         const TDisplayMode displayMode = EpocSdlEnv::DisplayMode();
 438         int dmode = EColorLast;
 439         if(TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode) == aBitsPerPixel)
 440         {
 441                 dmode = displayMode;
 442         }
 443         else
 444         {
 445                 do
 446                 {
 447                         --dmode;
 448                 }
 449                 while(TDisplayModeUtils::IsDisplayModeColor(TDisplayMode(dmode)) &&
 450                         TDisplayModeUtils::NumDisplayModeBitsPerPixel(TDisplayMode(dmode)) != aBitsPerPixel);
 451         }
 452         return TDisplayMode(dmode);
 453 }
 454
 455
 456 static void glAssert(_THIS)
 457 {
 458         const EGLint err = DC(eglGetError)();
 459         if(err != EGL_SUCCESS)
 460         {
 461                 User::Leave(err);
 462         }
 463 }
 464
 465 static void CreateGles(_THIS, RWindow& aWindow, int bpp, SDL_PrivateGLData& aData)
 466 {
 467         SDL_GL_LoadLibrary(NULL); //just if its not already loaded
 468         aData.iDisplay = DC(eglGetDisplay)(EGL_DEFAULT_DISPLAY);
 469         DC(eglInitialize)(aData.iDisplay, NULL, NULL);
 470
 471         glAssert(_this);
 472
 473         int configs = 0;
 474         EGLConfig* configList = NULL;
 475         int configSz = 0;
 476         DC(eglGetConfigs)(aData.iDisplay, configList, configSz, &configs);
 477         configSz = configs;
 478
 479         glAssert(_this);
 480
 481         configList = new EGLConfig[configSz];
 482
 483         int red, green, blue;
 484         if(bpp == 16)
 485         {
 486                 red = 5;
 487                 green = 6;
 488                 blue = 5;
 489         }
 490         else
 491         {
 492                 red = 8;
 493                 green = 8;
 494                 blue = 8;
 495         }
 496
 497         const EGLint attribList[] =
 498         {
 499                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 500                 EGL_RED_SIZE, red,
 501                 EGL_GREEN_SIZE, green,
 502                 EGL_BLUE_SIZE, blue,
 503                 EGL_BUFFER_SIZE, EGL_DONT_CARE,
 504                 EGL_DEPTH_SIZE, 8,
 505                 EGL_NONE
 506         };
 507
 508         DC(eglChooseConfig)(aData.iDisplay,
 509                         attribList,
 510                         configList,
 511                         configSz,
 512                         &configs);
 513
 514
 515         glAssert(_this);
 516
 517         __ASSERT_ALWAYS(configs > 0, User::Invariant());
 518
 519         aData.iConfig = configList[0];
 520
 521         delete[] configList;
 522
 523         aData.iContext = DC(eglCreateContext)(aData.iDisplay,
 524                         aData.iConfig,
 525                         EGL_NO_CONTEXT,
 526                         NULL);
 527
 528         glAssert(_this);
 529
 530         aData.iSurface  = DC(eglCreateWindowSurface)(aData.iDisplay,
 531                         aData.iConfig,
 532                         &aWindow,
 533                         NULL);
 534
 535         glAssert(_this);
 536
 537 }
 538
 539 static void DestroyGles(_THIS)
 540 {
 541         if(     _this->gl_config.driver_loaded)
 542         {
 543                 DC(eglMakeCurrent)(_this->gl_data->iDisplay,
 544                                 EGL_NO_SURFACE,
 545                                 EGL_NO_SURFACE,
 546                                 EGL_NO_CONTEXT);
 547                 DC(eglDestroySurface)(_this->gl_data->iDisplay, _this->gl_data->iSurface);
 548                 DC(eglDestroyContext)(_this->gl_data->iDisplay, _this->gl_data->iContext);
 549                 DC(eglTerminate)(_this->gl_data->iDisplay);
 550                 _this->gl_data->iLibrary.Close();
 551                 _this->gl_config.driver_loaded = 0;
 552         }
 553 }
 554
 555 SDL_Surface *S60_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
 556 {
 557         if(flags & SDL_OPENGL)
 558         {
 559                 current->flags |= SDL_OPENGL;
 560                 current->w = width;
 561                 current->h = height;
 562
 563                 RWindow* win = EpocSdlEnv::Window();
 564                 EpocSdlEnv::ApplyGlesDsa();
 565
 566                 CreateGles(_this, *win, bpp, *_this->gl_data);
 567
 568                 return current;
 569         }
 570
 571         if(flags & SDL_HWSURFACE)
 572                 return NULL;
 573
 574         // check orientation and resolution validity
 575         bool resValid = false;
 576         Orientation orientation = CAknAppUi::EAppUiOrientationUnspecified;
 577         for(int i=0; i<2; i++)
 578         {
 579                 if(width <= Private->iRect[i]->w && height <= Private->iRect[i]->h)
 580                 {
 581                         orientation = Private->iOrientation[i];
 582                         resValid = true;
 583                         break;
 584                 }
 585         }
 586         if(!resValid)
 587                 return NULL;
 588
 589         if(!SDL_ReallocFormat(current, bpp, 0, 0, 0, 0))
 590                 return NULL;
 591
 592         const int numBytesPerPixel = ((bpp-1)>>3) + 1;
 593         current->pitch = numBytesPerPixel * width;
 594
 595         // set proper surface flags
 596         current->flags = SDL_SWSURFACE | SDL_PREALLOC;
 597         if(flags & SDL_FULLSCREEN)
 598                 current->flags |= SDL_FULLSCREEN;
 599         if(flags & SDL_RESIZABLE)
 600                 current->flags |= SDL_RESIZABLE;
 601         if(bpp <= 8)
 602                 current->flags |= SDL_HWPALETTE;
 603
 604         current->w = width;
 605         current->h = height;
 606
 607         // allocate surface
 608         const int surfacesize = width * height * numBytesPerPixel;
 609         Private->iSwSurfaceSize = TSize(width, height);
 610
 611         delete[] (TUint8*)current->pixels;
 612         current->pixels = new TUint8[surfacesize];
 613         Private->iSwSurface = (TUint8*) current->pixels;
 614
 615         if(current->pixels == NULL)
 616                 return NULL;
 617
 618         const TSize sz = GetScreenSize();
 619
 620         if(sz.iWidth < sz.iHeight && orientation != CAknAppUi::EAppUiOrientationPortrait ||
 621            sz.iWidth > sz.iHeight && orientation != CAknAppUi::EAppUiOrientationLandscape)
 622         {
 623                 EpocSdlEnv::SetOrientation(orientation, TSize(width, height), GetDisplayMode(current->format->BitsPerPixel));
 624         }
 625         else
 626         {
 627                 if((flags & SDL_RESIZABLE) == 0)
 628                 {
 629                         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 630                 }
 631                 else
 632                 {
 633                         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(CAknAppUi::EAppUiOrientationUnspecified));
 634                 }
 635
 636                 const int err = EpocSdlEnv::AllocSurface(TSize(width, height), GetDisplayMode(current->format->BitsPerPixel));
 637                 if(err != KErrNone)
 638                         return NULL;
 639         }
 640
 641         // Set the blit function
 642         _this->UpdateRects = S60_DirectUpdate;
 643
 644         // Centralize game window on device screen
 645         Private->iScreenPos.iX = 0;
 646         Private->iScreenPos.iY = 0;
 647
 648         return current;
 649 }
 650
 651 static int S60_AllocHWSurface(_THIS, SDL_Surface* surface)
 652 {
 653         return KErrNone == EpocSdlEnv::AllocSurface(TSize(surface->w, surface->h), GetDisplayMode(surface->format->BitsPerPixel));
 654 }
 655
 656 static void S60_FreeHWSurface(_THIS, SDL_Surface* /*surface*/)
 657 {
 658 }
 659
 660 static int S60_LockHWSurface(_THIS, SDL_Surface* surface)
 661 {
 662         if(EpocSdlEnv::IsDsaAvailable())
 663         {
 664                 TUint8* address = EpocSdlEnv::LockHwSurface();
 665                 if(address != NULL)
 666                 {
 667                         surface->pixels = address;
 668                         return 1;
 669                 }
 670         }
 671         return 0;
 672 }
 673 static void S60_UnlockHWSurface(_THIS, SDL_Surface* /*surface*/)
 674 {
 675         EpocSdlEnv::UnlockHwSurface();
 676 }
 677
 678 static int S60_FlipHWSurface(_THIS, SDL_Surface* /*surface*/)
 679 {
 680         return(0);
 681 }
 682
 683 static void S60_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
 684 {
 685         if(EpocSdlEnv::IsDsaAvailable())
 686         {
 687                 if(Private->iSwSurface)
 688                 {
 689                         const TRect target(TPoint(0, 0), Private->iSwSurfaceSize);
 690
 691                         if(EpocSdlEnv::GetUpdateWholeScreen())
 692                         {
 693                                 if(!EpocSdlEnv::AddUpdateRect(Private->iSwSurface, target, target))
 694                                         return;
 695                         }
 696                         else
 697                         {
 698                                 for(int i = 0; i < numrects ;i++)
 699                                 {
 700                                         const TRect rect(TPoint(rects[i].x, rects[i].y),
 701                                                         TSize(rects[i].w, rects[i].h));
 702                                         if(!EpocSdlEnv::AddUpdateRect(Private->iSwSurface, rect, target))
 703                                                 return; //not succesful
 704                                         EpocSdlEnv::UpdateWholeScreen(false);
 705                                 }
 706                         }
 707                         EpocSdlEnv::UpdateSwSurface();
 708                 }
 709                 SDL_PauseAudio(0);
 710         }
 711         else
 712         {
 713                 SDL_PauseAudio(1);
 714         }
 715 }
 716
 717 /* Note:  If we are terminated, this could be called in the middle of
 718    another SDL video routine -- notably UpdateRects.
 719    */
 720 void S60_VideoQuit(_THIS)
 721 {
 722         delete[] Private->iOrientation;
 723
 724         delete Private->iRect[0];
 725         delete Private->iRect[1];
 726         delete[] Private->iRect;
 727
 728         if(_this->gl_data)
 729                 DestroyGles(_this);
 730
 731         delete[] Private->iSwSurface;
 732         Private->iSwSurface = NULL;
 733         EpocSdlEnv::FreeSurface();
 734 }
 735
 736
 737 WMcursor *S60_CreateWMCursor(_THIS, Uint8* /*data*/, Uint8* /*mask*/, int /*w*/, int /*h*/, int /*hot_x*/, int /*hot_y*/)
 738 {
 739         // prevents SDL from displaying standard cursor
 740         return (WMcursor*) 1;
 741 }
 742
 743 void S60_FreeWMCursor(_THIS, WMcursor* /*cursor*/)
 744 {
 745 }
 746
 747 int S60_ShowWMCursor(_THIS, WMcursor *cursor)
 748 {
 749         return true;
 750 }
 751
 752 /*FOR GL comp*/
 753
 754 void glBegin(GLenum a) {}
 755 void glEnd(void) {}
 756 void glOrtho(GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) {}
 757 void glPopAttrib(void) {}
 758 void glPopClientAttrib(void){}
 759 void glPushAttrib(GLbitfield mask) {}
 760 void glPushClientAttrib(GLbitfield mask) {}
 761 void glTexCoord2f(GLfloat s, GLfloat t) {}
 762 void glVertex2i(GLint x, GLint y) {}