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