1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 Sam Lantinga 4 Copyright (C) 2001 Hsieh-Fu Tsai 5 Copyright (C) 2002 Greg Haerr <greg (at) censoft.com> 6 7 This library is free software; you can redistribute it and/or 8 modify it under the terms of the GNU Library General Public 9 License as published by the Free Software Foundation; either 10 version 2 of the License, or (at your option) any later version. 11 12 This library is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 Library General Public License for more details. 16 17 You should have received a copy of the GNU Library General Public 18 License along with this library; if not, write to the Free 19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 21 Sam Lantinga 22 slouken (at) libsdl.org 23 24 Hsieh-Fu Tsai 25 clare (at) setabox.com 26 */ 27 #include "SDL_config.h" 28 29 #include "SDL_thread.h" 30 #include "SDL_video.h" 31 #include "../SDL_pixels_c.h" 32 #include "../../events/SDL_events_c.h" 33 34 #define MWINCLUDECOLORS 35 #include "SDL_nxvideo.h" 36 #include "SDL_nxmodes_c.h" 37 #include "SDL_nxwm_c.h" 38 #include "SDL_nxmouse_c.h" 39 #include "SDL_nximage_c.h" 40 #include "SDL_nxevents_c.h" 41 42 // Initialization/Query functions 43 static int NX_VideoInit (_THIS, SDL_PixelFormat * vformat) ; 44 static SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) ; 45 static int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) ; 46 static void NX_VideoQuit (_THIS) ; 47 static void NX_DestroyWindow (_THIS, SDL_Surface * screen) ; 48 static int NX_ToggleFullScreen (_THIS, int on) ; 49 static void NX_UpdateMouse (_THIS) ; 50 static int NX_SetGammaRamp (_THIS, Uint16 * ramp) ; 51 static int NX_GetGammaRamp (_THIS, Uint16 * ramp) ; 52 53 // Microwin driver bootstrap functions 54 static int NX_Available () 55 { 56 Dprintf ("enter NX_Available\n") ; 57 58 if (GrOpen () < 0) return 0 ; 59 GrClose () ; 60 61 Dprintf ("leave NX_Available\n") ; 62 return 1 ; 63 } 64 65 static void NX_DeleteDevice (SDL_VideoDevice * device) 66 { 67 Dprintf ("enter NX_DeleteDevice\n") ; 68 69 if (device) { 70 if (device -> hidden) SDL_free (device -> hidden) ; 71 if (device -> gl_data) SDL_free (device -> gl_data) ; 72 SDL_free (device) ; 73 } 74 75 Dprintf ("leave NX_DeleteDevice\n") ; 76 } 77 78 static SDL_VideoDevice * NX_CreateDevice (int devindex) 79 { 80 SDL_VideoDevice * device ; 81 82 Dprintf ("enter NX_CreateDevice\n") ; 83 84 // Initialize all variables that we clean on shutdown 85 device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice)) ; 86 if (device) { 87 SDL_memset (device, 0, (sizeof * device)) ; 88 device -> hidden = (struct SDL_PrivateVideoData *) 89 SDL_malloc ((sizeof * device -> hidden)) ; 90 device -> gl_data = NULL ; 91 } 92 if ((device == NULL) || (device -> hidden == NULL)) { 93 SDL_OutOfMemory () ; 94 NX_DeleteDevice (device) ; 95 return 0 ; 96 } 97 SDL_memset (device -> hidden, 0, (sizeof * device -> hidden)) ; 98 99 // Set the function pointers 100 device -> VideoInit = NX_VideoInit ; 101 device -> ListModes = NX_ListModes ; 102 device -> SetVideoMode = NX_SetVideoMode ; 103 device -> ToggleFullScreen = NX_ToggleFullScreen ; 104 device -> UpdateMouse = NX_UpdateMouse ; 105 device -> CreateYUVOverlay = NULL ; 106 device -> SetColors = NX_SetColors ; 107 device -> UpdateRects = NULL ; 108 device -> VideoQuit = NX_VideoQuit; 109 device -> AllocHWSurface = NULL ; 110 device -> CheckHWBlit = NULL ; 111 device -> FillHWRect = NULL ; 112 device -> SetHWColorKey = NULL ; 113 device -> SetHWAlpha = NULL ; 114 device -> LockHWSurface = NULL ; 115 device -> UnlockHWSurface = NULL ; 116 device -> FlipHWSurface = NULL ; 117 device -> FreeHWSurface = NULL ; 118 device -> SetGamma = NULL ; 119 device -> GetGamma = NULL ; 120 device -> SetGammaRamp = NX_SetGammaRamp ; 121 device -> GetGammaRamp = NX_GetGammaRamp ; 122 123 #if SDL_VIDEO_OPENGL 124 device -> GL_LoadLibrary = NULL ; 125 device -> GL_GetProcAddress = NULL ; 126 device -> GL_GetAttribute = NULL ; 127 device -> GL_MakeCurrent = NULL ; 128 device -> GL_SwapBuffers = NULL ; 129 #endif 130 131 device -> SetIcon = NULL ; 132 device -> SetCaption = NX_SetCaption; 133 device -> IconifyWindow = NULL ; 134 device -> GrabInput = NULL ; 135 device -> GetWMInfo = NX_GetWMInfo ; 136 device -> FreeWMCursor = NX_FreeWMCursor ; 137 device -> CreateWMCursor = NX_CreateWMCursor ; 138 device -> ShowWMCursor = NX_ShowWMCursor ; 139 device -> WarpWMCursor = NX_WarpWMCursor ; 140 device -> CheckMouseMode = NULL ; 141 device -> InitOSKeymap = NX_InitOSKeymap ; 142 device -> PumpEvents = NX_PumpEvents ; 143 144 device -> free = NX_DeleteDevice ; 145 146 Dprintf ("leave NX_CreateDevice\n") ; 147 return device ; 148 } 149 150 VideoBootStrap NX_bootstrap = { 151 "nanox", "nanox", NX_Available, NX_CreateDevice 152 } ; 153 154 static void create_aux_windows (_THIS) 155 { 156 GR_WM_PROPERTIES props ; 157 158 Dprintf ("enter create_aux_windows\n") ; 159 160 // Don't create any extra windows if we are being managed 161 if (SDL_windowid) { 162 FSwindow = 0 ; 163 return ; 164 } 165 166 if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) { 167 GrDestroyWindow (FSwindow) ; 168 } 169 170 FSwindow = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK) ; 171 props.flags = GR_WM_FLAGS_PROPS ; 172 props.props = GR_WM_PROPS_NODECORATE ; 173 GrSetWMProperties (FSwindow, & props) ; 174 175 GrSelectEvents (FSwindow, (GR_EVENT_MASK_EXPOSURE | 176 GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | 177 GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT | 178 GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP | 179 GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | 180 GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE | 181 GR_EVENT_MASK_CLOSE_REQ)) ; 182 183 Dprintf ("leave create_aux_windows\n") ; 184 } 185 186 int NX_VideoInit (_THIS, SDL_PixelFormat * vformat) 187 { 188 GR_SCREEN_INFO si ; 189 190 Dprintf ("enter NX_VideoInit\n") ; 191 192 if (GrOpen () < 0) { 193 SDL_SetError ("GrOpen() fail") ; 194 return -1 ; 195 } 196 197 // use share memory to speed up 198 #ifdef NANOX_SHARE_MEMORY 199 GrReqShmCmds (0xFFFF); 200 #endif 201 202 SDL_Window = 0 ; 203 FSwindow = 0 ; 204 205 GammaRamp_R = NULL ; 206 GammaRamp_G = NULL ; 207 GammaRamp_B = NULL ; 208 209 GrGetScreenInfo (& si) ; 210 SDL_Visual.bpp = si.bpp ; 211 212 /* Determine the current screen size */ 213 this->info.current_w = si.cols ; 214 this->info.current_h = si.rows ; 215 216 // GetVideoMode 217 SDL_modelist = (SDL_Rect **) SDL_malloc (sizeof (SDL_Rect *) * 2) ; 218 if (SDL_modelist) { 219 SDL_modelist [0] = (SDL_Rect *) SDL_malloc (sizeof(SDL_Rect)) ; 220 if (SDL_modelist [0]) { 221 SDL_modelist [0] -> x = 0 ; 222 SDL_modelist [0] -> y = 0 ; 223 SDL_modelist [0] -> w = si.cols ; 224 SDL_modelist [0] -> h = si.rows ; 225 } 226 SDL_modelist [1] = NULL ; 227 } 228 229 pixel_type = si.pixtype; 230 SDL_Visual.red_mask = si.rmask; 231 SDL_Visual.green_mask = si.gmask; 232 SDL_Visual.blue_mask = si.bmask; 233 234 vformat -> BitsPerPixel = SDL_Visual.bpp ; 235 if (vformat -> BitsPerPixel > 8) { 236 vformat -> Rmask = SDL_Visual.red_mask ; 237 vformat -> Gmask = SDL_Visual.green_mask ; 238 vformat -> Bmask = SDL_Visual.blue_mask ; 239 } 240 241 // See if we have been passed a window to use 242 SDL_windowid = getenv ("SDL_WINDOWID") ; 243 244 // Create the fullscreen (and managed windows : no implement) 245 create_aux_windows (this) ; 246 247 Dprintf ("leave NX_VideoInit\n") ; 248 return 0 ; 249 } 250 251 void NX_VideoQuit (_THIS) 252 { 253 Dprintf ("enter NX_VideoQuit\n") ; 254 255 // Start shutting down the windows 256 NX_DestroyImage (this, this -> screen) ; 257 NX_DestroyWindow (this, this -> screen) ; 258 if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) { 259 GrDestroyWindow (FSwindow) ; 260 } 261 NX_FreeVideoModes (this) ; 262 SDL_free (GammaRamp_R) ; 263 SDL_free (GammaRamp_G) ; 264 SDL_free (GammaRamp_B) ; 265 266 #ifdef ENABLE_NANOX_DIRECT_FB 267 if (Clientfb) 268 GrCloseClientFramebuffer(); 269 #endif 270 GrClose () ; 271 272 Dprintf ("leave NX_VideoQuit\n") ; 273 } 274 275 static void NX_DestroyWindow (_THIS, SDL_Surface * screen) 276 { 277 Dprintf ("enter NX_DestroyWindow\n") ; 278 279 if (! SDL_windowid) { 280 if (screen && (screen -> flags & SDL_FULLSCREEN)) { 281 screen -> flags &= ~ SDL_FULLSCREEN ; 282 NX_LeaveFullScreen (this) ; 283 } 284 285 // Destroy the output window 286 if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) { 287 GrDestroyWindow (SDL_Window) ; 288 } 289 } 290 291 // Free the graphics context 292 if (! SDL_GC) { 293 GrDestroyGC (SDL_GC) ; 294 SDL_GC = 0; 295 } 296 297 Dprintf ("leave NX_DestroyWindow\n") ; 298 } 299 300 static int NX_CreateWindow (_THIS, SDL_Surface * screen, 301 int w, int h, int bpp, Uint32 flags) 302 { 303 Dprintf ("enter NX_CreateWindow\n") ; 304 305 // If a window is already present, destroy it and start fresh 306 if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) { 307 NX_DestroyWindow (this, screen) ; 308 } 309 310 // See if we have been given a window id 311 if (SDL_windowid) { 312 SDL_Window = SDL_strtol (SDL_windowid, NULL, 0) ; 313 } else { 314 SDL_Window = 0 ; 315 } 316 317 if ( ! SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask, 318 SDL_Visual.green_mask, SDL_Visual.blue_mask, 0)) 319 return -1; 320 321 // Create (or use) the nanox display window 322 if (! SDL_windowid) { 323 324 SDL_Window = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE) ; 325 326 GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE | 327 GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP | 328 GR_EVENT_MASK_FOCUS_IN | GR_EVENT_MASK_FOCUS_OUT | 329 GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP | 330 GR_EVENT_MASK_MOUSE_ENTER | GR_EVENT_MASK_MOUSE_EXIT | 331 GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE | 332 GR_EVENT_MASK_CLOSE_REQ)) ; 333 } 334 335 /* Create the graphics context here, once we have a window */ 336 SDL_GC = GrNewGC () ; 337 if (SDL_GC == 0) { 338 SDL_SetError("Couldn't create graphics context"); 339 return(-1); 340 } 341 342 // Map them both and go fullscreen, if requested 343 if (! SDL_windowid) { 344 GrMapWindow (SDL_Window) ; 345 if (flags & SDL_FULLSCREEN) { 346 screen -> flags |= SDL_FULLSCREEN ; 347 NX_EnterFullScreen (this) ; 348 } else { 349 screen -> flags &= ~ SDL_FULLSCREEN ; 350 } 351 } 352 353 #ifdef ENABLE_NANOX_DIRECT_FB 354 /* attempt allocating the client side framebuffer */ 355 Clientfb = GrOpenClientFramebuffer(); 356 /* NULL return will default to using GrArea()*/ 357 #endif 358 359 Dprintf ("leave NX_CreateWindow\n") ; 360 return 0 ; 361 } 362 363 SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current, 364 int width, int height, int bpp, Uint32 flags) 365 { 366 Dprintf ("enter NX_SetVideoMode\n") ; 367 368 // Lock the event thread, in multi-threading environments 369 SDL_Lock_EventThread () ; 370 371 bpp = SDL_Visual.bpp ; 372 if (NX_CreateWindow (this, current, width, height, bpp, flags) < 0) { 373 current = NULL; 374 goto done; 375 } 376 377 if (current -> w != width || current -> h != height) { 378 current -> w = width ; 379 current -> h = height ; 380 current -> pitch = SDL_CalculatePitch (current) ; 381 NX_ResizeImage (this, current, flags) ; 382 } 383 384 /* Clear these flags and set them only if they are in the new set. */ 385 current -> flags &= ~(SDL_RESIZABLE|SDL_NOFRAME); 386 current -> flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME)) ; 387 388 done: 389 SDL_Unlock_EventThread () ; 390 391 Dprintf ("leave NX_SetVideoMode\n") ; 392 393 // We're done! 394 return current ; 395 } 396 397 // ncolors <= 256 398 int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) 399 { 400 int i ; 401 GR_PALETTE pal ; 402 403 Dprintf ("enter NX_SetColors\n") ; 404 405 if (ncolors > 256) return 0 ; 406 407 pal.count = ncolors ; 408 for (i = 0; i < ncolors; ++ i) { 409 pal.palette [i].r = colors [i].r ; 410 pal.palette [i].g = colors [i].g ; 411 pal.palette [i].b = colors [i].b ; 412 } 413 GrSetSystemPalette (firstcolor, & pal) ; 414 415 Dprintf ("leave NX_SetColors\n") ; 416 return 1 ; 417 } 418 419 static int NX_ToggleFullScreen (_THIS, int on) 420 { 421 SDL_Rect rect ; 422 Uint32 event_thread ; 423 424 Dprintf ("enter NX_ToggleFullScreen\n") ; 425 426 // Don't switch if we don't own the window 427 if (SDL_windowid) return 0 ; 428 429 // Don't lock if we are the event thread 430 event_thread = SDL_EventThreadID () ; 431 if (event_thread && (SDL_ThreadID () == event_thread)) { 432 event_thread = 0 ; 433 } 434 if (event_thread) { 435 SDL_Lock_EventThread() ; 436 } 437 438 if (on) { 439 NX_EnterFullScreen (this) ; 440 } else { 441 this -> screen -> flags &= ~ SDL_FULLSCREEN ; 442 NX_LeaveFullScreen (this) ; 443 } 444 445 rect.x = rect.y = 0 ; 446 rect.w = this -> screen -> w, rect.h = this -> screen -> h ; 447 NX_NormalUpdate (this, 1, & rect) ; 448 449 if (event_thread) { 450 SDL_Unlock_EventThread () ; 451 } 452 453 Dprintf ("leave NX_ToggleFullScreen\n") ; 454 return 1 ; 455 } 456 457 // Update the current mouse state and position 458 static void NX_UpdateMouse (_THIS) 459 { 460 int x, y ; 461 GR_WINDOW_INFO info ; 462 GR_SCREEN_INFO si ; 463 464 465 Dprintf ("enter NX_UpdateMouse\n") ; 466 467 // Lock the event thread, in multi-threading environments 468 SDL_Lock_EventThread () ; 469 470 GrGetScreenInfo (& si) ; 471 GrGetWindowInfo (SDL_Window, & info) ; 472 x = si.xpos - info.x ; 473 y = si.ypos - info.y ; 474 if (x >= 0 && x <= info.width && y >= 0 && y <= info.height) { 475 SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ; 476 SDL_PrivateMouseMotion (0, 0, x, y); 477 } else { 478 SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ; 479 } 480 481 SDL_Unlock_EventThread () ; 482 Dprintf ("leave NX_UpdateMouse\n") ; 483 } 484 485 static int NX_SetGammaRamp (_THIS, Uint16 * ramp) 486 { 487 int i ; 488 Uint16 * red, * green, * blue ; 489 490 Dprintf ("enter NX_SetGammaRamp\n") ; 491 492 if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ; 493 494 if (! GammaRamp_R) GammaRamp_R = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ; 495 if (! GammaRamp_G) GammaRamp_G = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ; 496 if (! GammaRamp_B) GammaRamp_B = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ; 497 if ((! GammaRamp_R) || (! GammaRamp_G) || (! GammaRamp_B)) { 498 SDL_OutOfMemory () ; 499 return -1 ; 500 } 501 502 for (i = 0; i < CI_SIZE; ++ i) 503 GammaRamp_R [i] = GammaRamp_G [i] = GammaRamp_B [i] = i ; 504 505 red = ramp ; 506 green = ramp + CI_SIZE ; 507 blue = green + CI_SIZE ; 508 509 for (i = 0; i < CI_SIZE; ++ i) { 510 GammaRamp_R [i] = red [i] ; 511 GammaRamp_G [i] = green [i] ; 512 GammaRamp_B [i] = blue [i] ; 513 } 514 SDL_UpdateRect(this->screen, 0, 0, 0, 0); 515 516 Dprintf ("leave NX_SetGammaRamp\n") ; 517 return 0 ; 518 } 519 520 static int NX_GetGammaRamp (_THIS, Uint16 * ramp) 521 { 522 int i ; 523 Uint16 * red, * green, * blue ; 524 525 Dprintf ("enter NX_GetGammaRamp\n") ; 526 527 if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ; 528 red = ramp ; 529 green = ramp + CI_SIZE ; 530 blue = green + CI_SIZE ; 531 if (GammaRamp_R && GammaRamp_G && GammaRamp_B) { 532 for (i = 0; i < CI_SIZE; ++ i) { 533 red [i] = GammaRamp_R [i] ; 534 green [i] = GammaRamp_G [i] ; 535 blue [i] = GammaRamp_B [i] ; 536 } 537 } else { 538 for (i = 0; i < CI_SIZE; ++ i) 539 red [i] = green [i] = blue [i] = i ; 540 } 541 542 Dprintf ("leave NX_GetGammaRamp\n") ; 543 return 0 ; 544 } 545
