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@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@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
RDebug_Print_b(char * error_str,void * param)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
RDebug_Print(char * error_str,void * param)57 extern "C" void RDebug_Print(char* error_str, void* param)
58 {
59 RDebug_Print_b(error_str, param);
60 }
61
62
Debug_AvailMem2()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
Debug_AvailMem()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
EPOC_Available(void)121 static int EPOC_Available(void)
122 {
123 return 1; /* Always available */
124 }
125
EPOC_DeleteDevice(SDL_VideoDevice * device)126 static void EPOC_DeleteDevice(SDL_VideoDevice *device)
127 {
128 SDL_free(device->hidden);
129 SDL_free(device);
130 }
131
EPOC_CreateDevice(int devindex)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
GetBpp(TDisplayMode displaymode)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
ConstructWindowL(_THIS)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
EPOC_VideoInit(_THIS,SDL_PixelFormat * vformat)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
EPOC_ListModes(_THIS,SDL_PixelFormat * format,Uint32 flags)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
EPOC_SetColors(_THIS,int firstcolor,int ncolors,SDL_Color * colors)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
EPOC_SetVideoMode(_THIS,SDL_Surface * current,int width,int height,int bpp,Uint32 flags)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
RedrawWindowL(_THIS)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 */
EPOC_AllocHWSurface(_THIS,SDL_Surface * surface)440 static int EPOC_AllocHWSurface(_THIS, SDL_Surface *surface)
441 {
442 return(-1);
443 }
EPOC_FreeHWSurface(_THIS,SDL_Surface * surface)444 static void EPOC_FreeHWSurface(_THIS, SDL_Surface *surface)
445 {
446 return;
447 }
448
EPOC_LockHWSurface(_THIS,SDL_Surface * surface)449 static int EPOC_LockHWSurface(_THIS, SDL_Surface *surface)
450 {
451 return(0);
452 }
EPOC_UnlockHWSurface(_THIS,SDL_Surface * surface)453 static void EPOC_UnlockHWSurface(_THIS, SDL_Surface *surface)
454 {
455 return;
456 }
457
EPOC_FlipHWSurface(_THIS,SDL_Surface * surface)458 static int EPOC_FlipHWSurface(_THIS, SDL_Surface *surface)
459 {
460 return(0);
461 }
462
EPOC_DirectUpdate(_THIS,int numrects,SDL_Rect * rects)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 */
EPOC_VideoQuit(_THIS)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
EPOC_CreateWMCursor(_THIS,Uint8 * data,Uint8 * mask,int w,int h,int hot_x,int hot_y)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
EPOC_FreeWMCursor(_THIS,WMcursor * cursor)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
EPOC_ShowWMCursor(_THIS,WMcursor * cursor)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