1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 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 (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 /* 25 SDL_epocvideo.cpp 26 Epoc based SDL video driver implementation 27 28 Epoc version by Hannu Viitala (hannu.j.viitala (at) mbnet.fi) 29 */ 30 31 extern "C" { 32 #include "SDL_timer.h" 33 #include "SDL_video.h" 34 #undef NULL 35 #include "../SDL_pixels_c.h" 36 }; 37 38 #include "SDL_epocvideo.h" 39 #include "SDL_epocevents_c.h" 40 41 #include <hal.h> 42 #include <coedef.h> 43 44 /* For debugging */ 45 46 void RDebug_Print_b(char* error_str, void* param) 47 { 48 TBuf8<128> error8((TUint8*)error_str); 49 TBuf<128> error; 50 error.Copy(error8); 51 if (param) //!! Do not work if the parameter is really 0!! 52 RDebug::Print(error, param); 53 else 54 RDebug::Print(error); 55 } 56 57 extern "C" void RDebug_Print(char* error_str, void* param) 58 { 59 RDebug_Print_b(error_str, param); 60 } 61 62 63 int Debug_AvailMem2() 64 { 65 //User::CompressAllHeaps(); 66 TMemoryInfoV1Buf membuf; 67 User::LeaveIfError(UserHal::MemoryInfo(membuf)); 68 TMemoryInfoV1 minfo = membuf(); 69 return(minfo.iFreeRamInBytes); 70 } 71 72 extern "C" int Debug_AvailMem() 73 { 74 return(Debug_AvailMem2()); 75 } 76 77 78 extern "C" { 79 80 /* Initialization/Query functions */ 81 82 static int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat); 83 static SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 84 static SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 85 static int EPOC_SetColors(_THIS, int firstcolor, int ncolors, 86 SDL_Color *colors); 87 static void EPOC_VideoQuit(_THIS); 88 89 /* Hardware surface functions */ 90 91 static int EPOC_AllocHWSurface(_THIS, SDL_Surface *surface); 92 static int EPOC_LockHWSurface(_THIS, SDL_Surface *surface); 93 static int EPOC_FlipHWSurface(_THIS, SDL_Surface *surface); 94 static void EPOC_UnlockHWSurface(_THIS, SDL_Surface *surface); 95 static void EPOC_FreeHWSurface(_THIS, SDL_Surface *surface); 96 static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); 97 98 static int EPOC_Available(void); 99 static SDL_VideoDevice *EPOC_CreateDevice(int devindex); 100 101 /* Mouse functions */ 102 103 static WMcursor *EPOC_CreateWMCursor(_THIS, Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y); 104 static void EPOC_FreeWMCursor(_THIS, WMcursor *cursor); 105 static int EPOC_ShowWMCursor(_THIS, WMcursor *cursor); 106 107 108 109 /* !! Table for fast conversion from 8 bit to 12 bit */ 110 static TUint16 EPOC_HWPalette_256_to_4k[256]; 111 112 VideoBootStrap EPOC_bootstrap = { 113 "epoc", "EPOC system", 114 EPOC_Available, EPOC_CreateDevice 115 }; 116 117 const TUint32 WindowClientHandle = 9210; //!! 118 119 /* Epoc video driver bootstrap functions */ 120 121 static int EPOC_Available(void) 122 { 123 return 1; /* Always available */ 124 } 125 126 static void EPOC_DeleteDevice(SDL_VideoDevice *device) 127 { 128 SDL_free(device->hidden); 129 SDL_free(device); 130 } 131 132 static SDL_VideoDevice *EPOC_CreateDevice(int devindex) 133 { 134 SDL_VideoDevice *device; 135 136 /* Allocate all variables that we free on delete */ 137 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 138 if ( device ) { 139 SDL_memset(device, 0, (sizeof *device)); 140 device->hidden = (struct SDL_PrivateVideoData *) 141 SDL_malloc((sizeof *device->hidden)); 142 } 143 if ( (device == NULL) || (device->hidden == NULL) ) { 144 SDL_OutOfMemory(); 145 if ( device ) { 146 SDL_free(device); 147 } 148 return(0); 149 } 150 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); 151 152 /* Set the function pointers */ 153 device->VideoInit = EPOC_VideoInit; 154 device->ListModes = EPOC_ListModes; 155 device->SetVideoMode = EPOC_SetVideoMode; 156 device->SetColors = EPOC_SetColors; 157 device->UpdateRects = NULL; 158 device->VideoQuit = EPOC_VideoQuit; 159 device->AllocHWSurface = EPOC_AllocHWSurface; 160 device->CheckHWBlit = NULL; 161 device->FillHWRect = NULL; 162 device->SetHWColorKey = NULL; 163 device->SetHWAlpha = NULL; 164 device->LockHWSurface = EPOC_LockHWSurface; 165 device->UnlockHWSurface = EPOC_UnlockHWSurface; 166 device->FlipHWSurface = EPOC_FlipHWSurface; 167 device->FreeHWSurface = EPOC_FreeHWSurface; 168 device->SetIcon = NULL; 169 device->SetCaption = NULL; 170 device->GetWMInfo = NULL; 171 device->FreeWMCursor = EPOC_FreeWMCursor; 172 device->CreateWMCursor = EPOC_CreateWMCursor; 173 device->ShowWMCursor = EPOC_ShowWMCursor; 174 device->WarpWMCursor = NULL; 175 device->InitOSKeymap = EPOC_InitOSKeymap; 176 device->PumpEvents = EPOC_PumpEvents; 177 device->free = EPOC_DeleteDevice; 178 179 return device; 180 } 181 182 183 int GetBpp(TDisplayMode displaymode) 184 { 185 TInt numColors = TDisplayModeUtils::NumDisplayModeColors(displaymode); 186 TInt bitsPerPixel = 1; 187 for (TInt32 i = 2; i < numColors; i <<= 1, bitsPerPixel++); 188 return bitsPerPixel; 189 } 190 191 void ConstructWindowL(_THIS) 192 { 193 TInt error; 194 195 error = Private->EPOC_WsSession.Connect(); 196 User::LeaveIfError(error); 197 Private->EPOC_WsScreen=new(ELeave) CWsScreenDevice(Private->EPOC_WsSession); 198 User::LeaveIfError(Private->EPOC_WsScreen->Construct()); 199 User::LeaveIfError(Private->EPOC_WsScreen->CreateContext(Private->EPOC_WindowGc)); 200 201 Private->EPOC_WsWindowGroup=RWindowGroup(Private->EPOC_WsSession); 202 User::LeaveIfError(Private->EPOC_WsWindowGroup.Construct(WindowClientHandle)); 203 Private->EPOC_WsWindowGroup.SetOrdinalPosition(0); 204 205 //!! 206 TBuf<32> winGroupName; 207 winGroupName.Append(0); 208 winGroupName.Append(0); 209 winGroupName.Append(0);// uid 210 winGroupName.Append(0); 211 winGroupName.Append(_L("SDL")); // caption 212 winGroupName.Append(0); 213 winGroupName.Append(0); //doc name 214 Private->EPOC_WsWindowGroup.SetName(winGroupName); //!! 215 216 Private->EPOC_WsWindow=RWindow(Private->EPOC_WsSession); 217 User::LeaveIfError(Private->EPOC_WsWindow.Construct(Private->EPOC_WsWindowGroup,WindowClientHandle)); 218 Private->EPOC_WsWindow.SetBackgroundColor(KRgbWhite); 219 Private->EPOC_WsWindow.Activate(); 220 Private->EPOC_WsWindow.SetSize(Private->EPOC_WsScreen->SizeInPixels()); 221 Private->EPOC_WsWindow.SetVisible(ETrue); 222 223 Private->EPOC_WsWindowGroupID = Private->EPOC_WsWindowGroup.Identifier(); 224 Private->EPOC_IsWindowFocused = EFalse; 225 } 226 227 228 int EPOC_VideoInit(_THIS, SDL_PixelFormat *vformat) 229 { 230 // !!TODO:handle leave functions! 231 232 int i; 233 234 /* Initialize all variables that we clean on shutdown */ 235 236 for ( i=0; i<SDL_NUMMODES; ++i ) { 237 Private->SDL_modelist[i] = (SDL_Rect *)SDL_malloc(sizeof(SDL_Rect)); 238 Private->SDL_modelist[i]->x = Private->SDL_modelist[i]->y = 0; 239 } 240 /* Modes sorted largest to smallest !!TODO:sorting order??*/ 241 Private->SDL_modelist[0]->w = 640; Private->SDL_modelist[0]->h = 200; 242 Private->SDL_modelist[1]->w = 320; Private->SDL_modelist[1]->h = 200; 243 Private->SDL_modelist[2]->w = 640; Private->SDL_modelist[2]->h = 400; 244 Private->SDL_modelist[3]->w = 640; Private->SDL_modelist[3]->h = 480; 245 Private->SDL_modelist[4] = NULL; 246 247 /* Construct Epoc window */ 248 249 ConstructWindowL(_this); 250 251 /* Initialise Epoc frame buffer */ 252 253 TDisplayMode displayMode = Private->EPOC_WsScreen->DisplayMode(); 254 255 #ifndef __WINS__ 256 257 TScreenInfoV01 screenInfo; 258 TPckg<TScreenInfoV01> sInfo(screenInfo); 259 UserSvr::ScreenInfo(sInfo); 260 261 Private->EPOC_ScreenSize = screenInfo.iScreenSize; 262 Private->EPOC_DisplayMode = displayMode; 263 Private->EPOC_HasFrameBuffer = screenInfo.iScreenAddressValid; 264 Private->EPOC_FrameBuffer = Private->EPOC_HasFrameBuffer ? (TUint8*) screenInfo.iScreenAddress : NULL; 265 Private->EPOC_BytesPerPixel = ((GetBpp(displayMode)-1) / 8) + 1; 266 Private->EPOC_BytesPerScanLine = screenInfo.iScreenSize.iWidth * Private->EPOC_BytesPerPixel; 267 268 /* It seems that in SA1100 machines for 8bpp displays there is a 512 palette table at the 269 * beginning of the frame buffer. E.g. Series 7 and Netbook. 270 * In 12 bpp machines the table has 16 entries. 271 */ 272 if (Private->EPOC_HasFrameBuffer && GetBpp(displayMode) == 8) 273 Private->EPOC_FrameBuffer += 512; 274 if (Private->EPOC_HasFrameBuffer && GetBpp(displayMode) == 12) 275 Private->EPOC_FrameBuffer += 16 * 2; 276 277 #else /* defined __WINS__ */ 278 279 /* Create bitmap, device and context for screen drawing */ 280 Private->EPOC_ScreenSize = Private->EPOC_WsScreen->SizeInPixels(); 281 282 Private->EPOC_Bitmap = new (ELeave) CWsBitmap(Private->EPOC_WsSession); 283 Private->EPOC_Bitmap->Create(Private->EPOC_ScreenSize, displayMode); 284 285 Private->EPOC_DisplayMode = displayMode; 286 Private->EPOC_HasFrameBuffer = ETrue; 287 Private->EPOC_FrameBuffer = NULL; /* Private->EPOC_Bitmap->DataAddress() can change any time */ 288 Private->EPOC_BytesPerPixel = ((GetBpp(displayMode)-1) / 8) + 1; 289 Private->EPOC_BytesPerScanLine = Private->EPOC_WsScreen->SizeInPixels().iWidth * Private->EPOC_BytesPerPixel; 290 291 #endif /* __WINS__ */ 292 293 _this->info.current_w = Private->EPOC_ScreenSize.iWidth; 294 _this->info.current_h = Private->EPOC_ScreenSize.iHeight; 295 296 /* The "best" video format should be returned to caller. */ 297 298 vformat->BitsPerPixel = /*!!GetBpp(displayMode) */ 8; 299 vformat->BytesPerPixel = /*!!Private->EPOC_BytesPerPixel*/ 1; 300 301 /* Activate events for me */ 302 303 Private->EPOC_WsEventStatus = KRequestPending; 304 Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus); 305 Private->EPOC_RedrawEventStatus = KRequestPending; 306 Private->EPOC_WsSession.RedrawReady(&Private->EPOC_RedrawEventStatus); 307 Private->EPOC_WsWindow.PointerFilter(EPointerFilterDrag, 0); 308 309 Private->EPOC_ScreenOffset = 0; 310 311 //!! TODO: error handling 312 //if (ret != KErrNone) 313 // return(-1); 314 //else 315 return(0); 316 } 317 318 319 SDL_Rect **EPOC_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 320 { 321 if (format->BitsPerPixel == 12 || format->BitsPerPixel == 8) 322 return Private->SDL_modelist; 323 return NULL; 324 } 325 326 int EPOC_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 327 { 328 for(int i = firstcolor; i < ncolors; i++) { 329 // 4k value: 000rgb 330 TUint16 color4K = 0; 331 color4K |= (colors[i].r & 0x0000f0) << 4; 332 color4K |= (colors[i].g & 0x0000f0); 333 color4K |= (colors[i].b & 0x0000f0) >> 4; 334 EPOC_HWPalette_256_to_4k[i] = color4K; 335 } 336 return(0); 337 } 338 339 340 SDL_Surface *EPOC_SetVideoMode(_THIS, SDL_Surface *current, 341 int width, int height, int bpp, Uint32 flags) 342 { 343 /* Check parameters */ 344 if (!((width == 640 && height == 200 && bpp == 12) || 345 (width == 640 && height == 400 && bpp == 12) || 346 (width == 640 && height == 480 && bpp == 12) || 347 (width == 320 && height == 200 && bpp == 12) || 348 (width == 640 && height == 200 && bpp == 8) || 349 (width == 640 && height == 400 && bpp == 8) || 350 (width == 640 && height == 480 && bpp == 8) || 351 (width == 320 && height == 200 && bpp == 8))) { 352 SDL_SetError("Requested video mode is not supported"); 353 return NULL; 354 } 355 356 if (current && current->pixels) { 357 SDL_free(current->pixels); 358 current->pixels = NULL; 359 } 360 if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) { 361 return(NULL); 362 } 363 364 /* Set up the new mode framebuffer */ 365 if (bpp == 8) 366 current->flags = (SDL_FULLSCREEN|SDL_SWSURFACE|SDL_PREALLOC|SDL_HWPALETTE); 367 else // 12 bpp 368 current->flags = (SDL_FULLSCREEN|SDL_SWSURFACE|SDL_PREALLOC); 369 current->w = width; 370 current->h = height; 371 int numBytesPerPixel = ((bpp-1)>>3) + 1; 372 current->pitch = numBytesPerPixel * width; // Number of bytes in scanline 373 current->pixels = SDL_malloc(width * height * numBytesPerPixel); 374 SDL_memset(current->pixels, 0, width * height * numBytesPerPixel); 375 376 /* Set the blit function */ 377 _this->UpdateRects = EPOC_DirectUpdate; 378 379 /* Must buffer height be shrinked to screen by 2 ? */ 380 if (current->h >= 400) 381 Private->EPOC_ShrinkedHeight = ETrue; 382 383 /* Centralize game window on device screen */ 384 Private->EPOC_ScreenOffset = (Private->EPOC_ScreenSize.iWidth - current->w) / 2; 385 386 /* We're done */ 387 return(current); 388 } 389 390 void RedrawWindowL(_THIS) 391 { 392 SDL_Rect fullScreen; 393 fullScreen.x = 0; 394 fullScreen.y = 0; 395 fullScreen.w = _this->screen->w; 396 fullScreen.h = _this->screen->h; 397 398 #ifdef __WINS__ 399 TBitmapUtil lock(Private->EPOC_Bitmap); 400 lock.Begin(TPoint(0,0)); // Lock bitmap heap 401 Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow); 402 #endif 403 404 if (fullScreen.w < Private->EPOC_ScreenSize.iWidth 405 && fullScreen.w < Private->EPOC_ScreenSize.iWidth) { 406 /* Draw blue stripes background */ 407 #ifdef __WINS__ 408 TUint16* screenBuffer = (TUint16*)Private->EPOC_Bitmap->DataAddress(); 409 #else 410 TUint16* screenBuffer = (TUint16*)Private->EPOC_FrameBuffer; 411 #endif 412 for (int y=0; y < Private->EPOC_ScreenSize.iHeight; y++) { 413 for (int x=0; x < Private->EPOC_ScreenSize.iWidth; x++) { 414 TUint16 color = ((x+y)>>1) & 0xf; /* Draw pattern */ 415 *screenBuffer++ = color; 416 } 417 } 418 } 419 420 421 /* Tell the system that something has been drawn */ 422 TRect rect = TRect(Private->EPOC_WsWindow.Size()); 423 Private->EPOC_WsWindow.Invalidate(rect); 424 425 #ifdef __WINS__ 426 Private->EPOC_WsWindow.BeginRedraw(rect); 427 Private->EPOC_WindowGc->BitBlt(TPoint(), Private->EPOC_Bitmap); 428 Private->EPOC_WsWindow.EndRedraw(); 429 Private->EPOC_WindowGc->Deactivate(); 430 lock.End(); // Unlock bitmap heap 431 Private->EPOC_WsSession.Flush(); 432 #endif 433 434 /* Draw current buffer */ 435 EPOC_DirectUpdate(_this, 1, &fullScreen); 436 } 437 438 439 /* We don't actually allow hardware surfaces other than the main one */ 440 static int EPOC_AllocHWSurface(_THIS, SDL_Surface *surface) 441 { 442 return(-1); 443 } 444 static void EPOC_FreeHWSurface(_THIS, SDL_Surface *surface) 445 { 446 return; 447 } 448 449 static int EPOC_LockHWSurface(_THIS, SDL_Surface *surface) 450 { 451 return(0); 452 } 453 static void EPOC_UnlockHWSurface(_THIS, SDL_Surface *surface) 454 { 455 return; 456 } 457 458 static int EPOC_FlipHWSurface(_THIS, SDL_Surface *surface) 459 { 460 return(0); 461 } 462 463 static void EPOC_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) 464 { 465 TInt focusWindowGroupId = Private->EPOC_WsSession.GetFocusWindowGroup(); 466 if (focusWindowGroupId != Private->EPOC_WsWindowGroupID) { 467 468 /* Force focus window to redraw again for cleaning away SDL screen graphics */ 469 470 471 TInt pos = Private->EPOC_WsWindowGroup.OrdinalPosition(); 472 Private->EPOC_WsWindowGroup.SetOrdinalPosition(0, KMaxTInt); 473 TRect rect = TRect(Private->EPOC_WsWindow.Size()); 474 Private->EPOC_WsWindow.Invalidate(rect); 475 Private->EPOC_WsWindowGroup.SetOrdinalPosition(pos, ECoeWinPriorityNormal); 476 477 /* If this is not the topmost window, wait here! Sleep for 1 second to give cpu to 478 multitasking and poll for being the topmost window. 479 */ 480 while (Private->EPOC_WsSession.GetFocusWindowGroup() != Private->EPOC_WsWindowGroupID) 481 SDL_Delay(1000); 482 483 RedrawWindowL(_this); 484 } 485 486 TInt i; 487 TInt sourceNumBytesPerPixel = ((_this->screen->format->BitsPerPixel-1)>>3) + 1; 488 TInt targetNumBytesPerPixel = Private->EPOC_BytesPerPixel; 489 TInt fixedOffset = Private->EPOC_ScreenOffset; 490 TInt screenW = _this->screen->w; 491 TInt screenH = _this->screen->h; 492 TInt sourceScanlineLength = screenW; 493 if (Private->EPOC_ShrinkedHeight) { /* simulate 400 pixel height in 200 pixel screen */ 494 sourceScanlineLength <<= 1; 495 screenH >>= 1; 496 } 497 TInt targetScanlineLength = Private->EPOC_ScreenSize.iWidth; 498 #ifdef __WINS__ 499 TBitmapUtil lock(Private->EPOC_Bitmap); 500 lock.Begin(TPoint(0,0)); // Lock bitmap heap 501 Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow); 502 TUint16* screenBuffer = (TUint16*)Private->EPOC_Bitmap->DataAddress(); 503 #else 504 TUint16* screenBuffer = (TUint16*)Private->EPOC_FrameBuffer; 505 #endif 506 507 508 /* Render the rectangles in the list */ 509 510 for ( i=0; i < numrects; ++i ) { 511 SDL_Rect rect2; 512 const SDL_Rect& currentRect = rects[i]; 513 rect2.x = currentRect.x; 514 rect2.y = currentRect.y; 515 rect2.w = currentRect.w; 516 rect2.h = currentRect.h; 517 518 if (rect2.w <= 0 || rect2.h <= 0) /* sanity check */ 519 continue; 520 521 if (Private->EPOC_ShrinkedHeight) { /* simulate 400 pixel height in 200 pixel screen */ 522 rect2.y >>= 1; 523 if (!(rect2.h >>= 1)) 524 rect2.h = 1; // always at least 1 pixel height! 525 } 526 527 /* All variables are measured in pixels */ 528 529 /* Check rects validity, i.e. upper and lower bounds */ 530 TInt maxX = Min(screenW - 1, rect2.x + rect2.w - 1); 531 TInt maxY = Min(screenH - 1, rect2.y + rect2.h - 1); 532 if (maxX < 0 || maxY < 0) /* sanity check */ 533 continue; 534 maxY = Min(maxY, 199); 535 536 TInt sourceRectWidth = maxX - rect2.x + 1; 537 TInt sourceRectWidthInBytes = sourceRectWidth * sourceNumBytesPerPixel; 538 TInt sourceRectHeight = maxY - rect2.y + 1; 539 TInt sourceStartOffset = rect2.x + rect2.y * sourceScanlineLength; 540 TInt targetStartOffset = fixedOffset + rect2.x + rect2.y * targetScanlineLength; 541 542 // !! Nokia9210 native mode: 12 bpp --> 12 bpp 543 if (_this->screen->format->BitsPerPixel == 12) { 544 TUint16* bitmapLine = (TUint16*)_this->screen->pixels + sourceStartOffset; 545 TUint16* screenMemory = screenBuffer + targetStartOffset; 546 for(TInt y = 0 ; y < sourceRectHeight ; y++) { 547 __ASSERT_DEBUG(screenMemory < (screenBuffer 548 + Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight), 549 User::Panic(_L("SDL"), KErrCorrupt)); 550 __ASSERT_DEBUG(screenMemory >= screenBuffer, 551 User::Panic(_L("SDL"), KErrCorrupt)); 552 __ASSERT_DEBUG(bitmapLine < ((TUint16*)_this->screen->pixels + 553 + (_this->screen->w * _this->screen->h)), 554 User::Panic(_L("SDL"), KErrCorrupt)); 555 __ASSERT_DEBUG(bitmapLine >= (TUint16*)_this->screen->pixels, 556 User::Panic(_L("SDL"), KErrCorrupt)); 557 Mem::Copy(screenMemory, bitmapLine, sourceRectWidthInBytes); 558 bitmapLine += sourceScanlineLength; 559 screenMemory += targetScanlineLength; 560 } 561 } 562 // !! 256 color paletted mode: 8 bpp --> 12 bpp 563 else { 564 TUint8* bitmapLine = (TUint8*)_this->screen->pixels + sourceStartOffset; 565 TUint16* screenMemory = screenBuffer + targetStartOffset; 566 for(TInt y = 0 ; y < sourceRectHeight ; y++) { 567 TUint8* bitmapPos = bitmapLine; /* 1 byte per pixel */ 568 TUint16* screenMemoryLinePos = screenMemory; /* 2 bytes per pixel */ 569 /* Convert each pixel from 256 palette to 4k color values */ 570 for(TInt x = 0 ; x < sourceRectWidth ; x++) { 571 __ASSERT_DEBUG(screenMemoryLinePos < (screenBuffer 572 + (Private->EPOC_ScreenSize.iWidth * Private->EPOC_ScreenSize.iHeight)), 573 User::Panic(_L("SDL"), KErrCorrupt)); 574 __ASSERT_DEBUG(screenMemoryLinePos >= screenBuffer, 575 User::Panic(_L("SDL"), KErrCorrupt)); 576 __ASSERT_DEBUG(bitmapPos < ((TUint8*)_this->screen->pixels + 577 + (_this->screen->w * _this->screen->h)), 578 User::Panic(_L("SDL"), KErrCorrupt)); 579 __ASSERT_DEBUG(bitmapPos >= (TUint8*)_this->screen->pixels, 580 User::Panic(_L("SDL"), KErrCorrupt)); 581 *screenMemoryLinePos = EPOC_HWPalette_256_to_4k[*bitmapPos]; 582 bitmapPos++; 583 screenMemoryLinePos++; 584 } 585 bitmapLine += sourceScanlineLength; 586 screenMemory += targetScanlineLength; 587 } 588 } 589 590 } 591 592 #ifdef __WINS__ 593 594 TRect rect = TRect(Private->EPOC_WsWindow.Size()); 595 Private->EPOC_WsWindow.Invalidate(rect); 596 Private->EPOC_WsWindow.BeginRedraw(rect); 597 Private->EPOC_WindowGc->BitBlt(TPoint(), Private->EPOC_Bitmap); 598 Private->EPOC_WsWindow.EndRedraw(); 599 Private->EPOC_WindowGc->Deactivate(); 600 lock.End(); // Unlock bitmap heap 601 Private->EPOC_WsSession.Flush(); 602 603 #endif 604 605 /* Update virtual cursor */ 606 //!!Private->EPOC_WsSession.SetPointerCursorPosition(Private->EPOC_WsSession.PointerCursorPosition()); 607 608 return; 609 } 610 611 612 /* Note: If we are terminated, this could be called in the middle of 613 another SDL video routine -- notably UpdateRects. 614 */ 615 void EPOC_VideoQuit(_THIS) 616 { 617 int i; 618 619 /* Free video mode lists */ 620 for ( i=0; i<SDL_NUMMODES; ++i ) { 621 if ( Private->SDL_modelist[i] != NULL ) { 622 SDL_free(Private->SDL_modelist[i]); 623 Private->SDL_modelist[i] = NULL; 624 } 625 } 626 627 if ( _this->screen && (_this->screen->flags & SDL_HWSURFACE) ) { 628 /* Direct screen access, no memory buffer */ 629 _this->screen->pixels = NULL; 630 } 631 632 if (_this->screen && _this->screen->pixels) { 633 SDL_free(_this->screen->pixels); 634 _this->screen->pixels = NULL; 635 } 636 637 /* Free Epoc resources */ 638 639 /* Disable events for me */ 640 if (Private->EPOC_WsEventStatus != KRequestPending) 641 Private->EPOC_WsSession.EventReadyCancel(); 642 if (Private->EPOC_RedrawEventStatus != KRequestPending) 643 Private->EPOC_WsSession.RedrawReadyCancel(); 644 645 #ifdef __WINS__ 646 delete Private->EPOC_Bitmap; 647 Private->EPOC_Bitmap = NULL; 648 #endif 649 650 if (Private->EPOC_WsWindow.WsHandle()) 651 Private->EPOC_WsWindow.Close(); 652 653 if (Private->EPOC_WsWindowGroup.WsHandle()) 654 Private->EPOC_WsWindowGroup.Close(); 655 656 delete Private->EPOC_WindowGc; 657 Private->EPOC_WindowGc = NULL; 658 659 delete Private->EPOC_WsScreen; 660 Private->EPOC_WsScreen = NULL; 661 662 if (Private->EPOC_WsSession.WsHandle()) 663 Private->EPOC_WsSession.Close(); 664 } 665 666 667 WMcursor *EPOC_CreateWMCursor(_THIS, Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y) 668 { 669 return (WMcursor *) 9210; // it's ok to return something unuseful but true 670 } 671 672 void EPOC_FreeWMCursor(_THIS, WMcursor *cursor) 673 { 674 /* Disable virtual cursor */ 675 HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible); 676 Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNone); 677 } 678 679 int EPOC_ShowWMCursor(_THIS, WMcursor *cursor) 680 { 681 682 if (cursor == (WMcursor *)9210) { 683 /* Enable virtual cursor */ 684 HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible); 685 Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNormal); 686 } 687 else { 688 /* Disable virtual cursor */ 689 HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible); 690 Private->EPOC_WsSession.SetPointerCursorMode(EPointerCursorNone); 691 } 692 693 return(1); 694 } 695 696 }; // extern "C" 697 698