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