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         /* The "best" video format should be returned to caller. */
 187
 188         vformat->BitsPerPixel   = 16;
 189         vformat->BytesPerPixel  = 2;
 190
 191         Private->iRect = new SDL_Rect*[5];
 192         Private->iRect[0] = new SDL_Rect;
 193         Private->iRect[1] = new SDL_Rect;
 194         Private->iRect[2] = new SDL_Rect;
 195         Private->iRect[3] = new SDL_Rect;
 196         Private->iRect[4] = NULL;
 197
 198         for( int i=0; i<4; i++ )
 199         {
 200                 Private->iRect[i]->x = 0;
 201                 Private->iRect[i]->y = 0;
 202         }
 203
 204         const TSize sz = GetScreenSize();
 205
 206         Private->iRect[0]->w = sz.iWidth;
 207         Private->iRect[0]->h = sz.iHeight;
 208
 209         Private->iRect[1]->w = sz.iHeight;
 210         Private->iRect[1]->h = sz.iWidth;
 211
 212         Private->iRect[2]->w = sz.iWidth * 2;
 213         Private->iRect[2]->h = sz.iHeight * 2;
 214
 215         Private->iRect[3]->w = sz.iHeight * 2;
 216         Private->iRect[3]->h = sz.iWidth * 2;
 217
 218         Private->iOrientation = new CAknAppUi::TAppUiOrientation[4];
 219
 220         if(sz.iWidth < sz.iHeight)
 221         {
 222                 Private->iOrientation[0] = CAknAppUi::EAppUiOrientationPortrait;
 223                 Private->iOrientation[1] = CAknAppUi::EAppUiOrientationLandscape;
 224                 Private->iOrientation[2] = CAknAppUi::EAppUiOrientationPortrait;
 225                 Private->iOrientation[3] = CAknAppUi::EAppUiOrientationLandscape;
 226         }
 227         else
 228         {
 229                 Private->iOrientation[0] = CAknAppUi::EAppUiOrientationLandscape;
 230                 Private->iOrientation[1] = CAknAppUi::EAppUiOrientationPortrait;
 231                 Private->iOrientation[2] = CAknAppUi::EAppUiOrientationLandscape;
 232                 Private->iOrientation[3] = 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         int c = 0;
 259
 260         for(int i = firstcolor; i < firstcolor+ncolors; i++)
 261         {
 262                 TUint32 color64K = (colors[c].r & 0x0000f8) << 8;
 263                 color64K                |= (colors[c].g & 0x0000fc) << 3;
 264                 color64K                |= (colors[c].b & 0x0000f8) >> 3;
 265                 palette[i] = color64K;
 266                 c++;
 267         }
 268
 269         if(EpocSdlEnv::SetPalette(firstcolor, ncolors, palette) == KErrNone)
 270         {
 271                 return 0;
 272         }
 273         return -1;
 274 }
 275
 276 int S60_GlesLoadLibrary(SDL_VideoDevice* _this, const char* path)
 277 {
 278         if(_this->gl_data->iLibrary.Handle() != 0)
 279                 return KErrAlreadyExists; //already loaded
 280         const char* const gles_lib[] = {"libgles_cm.dll", "libSWGLES.dll"};
 281         int err = KErrNotFound;
 282         for(int i = 0; i < 2 && err != KErrNone; i++)
 283         {
 284                 const char* name8 = path == NULL ? gles_lib[i] : path;
 285                 TFileName lib;
 286                 lib.Copy(TPtrC8((unsigned char*)name8));
 287                 err = _this->gl_data->iLibrary.Load(lib);
 288         }
 289         if(err == KErrNone)
 290                 _this->gl_config.driver_loaded = 1;
 291         return err;
 292 }
 293
 294 typedef int (*Ftp)(...);
 295 #define DC(x) ((Ftp) S60_GlesGetProcAddress(_this, #x))
 296
 297 const char* const OpenGL[] = //these funtions are in gl, but not in gles, at least in all in all versions...
 298 {
 299         "glBegin",
 300         "glEnd",
 301         "glOrtho",
 302         "glPopAttrib",
 303         "glPopClientAttrib",
 304         "glPushAttrib",
 305         "glPushClientAttrib",
 306         "glTexCoord2f",
 307         "glVertex2i",
 308         "glTexParameteri"
 309 };
 310
 311 int NotSupported()
 312 {
 313         User::Panic(_L("SDL, Gles"), KErrNotSupported);
 314         return 0;
 315 }
 316
 317 void* S60_GlesGetProcAddress(_THIS, const char *proc)
 318 {
 319         if(_this->gl_data->iLibrary.Handle() == 0)
 320                 return NULL; //not loaded
 321         TLibraryFunction f = NULL;
 322         for(int i = 0; i < G_ordinals_count; i++)
 323         {
 324                 if(strcmp(G_ordinals[i].name, proc) == 0)
 325                 {
 326                         f = _this->gl_data->iLibrary.Lookup(G_ordinals[i].ord);
 327                         break;
 328                 }
 329         }
 330
 331         if(f != NULL) /*Lookup may fail*/
 332                 return  (void*) f;
 333
 334         for(int i = 0; i < sizeof(OpenGL) / sizeof(char*); i++)
 335         {
 336                 if(strcmp(OpenGL[i], proc) == 0)
 337                         return (void*) NotSupported;
 338         }
 339
 340         return NULL;
 341 }
 342
 343 int S60_GlesGetAttribute(_THIS, SDL_GLattr aAttrib, int* aValue)
 344 {
 345         EGLint attrib;
 346         switch(aAttrib)
 347         {
 348                 /*todo*/
 349                 case SDL_GL_RED_SIZE: attrib = EGL_RED_SIZE; break;
 350                 case SDL_GL_GREEN_SIZE: attrib = EGL_GREEN_SIZE; break;
 351                 case SDL_GL_BLUE_SIZE:attrib = EGL_BLUE_SIZE; break;
 352                 case SDL_GL_ALPHA_SIZE: attrib = EGL_ALPHA_SIZE; break;
 353                 case SDL_GL_BUFFER_SIZE: attrib = EGL_BUFFER_SIZE; break;
 354                 case SDL_GL_DOUBLEBUFFER: *aValue = 1; return 0; //always
 355                 case SDL_GL_DEPTH_SIZE: attrib = EGL_DEPTH_SIZE; break;
 356                 case SDL_GL_STENCIL_SIZE: attrib = EGL_STENCIL_SIZE; break;
 357                 case SDL_GL_ACCUM_RED_SIZE:
 358                 case SDL_GL_ACCUM_GREEN_SIZE:
 359                 case SDL_GL_ACCUM_BLUE_SIZE:
 360                 case SDL_GL_ACCUM_ALPHA_SIZE:
 361                 case SDL_GL_STEREO:
 362                 case SDL_GL_MULTISAMPLEBUFFERS:
 363                 case SDL_GL_MULTISAMPLESAMPLES:
 364                 case SDL_GL_ACCELERATED_VISUAL:
 365                 case SDL_GL_SWAP_CONTROL:
 366                                           *aValue = 0;
 367                                           return -1;
 368         }
 369         const int success = DC(eglGetConfigAttrib)
 370                 (
 371                  _this->gl_data->iDisplay,
 372                  _this->gl_data->iConfig,
 373                  attrib,
 374                  aValue);
 375         return success == EGL_FALSE ? -1 : 0;
 376 }
 377
 378
 379 int S60_GlesMakeCurrent(_THIS)
 380 {
 381         DC(eglMakeCurrent)
 382                 (_this->gl_data->iDisplay,
 383                  _this->gl_data->iSurface,
 384                  _this->gl_data->iSurface,
 385                  _this->gl_data->iContext);
 386         return DC(eglGetError)();
 387 }
 388
 389 void S60_GlesSwapBuffers(_THIS)
 390 {
 391         DC(eglSwapBuffers)(
 392                         _this->gl_data->iDisplay,
 393                         _this->gl_data->iSurface);
 394 }
 395
 396 static void glAssert(_THIS)
 397 {
 398         const EGLint err = DC(eglGetError)();
 399         if(err != EGL_SUCCESS)
 400         {
 401                 User::Leave(err);
 402         }
 403 }
 404
 405 static void CreateGles(_THIS, RWindow& aWindow, int bpp, SDL_PrivateGLData& aData)
 406 {
 407         SDL_GL_LoadLibrary(NULL); //just if its not already loaded
 408         aData.iDisplay = DC(eglGetDisplay)(EGL_DEFAULT_DISPLAY);
 409         DC(eglInitialize)(aData.iDisplay, NULL, NULL);
 410
 411         glAssert(_this);
 412
 413         int configs = 0;
 414         EGLConfig* configList = NULL;
 415         int configSz = 0;
 416         DC(eglGetConfigs)(aData.iDisplay, configList, configSz, &configs);
 417         configSz = configs;
 418
 419         glAssert(_this);
 420
 421         configList = new EGLConfig[configSz];
 422
 423         int red, green, blue;
 424         if(bpp == 16)
 425         {
 426                 red = 5;
 427                 green = 6;
 428                 blue = 5;
 429         }
 430         else
 431         {
 432                 red = 8;
 433                 green = 8;
 434                 blue = 8;
 435         }
 436
 437         const EGLint attribList[] =
 438         {
 439                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 440                 EGL_RED_SIZE, red,
 441                 EGL_GREEN_SIZE, green,
 442                 EGL_BLUE_SIZE, blue,
 443                 EGL_BUFFER_SIZE, EGL_DONT_CARE,
 444                 EGL_DEPTH_SIZE, 8,
 445                 EGL_NONE
 446         };
 447
 448         DC(eglChooseConfig)(aData.iDisplay,
 449                         attribList,
 450                         configList,
 451                         configSz,
 452                         &configs);
 453
 454
 455         glAssert(_this);
 456
 457         __ASSERT_ALWAYS(configs > 0, User::Invariant());
 458
 459         aData.iConfig = configList[0];
 460
 461         delete[] configList;
 462
 463         aData.iContext = DC(eglCreateContext)(aData.iDisplay,
 464                         aData.iConfig,
 465                         EGL_NO_CONTEXT,
 466                         NULL);
 467
 468         glAssert(_this);
 469
 470         aData.iSurface  = DC(eglCreateWindowSurface)(aData.iDisplay,
 471                         aData.iConfig,
 472                         &aWindow,
 473                         NULL);
 474
 475         glAssert(_this);
 476
 477 }
 478
 479 static void DestroyGles(_THIS)
 480 {
 481         if(     _this->gl_config.driver_loaded)
 482         {
 483                 DC(eglMakeCurrent)(_this->gl_data->iDisplay,
 484                                 EGL_NO_SURFACE,
 485                                 EGL_NO_SURFACE,
 486                                 EGL_NO_CONTEXT);
 487                 DC(eglDestroySurface)(_this->gl_data->iDisplay, _this->gl_data->iSurface);
 488                 DC(eglDestroyContext)(_this->gl_data->iDisplay, _this->gl_data->iContext);
 489                 DC(eglTerminate)(_this->gl_data->iDisplay);
 490                 _this->gl_data->iLibrary.Close();
 491                 _this->gl_config.driver_loaded = 0;
 492         }
 493 }
 494
 495 SDL_Surface *S60_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
 496 {
 497         if(flags & SDL_OPENGL)
 498         {
 499                 current->flags |= SDL_OPENGL;
 500                 current->w = width;
 501                 current->h = height;
 502
 503                 RWindow* win = EpocSdlEnv::Window();
 504                 EpocSdlEnv::ApplyGlesDsa();
 505
 506                 CreateGles(_this, *win, bpp, *_this->gl_data);
 507
 508                 return current;
 509         }
 510
 511         if(flags & SDL_HWSURFACE)
 512                 return NULL;
 513
 514         // check orientation and resolution validity
 515         bool resValid = false;
 516         Orientation orientation = CAknAppUi::EAppUiOrientationUnspecified;
 517         for(int i=0; i<4; i++)
 518         {
 519                 if(width <= Private->iRect[i]->w && height <= Private->iRect[i]->h)
 520                 {
 521                         orientation = Private->iOrientation[i];
 522                         resValid = true;
 523                         break;
 524                 }
 525         }
 526         if(!resValid)
 527                 return NULL;
 528
 529         if(!SDL_ReallocFormat(current, bpp, 0, 0, 0, 0))
 530                 return NULL;
 531
 532         const int numBytesPerPixel = ((bpp-1)>>3) + 1;
 533         current->pitch = numBytesPerPixel * width;
 534
 535         // set proper surface flags
 536         current->flags = SDL_SWSURFACE | SDL_PREALLOC;
 537         if(flags & SDL_FULLSCREEN)
 538                 current->flags |= SDL_FULLSCREEN;
 539         if(flags & SDL_RESIZABLE)
 540                 current->flags |= SDL_RESIZABLE;
 541         if(bpp <= 8)
 542                 current->flags |= SDL_HWPALETTE;
 543
 544         current->w = width;
 545         current->h = height;
 546
 547         // allocate surface
 548         const int surfacesize = width * height * numBytesPerPixel;
 549         Private->iSwSurfaceSize = TSize(width, height);
 550
 551         delete[] (TUint8*)current->pixels;
 552         current->pixels = new TUint8[surfacesize];
 553         Private->iSwSurface = (TUint8*) current->pixels;
 554
 555         if(current->pixels == NULL)
 556                 return NULL;
 557
 558         const TSize sz = GetScreenSize();
 559
 560         if(sz.iWidth < sz.iHeight && orientation != CAknAppUi::EAppUiOrientationPortrait ||
 561            sz.iWidth > sz.iHeight && orientation != CAknAppUi::EAppUiOrientationLandscape)
 562         {
 563                 g_SDL->SetOrientation(orientation, current->format->BitsPerPixel / 8);
 564         }
 565         else
 566         {
 567                 if((flags & SDL_RESIZABLE) == 0)
 568                 {
 569                         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 570                 }
 571                 else
 572                 {
 573                         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(CAknAppUi::EAppUiOrientationUnspecified));
 574                 }
 575
 576                 const int err = EpocSdlEnv::AllocSurface(current->format->BitsPerPixel / 8);
 577                 if(err != KErrNone)
 578                         return NULL;
 579         }
 580
 581         // Set the blit function
 582         _this->UpdateRects = S60_DirectUpdate;
 583
 584         return current;
 585 }
 586
 587 static int S60_AllocHWSurface(_THIS, SDL_Surface* surface)
 588 {
 589         return KErrNone == EpocSdlEnv::AllocSurface(surface->format->BitsPerPixel / 8);
 590 }
 591
 592 static void S60_FreeHWSurface(_THIS, SDL_Surface* /*surface*/)
 593 {
 594 }
 595
 596 static int S60_LockHWSurface(_THIS, SDL_Surface* surface)
 597 {
 598         if(EpocSdlEnv::IsDsaAvailable())
 599         {
 600                 TUint8* address = EpocSdlEnv::LockHwSurface();
 601                 if(address != NULL)
 602                 {
 603                         surface->pixels = address;
 604                         return 1;
 605                 }
 606         }
 607         return 0;
 608 }
 609 static void S60_UnlockHWSurface(_THIS, SDL_Surface* /*surface*/)
 610 {
 611         EpocSdlEnv::UnlockHwSurface();
 612 }
 613
 614 static int S60_FlipHWSurface(_THIS, SDL_Surface* /*surface*/)
 615 {
 616         return(0);
 617 }
 618
 619 static void S60_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
 620 {
 621         if(EpocSdlEnv::IsDsaAvailable())
 622         {
 623                 if(Private->iSwSurface)
 624                 {
 625                         EpocSdlEnv::Blit(Private->iSwSurface, Private->iSwSurfaceSize);
 626                 }
 627                 if(!Private->iIsWindowFocused)
 628                 {
 629                         User::After(100000);
 630                 }
 631         }
 632 }
 633
 634 /* Note:  If we are terminated, this could be called in the middle of
 635    another SDL video routine -- notably UpdateRects.
 636    */
 637 void S60_VideoQuit(_THIS)
 638 {
 639         delete[] Private->iOrientation;
 640
 641         delete Private->iRect[0];
 642         delete Private->iRect[1];
 643         delete[] Private->iRect;
 644
 645         if(_this->gl_data)
 646                 DestroyGles(_this);
 647
 648         delete[] Private->iSwSurface;
 649         Private->iSwSurface = NULL;
 650         EpocSdlEnv::FreeSurface();
 651 }
 652
 653
 654 WMcursor *S60_CreateWMCursor(_THIS, Uint8* /*data*/, Uint8* /*mask*/, int /*w*/, int /*h*/, int /*hot_x*/, int /*hot_y*/)
 655 {
 656         // prevents SDL from displaying standard cursor
 657         return (WMcursor*) 1;
 658 }
 659
 660 void S60_FreeWMCursor(_THIS, WMcursor* /*cursor*/)
 661 {
 662 }
 663
 664 int S60_ShowWMCursor(_THIS, WMcursor *cursor)
 665 {
 666         return true;
 667 }
 668
 669 /*FOR GL comp*/
 670
 671 void glBegin(GLenum a) {}
 672 void glEnd(void) {}
 673 void glOrtho(GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f) {}
 674 void glPopAttrib(void) {}
 675 void glPopClientAttrib(void){}
 676 void glPushAttrib(GLbitfield mask) {}
 677 void glPushClientAttrib(GLbitfield mask) {}
 678 void glTexCoord2f(GLfloat s, GLfloat t) {}
 679 void glVertex2i(GLint x, GLint y) {}