src/video/SDL_video.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 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     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21 */
  22 #include "SDL_config.h"
  23
  24 /* The high-level video driver subsystem */
  25
  26 #include "SDL.h"
  27 #include "SDL_sysvideo.h"
  28 #include "SDL_blit.h"
  29 #include "SDL_pixels_c.h"
  30 #include "SDL_cursor_c.h"
  31 #include "../events/SDL_sysevents.h"
  32 #include "../events/SDL_events_c.h"
  33
  34 /* Available video drivers */
  35 static VideoBootStrap *bootstrap[] = {
  36 #if SDL_VIDEO_DRIVER_QUARTZ
  37         &QZ_bootstrap,
  38 #endif
  39 #if SDL_VIDEO_DRIVER_X11
  40         &X11_bootstrap,
  41 #endif
  42 #if SDL_VIDEO_DRIVER_DGA
  43         &DGA_bootstrap,
  44 #endif
  45 #if SDL_VIDEO_DRIVER_NANOX
  46         &NX_bootstrap,
  47 #endif
  48 #if SDL_VIDEO_DRIVER_IPOD
  49         &iPod_bootstrap,
  50 #endif
  51 #if SDL_VIDEO_DRIVER_QTOPIA
  52         &Qtopia_bootstrap,
  53 #endif
  54 #if SDL_VIDEO_DRIVER_WSCONS
  55         &WSCONS_bootstrap,
  56 #endif
  57 #if SDL_VIDEO_DRIVER_FBCON
  58         &FBCON_bootstrap,
  59 #endif
  60 #if SDL_VIDEO_DRIVER_DIRECTFB
  61         &DirectFB_bootstrap,
  62 #endif
  63 #if SDL_VIDEO_DRIVER_PS2GS
  64         &PS2GS_bootstrap,
  65 #endif
  66 #if SDL_VIDEO_DRIVER_PS3
  67         &PS3_bootstrap,
  68 #endif
  69 #if SDL_VIDEO_DRIVER_GGI
  70         &GGI_bootstrap,
  71 #endif
  72 #if SDL_VIDEO_DRIVER_VGL
  73         &VGL_bootstrap,
  74 #endif
  75 #if SDL_VIDEO_DRIVER_SVGALIB
  76         &SVGALIB_bootstrap,
  77 #endif
  78 #if SDL_VIDEO_DRIVER_GAPI
  79         &GAPI_bootstrap,
  80 #endif
  81 #if SDL_VIDEO_DRIVER_WINDIB
  82         &WINDIB_bootstrap,
  83 #endif
  84 #if SDL_VIDEO_DRIVER_DDRAW
  85         &DIRECTX_bootstrap,
  86 #endif
  87 #if SDL_VIDEO_DRIVER_BWINDOW
  88         &BWINDOW_bootstrap,
  89 #endif
  90 #if SDL_VIDEO_DRIVER_TOOLBOX
  91         &TOOLBOX_bootstrap,
  92 #endif
  93 #if SDL_VIDEO_DRIVER_DRAWSPROCKET
  94         &DSp_bootstrap,
  95 #endif
  96 #if SDL_VIDEO_DRIVER_PHOTON
  97         &ph_bootstrap,
  98 #endif
  99 #if SDL_VIDEO_DRIVER_EPOC
 100         &EPOC_bootstrap,
 101 #endif
 102 #if SDL_VIDEO_DRIVER_XBIOS
 103         &XBIOS_bootstrap,
 104 #endif
 105 #if SDL_VIDEO_DRIVER_GEM
 106         &GEM_bootstrap,
 107 #endif
 108 #if SDL_VIDEO_DRIVER_PICOGUI
 109         &PG_bootstrap,
 110 #endif
 111 #if SDL_VIDEO_DRIVER_DC
 112         &DC_bootstrap,
 113 #endif
 114 #if SDL_VIDEO_DRIVER_NDS
 115         &NDS_bootstrap,
 116 #endif
 117 #if SDL_VIDEO_DRIVER_RISCOS
 118         &RISCOS_bootstrap,
 119 #endif
 120 #if SDL_VIDEO_DRIVER_OS2FS
 121         &OS2FSLib_bootstrap,
 122 #endif
 123 #if SDL_VIDEO_DRIVER_AALIB
 124         &AALIB_bootstrap,
 125 #endif
 126 #if SDL_VIDEO_DRIVER_CACA
 127         &CACA_bootstrap,
 128 #endif
 129 #if SDL_VIDEO_DRIVER_DUMMY
 130         &DUMMY_bootstrap,
 131 #endif
 132         NULL
 133 };
 134
 135 SDL_VideoDevice *current_video = NULL;
 136
 137 /* Various local functions */
 138 int SDL_VideoInit(const char *driver_name, Uint32 flags);
 139 void SDL_VideoQuit(void);
 140 void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect* rects);
 141
 142 static SDL_GrabMode SDL_WM_GrabInputOff(void);
 143 #if SDL_VIDEO_OPENGL
 144 static int lock_count = 0;
 145 #endif
 146
 147
 148 /*
 149  * Initialize the video and event subsystems -- determine native pixel format
 150  */
 151 int SDL_VideoInit (const char *driver_name, Uint32 flags)
 152 {
 153         SDL_VideoDevice *video;
 154         int index;
 155         int i;
 156         SDL_PixelFormat vformat;
 157         Uint32 video_flags;
 158
 159         /* Toggle the event thread flags, based on OS requirements */
 160 #if defined(MUST_THREAD_EVENTS)
 161         flags |= SDL_INIT_EVENTTHREAD;
 162 #elif defined(CANT_THREAD_EVENTS)
 163         if ( (flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD ) {
 164                 SDL_SetError("OS doesn't support threaded events");
 165                 return(-1);
 166         }
 167 #endif
 168
 169         /* Check to make sure we don't overwrite 'current_video' */
 170         if ( current_video != NULL ) {
 171                 SDL_VideoQuit();
 172         }
 173
 174         /* Select the proper video driver */
 175         index = 0;
 176         video = NULL;
 177         if ( driver_name != NULL ) {
 178 #if 0   /* This will be replaced with a better driver selection API */
 179                 if ( SDL_strrchr(driver_name, ':') != NULL ) {
 180                         index = atoi(SDL_strrchr(driver_name, ':')+1);
 181                 }
 182 #endif
 183                 for ( i=0; bootstrap[i]; ++i ) {
 184                         if ( SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {
 185                                 if ( bootstrap[i]->available() ) {
 186                                         video = bootstrap[i]->create(index);
 187                                         break;
 188                                 }
 189                         }
 190                 }
 191         } else {
 192                 for ( i=0; bootstrap[i]; ++i ) {
 193                         if ( bootstrap[i]->available() ) {
 194                                 video = bootstrap[i]->create(index);
 195                                 if ( video != NULL ) {
 196                                         break;
 197                                 }
 198                         }
 199                 }
 200         }
 201         if ( video == NULL ) {
 202                 SDL_SetError("No available video device");
 203                 return(-1);
 204         }
 205         current_video = video;
 206         current_video->name = bootstrap[i]->name;
 207
 208         /* Do some basic variable initialization */
 209         video->screen = NULL;
 210         video->shadow = NULL;
 211         video->visible = NULL;
 212         video->physpal = NULL;
 213         video->gammacols = NULL;
 214         video->gamma = NULL;
 215         video->wm_title = NULL;
 216         video->wm_icon  = NULL;
 217         video->offset_x = 0;
 218         video->offset_y = 0;
 219         SDL_memset(&video->info, 0, (sizeof video->info));
 220
 221         video->displayformatalphapixel = NULL;
 222
 223         /* Set some very sane GL defaults */
 224         video->gl_config.driver_loaded = 0;
 225         video->gl_config.dll_handle = NULL;
 226         video->gl_config.red_size = 3;
 227         video->gl_config.green_size = 3;
 228         video->gl_config.blue_size = 2;
 229         video->gl_config.alpha_size = 0;
 230         video->gl_config.buffer_size = 0;
 231         video->gl_config.depth_size = 16;
 232         video->gl_config.stencil_size = 0;
 233         video->gl_config.double_buffer = 1;
 234         video->gl_config.accum_red_size = 0;
 235         video->gl_config.accum_green_size = 0;
 236         video->gl_config.accum_blue_size = 0;
 237         video->gl_config.accum_alpha_size = 0;
 238         video->gl_config.stereo = 0;
 239         video->gl_config.multisamplebuffers = 0;
 240         video->gl_config.multisamplesamples = 0;
 241         video->gl_config.accelerated = -1; /* not known, don't set */
 242         video->gl_config.swap_control = -1; /* not known, don't set */
 243
 244         /* Initialize the video subsystem */
 245         SDL_memset(&vformat, 0, sizeof(vformat));
 246         if ( video->VideoInit(video, &vformat) < 0 ) {
 247                 SDL_VideoQuit();
 248                 return(-1);
 249         }
 250
 251         /* Create a zero sized video surface of the appropriate format */
 252         video_flags = SDL_SWSURFACE;
 253         SDL_VideoSurface = SDL_CreateRGBSurface(video_flags, 0, 0,
 254                                 vformat.BitsPerPixel,
 255                                 vformat.Rmask, vformat.Gmask, vformat.Bmask, 0);
 256         if ( SDL_VideoSurface == NULL ) {
 257                 SDL_VideoQuit();
 258                 return(-1);
 259         }
 260         SDL_PublicSurface = NULL;       /* Until SDL_SetVideoMode() */
 261
 262 #if 0 /* Don't change the current palette - may be used by other programs.
 263        * The application can't do anything with the display surface until
 264        * a video mode has been set anyway. :)
 265        */
 266         /* If we have a palettized surface, create a default palette */
 267         if ( SDL_VideoSurface->format->palette ) {
 268                 SDL_PixelFormat *vf = SDL_VideoSurface->format;
 269                 SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel);
 270                 video->SetColors(video,
 271                                  0, vf->palette->ncolors, vf->palette->colors);
 272         }
 273 #endif
 274         video->info.vfmt = SDL_VideoSurface->format;
 275
 276         /* Start the event loop */
 277         if ( SDL_StartEventLoop(flags) < 0 ) {
 278                 SDL_VideoQuit();
 279                 return(-1);
 280         }
 281         SDL_CursorInit(flags & SDL_INIT_EVENTTHREAD);
 282
 283         /* We're ready to go! */
 284         return(0);
 285 }
 286
 287 char *SDL_VideoDriverName(char *namebuf, int maxlen)
 288 {
 289         if ( current_video != NULL ) {
 290                 SDL_strlcpy(namebuf, current_video->name, maxlen);
 291                 return(namebuf);
 292         }
 293         return(NULL);
 294 }
 295
 296 /*
 297  * Get the current display surface
 298  */
 299 SDL_Surface *SDL_GetVideoSurface(void)
 300 {
 301         SDL_Surface *visible;
 302
 303         visible = NULL;
 304         if ( current_video ) {
 305                 visible = current_video->visible;
 306         }
 307         return(visible);
 308 }
 309
 310 /*
 311  * Get the current information about the video hardware
 312  */
 313 const SDL_VideoInfo *SDL_GetVideoInfo(void)
 314 {
 315         const SDL_VideoInfo *info;
 316
 317         info = NULL;
 318         if ( current_video ) {
 319                 info = &current_video->info;
 320         }
 321         return(info);
 322 }
 323
 324 /*
 325  * Return a pointer to an array of available screen dimensions for the
 326  * given format, sorted largest to smallest.  Returns NULL if there are
 327  * no dimensions available for a particular format, or (SDL_Rect **)-1
 328  * if any dimension is okay for the given format.  If 'format' is NULL,
 329  * the mode list will be for the format given by SDL_GetVideoInfo()->vfmt
 330  */
 331 SDL_Rect ** SDL_ListModes (SDL_PixelFormat *format, Uint32 flags)
 332 {
 333         SDL_VideoDevice *video = current_video;
 334         SDL_VideoDevice *this  = current_video;
 335         SDL_Rect **modes;
 336
 337         modes = NULL;
 338         if ( SDL_VideoSurface ) {
 339                 if ( format == NULL ) {
 340                         format = SDL_VideoSurface->format;
 341                 }
 342                 modes = video->ListModes(this, format, flags);
 343         }
 344         return(modes);
 345 }
 346
 347 /*
 348  * Check to see if a particular video mode is supported.
 349  * It returns 0 if the requested mode is not supported under any bit depth,
 350  * or returns the bits-per-pixel of the closest available mode with the
 351  * given width and height.  If this bits-per-pixel is different from the
 352  * one used when setting the video mode, SDL_SetVideoMode() will succeed,
 353  * but will emulate the requested bits-per-pixel with a shadow surface.
 354  */
 355 static Uint8 SDL_closest_depths[4][8] = {
 356         /* 8 bit closest depth ordering */
 357         { 0, 8, 16, 15, 32, 24, 0, 0 },
 358         /* 15,16 bit closest depth ordering */
 359         { 0, 16, 15, 32, 24, 8, 0, 0 },
 360         /* 24 bit closest depth ordering */
 361         { 0, 24, 32, 16, 15, 8, 0, 0 },
 362         /* 32 bit closest depth ordering */
 363         { 0, 32, 16, 15, 24, 8, 0, 0 }
 364 };
 365
 366
 367 #ifdef __MACOS__ /* MPW optimization bug? */
 368 #define NEGATIVE_ONE 0xFFFFFFFF
 369 #else
 370 #define NEGATIVE_ONE -1
 371 #endif
 372
 373 int SDL_VideoModeOK (int width, int height, int bpp, Uint32 flags)
 374 {
 375         int table, b, i;
 376         int supported;
 377         SDL_PixelFormat format;
 378         SDL_Rect **sizes;
 379
 380         /* Currently 1 and 4 bpp are not supported */
 381         if ( bpp < 8 || bpp > 32 ) {
 382                 return(0);
 383         }
 384         if ( (width <= 0) || (height <= 0) ) {
 385                 return(0);
 386         }
 387
 388         /* Search through the list valid of modes */
 389         SDL_memset(&format, 0, sizeof(format));
 390         supported = 0;
 391         table = ((bpp+7)/8)-1;
 392         SDL_closest_depths[table][0] = bpp;
 393         SDL_closest_depths[table][7] = 0;
 394         for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) {
 395                 format.BitsPerPixel = SDL_closest_depths[table][b];
 396                 sizes = SDL_ListModes(&format, flags);
 397                 if ( sizes == (SDL_Rect **)0 ) {
 398                         /* No sizes supported at this bit-depth */
 399                         continue;
 400                 } else
 401                 if (sizes == (SDL_Rect **)NEGATIVE_ONE) {
 402                         /* Any size supported at this bit-depth */
 403                         supported = 1;
 404                         continue;
 405                 } else if (current_video->handles_any_size) {
 406                         /* Driver can center a smaller surface to simulate fullscreen */
 407                         for ( i=0; sizes[i]; ++i ) {
 408                                 if ((sizes[i]->w >= width) && (sizes[i]->h >= height)) {
 409                                         supported = 1; /* this mode can fit the centered window. */
 410                                         break;
 411                                 }
 412                         }
 413                 } else
 414                 for ( i=0; sizes[i]; ++i ) {
 415                         if ((sizes[i]->w == width) && (sizes[i]->h == height)) {
 416                                 supported = 1;
 417                                 break;
 418                         }
 419                 }
 420         }
 421         if ( supported ) {
 422                 --b;
 423                 return(SDL_closest_depths[table][b]);
 424         } else {
 425                 return(0);
 426         }
 427 }
 428
 429 /*
 430  * Get the closest non-emulated video mode to the one requested
 431  */
 432 static int SDL_GetVideoMode (int *w, int *h, int *BitsPerPixel, Uint32 flags)
 433 {
 434         int table, b, i;
 435         int supported;
 436         int native_bpp;
 437         SDL_PixelFormat format;
 438         SDL_Rect **sizes;
 439
 440         /* Check parameters */
 441         if ( *BitsPerPixel < 8 || *BitsPerPixel > 32 ) {
 442                 SDL_SetError("Invalid bits per pixel (range is {8...32})");
 443                 return(0);
 444         }
 445         if ((*w <= 0) || (*h <= 0)) {
 446                 SDL_SetError("Invalid width or height");
 447                 return(0);
 448         }
 449
 450         /* Try the original video mode, get the closest depth */
 451         native_bpp = SDL_VideoModeOK(*w, *h, *BitsPerPixel, flags);
 452         if ( native_bpp == *BitsPerPixel ) {
 453                 return(1);
 454         }
 455         if ( native_bpp > 0 ) {
 456                 *BitsPerPixel = native_bpp;
 457                 return(1);
 458         }
 459
 460         /* No exact size match at any depth, look for closest match */
 461         SDL_memset(&format, 0, sizeof(format));
 462         supported = 0;
 463         table = ((*BitsPerPixel+7)/8)-1;
 464         SDL_closest_depths[table][0] = *BitsPerPixel;
 465         SDL_closest_depths[table][7] = SDL_VideoSurface->format->BitsPerPixel;
 466         for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) {
 467                 int best;
 468
 469                 format.BitsPerPixel = SDL_closest_depths[table][b];
 470                 sizes = SDL_ListModes(&format, flags);
 471                 if ( sizes == (SDL_Rect **)0 ) {
 472                         /* No sizes supported at this bit-depth */
 473                         continue;
 474                 }
 475                 best=0;
 476                 for ( i=0; sizes[i]; ++i ) {
 477                         /* Mode with both dimensions bigger or equal than asked ? */
 478                         if ((sizes[i]->w >= *w) && (sizes[i]->h >= *h)) {
 479                                 /* Mode with any dimension smaller or equal than current best ? */
 480                                 if ((sizes[i]->w <= sizes[best]->w) || (sizes[i]->h <= sizes[best]->h)) {
 481                                         /* Now choose the mode that has less pixels */
 482                                         if ((sizes[i]->w * sizes[i]->h) <= (sizes[best]->w * sizes[best]->h)) {
 483                                                 best=i;
 484                                                 supported = 1;
 485                                         }
 486                                 }
 487                         }
 488                 }
 489                 if (supported) {
 490                         *w=sizes[best]->w;
 491                         *h=sizes[best]->h;
 492                         *BitsPerPixel = SDL_closest_depths[table][b];
 493                 }
 494         }
 495         if ( ! supported ) {
 496                 SDL_SetError("No video mode large enough for %dx%d", *w, *h);
 497         }
 498         return(supported);
 499 }
 500
 501 /* This should probably go somewhere else -- like SDL_surface.c */
 502 static void SDL_ClearSurface(SDL_Surface *surface)
 503 {
 504         Uint32 black;
 505
 506         black = SDL_MapRGB(surface->format, 0, 0, 0);
 507         SDL_FillRect(surface, NULL, black);
 508         if ((surface->flags&SDL_HWSURFACE) && (surface->flags&SDL_DOUBLEBUF)) {
 509                 SDL_Flip(surface);
 510                 SDL_FillRect(surface, NULL, black);
 511         }
 512         if (surface->flags&SDL_FULLSCREEN) {
 513                 SDL_Flip(surface);
 514         }
 515 }
 516
 517 /*
 518  * Create a shadow surface suitable for fooling the app. :-)
 519  */
 520 static void SDL_CreateShadowSurface(int depth)
 521 {
 522         Uint32 Rmask, Gmask, Bmask;
 523
 524         /* Allocate the shadow surface */
 525         if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) {
 526                 Rmask = (SDL_VideoSurface->format)->Rmask;
 527                 Gmask = (SDL_VideoSurface->format)->Gmask;
 528                 Bmask = (SDL_VideoSurface->format)->Bmask;
 529         } else {
 530                 Rmask = Gmask = Bmask = 0;
 531         }
 532         SDL_ShadowSurface = SDL_CreateRGBSurface(SDL_SWSURFACE,
 533                                 SDL_VideoSurface->w, SDL_VideoSurface->h,
 534                                                 depth, Rmask, Gmask, Bmask, 0);
 535         if ( SDL_ShadowSurface == NULL ) {
 536                 return;
 537         }
 538
 539         /* 8-bit shadow surfaces report that they have exclusive palette */
 540         if ( SDL_ShadowSurface->format->palette ) {
 541                 SDL_ShadowSurface->flags |= SDL_HWPALETTE;
 542                 if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) {
 543                         SDL_memcpy(SDL_ShadowSurface->format->palette->colors,
 544                                 SDL_VideoSurface->format->palette->colors,
 545                                 SDL_VideoSurface->format->palette->ncolors*
 546                                                         sizeof(SDL_Color));
 547                 } else {
 548                         SDL_DitherColors(
 549                         SDL_ShadowSurface->format->palette->colors, depth);
 550                 }
 551         }
 552
 553         /* If the video surface is resizable, the shadow should say so */
 554         if ( (SDL_VideoSurface->flags & SDL_RESIZABLE) == SDL_RESIZABLE ) {
 555                 SDL_ShadowSurface->flags |= SDL_RESIZABLE;
 556         }
 557         /* If the video surface has no frame, the shadow should say so */
 558         if ( (SDL_VideoSurface->flags & SDL_NOFRAME) == SDL_NOFRAME ) {
 559                 SDL_ShadowSurface->flags |= SDL_NOFRAME;
 560         }
 561         /* If the video surface is fullscreen, the shadow should say so */
 562         if ( (SDL_VideoSurface->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
 563                 SDL_ShadowSurface->flags |= SDL_FULLSCREEN;
 564         }
 565         /* If the video surface is flippable, the shadow should say so */
 566         if ( (SDL_VideoSurface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
 567                 SDL_ShadowSurface->flags |= SDL_DOUBLEBUF;
 568         }
 569         return;
 570 }
 571
 572 #ifdef __QNXNTO__
 573     #include <sys/neutrino.h>
 574 #endif /* __QNXNTO__ */
 575
 576 /*
 577  * Set the requested video mode, allocating a shadow buffer if necessary.
 578  */
 579 SDL_Surface * SDL_SetVideoMode (int width, int height, int bpp, Uint32 flags)
 580 {
 581         SDL_VideoDevice *video, *this;
 582         SDL_Surface *prev_mode, *mode;
 583         int video_w;
 584         int video_h;
 585         int video_bpp;
 586         int is_opengl;
 587         SDL_GrabMode saved_grab;
 588
 589         /* Start up the video driver, if necessary..
 590            WARNING: This is the only function protected this way!
 591          */
 592         if ( ! current_video ) {
 593                 if ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) < 0 ) {
 594                         return(NULL);
 595                 }
 596         }
 597         this = video = current_video;
 598
 599         /* Default to the current width and height */
 600         if ( width == 0 ) {
 601                 width = video->info.current_w;
 602         }
 603         if ( height == 0 ) {
 604                 height = video->info.current_h;
 605         }
 606         /* Default to the current video bpp */
 607         if ( bpp == 0 ) {
 608                 flags |= SDL_ANYFORMAT;
 609                 bpp = SDL_VideoSurface->format->BitsPerPixel;
 610         }
 611
 612         /* Get a good video mode, the closest one possible */
 613         video_w = width;
 614         video_h = height;
 615         video_bpp = bpp;
 616         if ( ! SDL_GetVideoMode(&video_w, &video_h, &video_bpp, flags) ) {
 617                 return(NULL);
 618         }
 619
 620         /* Check the requested flags */
 621         /* There's no palette in > 8 bits-per-pixel mode */
 622         if ( video_bpp > 8 ) {
 623                 flags &= ~SDL_HWPALETTE;
 624         }
 625 #if 0
 626         if ( (flags&SDL_FULLSCREEN) != SDL_FULLSCREEN ) {
 627                 /* There's no windowed double-buffering */
 628                 flags &= ~SDL_DOUBLEBUF;
 629         }
 630 #endif
 631         if ( (flags&SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
 632                 /* Use hardware surfaces when double-buffering */
 633                 flags |= SDL_HWSURFACE;
 634         }
 635
 636         is_opengl = ( ( flags & SDL_OPENGL ) == SDL_OPENGL );
 637         if ( is_opengl ) {
 638                 /* These flags are for 2D video modes only */
 639                 flags &= ~(SDL_HWSURFACE|SDL_DOUBLEBUF);
 640         }
 641
 642         /* Reset the keyboard here so event callbacks can run */
 643         SDL_ResetKeyboard();
 644         SDL_ResetMouse();
 645         SDL_SetMouseRange(width, height);
 646         SDL_cursorstate &= ~CURSOR_USINGSW;
 647
 648         /* Clean up any previous video mode */
 649         if ( SDL_PublicSurface != NULL ) {
 650                 SDL_PublicSurface = NULL;
 651         }
 652         if ( SDL_ShadowSurface != NULL ) {
 653                 SDL_Surface *ready_to_go;
 654                 ready_to_go = SDL_ShadowSurface;
 655                 SDL_ShadowSurface = NULL;
 656                 SDL_FreeSurface(ready_to_go);
 657         }
 658         if ( video->physpal ) {
 659                 SDL_free(video->physpal->colors);
 660                 SDL_free(video->physpal);
 661                 video->physpal = NULL;
 662         }
 663         if( video->gammacols) {
 664                 SDL_free(video->gammacols);
 665                 video->gammacols = NULL;
 666         }
 667
 668         /* Save the previous grab state and turn off grab for mode switch */
 669         saved_grab = SDL_WM_GrabInputOff();
 670
 671         /* Try to set the video mode, along with offset and clipping */
 672         prev_mode = SDL_VideoSurface;
 673         SDL_LockCursor();
 674         SDL_VideoSurface = NULL;        /* In case it's freed by driver */
 675         mode = video->SetVideoMode(this, prev_mode,video_w,video_h,video_bpp,flags);
 676         if ( mode ) { /* Prevent resize events from mode change */
 677           /* But not on OS/2 */
 678 #ifndef __OS2__
 679             SDL_PrivateResize(mode->w, mode->h);
 680 #endif
 681
 682             /* Sam - If we asked for OpenGL mode, and didn't get it, fail */
 683             if ( is_opengl && !(mode->flags & SDL_OPENGL) ) {
 684                 mode = NULL;
 685                 SDL_SetError("OpenGL not available");
 686             }
 687         }
 688         /*
 689          * rcg11292000
 690          * If you try to set an SDL_OPENGL surface, and fail to find a
 691          * matching  visual, then the next call to SDL_SetVideoMode()
 692          * will segfault, since  we no longer point to a dummy surface,
 693          * but rather NULL.
 694          * Sam 11/29/00
 695          * WARNING, we need to make sure that the previous mode hasn't
 696          * already been freed by the video driver.  What do we do in
 697          * that case?  Should we call SDL_VideoInit() again?
 698          */
 699         SDL_VideoSurface = (mode != NULL) ? mode : prev_mode;
 700
 701         if ( (mode != NULL) && (!is_opengl) ) {
 702                 /* Sanity check */
 703                 if ( (mode->w < width) || (mode->h < height) ) {
 704                         SDL_SetError("Video mode smaller than requested");
 705                         return(NULL);
 706                 }
 707
 708                 /* If we have a palettized surface, create a default palette */
 709                 if ( mode->format->palette ) {
 710                         SDL_PixelFormat *vf = mode->format;
 711                         SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel);
 712                         video->SetColors(this, 0, vf->palette->ncolors,
 713                                                    vf->palette->colors);
 714                 }
 715
 716                 /* Clear the surface to black */
 717                 video->offset_x = 0;
 718                 video->offset_y = 0;
 719                 mode->offset = 0;
 720                 SDL_SetClipRect(mode, NULL);
 721                 SDL_ClearSurface(mode);
 722
 723                 /* Now adjust the offsets to match the desired mode */
 724                 video->offset_x = (mode->w-width)/2;
 725                 video->offset_y = (mode->h-height)/2;
 726                 mode->offset = video->offset_y*mode->pitch +
 727                                 video->offset_x*mode->format->BytesPerPixel;
 728 #ifdef DEBUG_VIDEO
 729   fprintf(stderr,
 730         "Requested mode: %dx%dx%d, obtained mode %dx%dx%d (offset %d)\n",
 731                 width, height, bpp,
 732                 mode->w, mode->h, mode->format->BitsPerPixel, mode->offset);
 733 #endif
 734                 mode->w = width;
 735                 mode->h = height;
 736                 SDL_SetClipRect(mode, NULL);
 737         }
 738         SDL_ResetCursor();
 739         SDL_UnlockCursor();
 740
 741         /* If we failed setting a video mode, return NULL... (Uh Oh!) */
 742         if ( mode == NULL ) {
 743                 return(NULL);
 744         }
 745
 746         /* If there is no window manager, set the SDL_NOFRAME flag */
 747         if ( ! video->info.wm_available ) {
 748                 mode->flags |= SDL_NOFRAME;
 749         }
 750
 751         /* Reset the mouse cursor and grab for new video mode */
 752         SDL_SetCursor(NULL);
 753         if ( video->UpdateMouse ) {
 754                 video->UpdateMouse(this);
 755         }
 756         SDL_WM_GrabInput(saved_grab);
 757         SDL_GetRelativeMouseState(NULL, NULL); /* Clear first large delta */
 758
 759 #if SDL_VIDEO_OPENGL
 760         /* Load GL symbols (before MakeCurrent, where we need glGetString). */
 761         if ( flags & (SDL_OPENGL | SDL_OPENGLBLIT) ) {
 762
 763 #if defined(__QNXNTO__) && (_NTO_VERSION < 630)
 764 #define __SDL_NOGETPROCADDR__
 765 #elif defined(__MINT__)
 766 #define __SDL_NOGETPROCADDR__
 767 #endif
 768 #ifdef __SDL_NOGETPROCADDR__
 769     #define SDL_PROC(ret,func,params) video->func=func;
 770 #else
 771     #define SDL_PROC(ret,func,params) \
 772     do { \
 773         video->func = SDL_GL_GetProcAddress(#func); \
 774         if ( ! video->func ) { \
 775             SDL_SetError("Couldn't load GL function %s: %s\n", #func, SDL_GetError()); \
 776         return(NULL); \
 777         } \
 778     } while ( 0 );
 779
 780 #endif /* __SDL_NOGETPROCADDR__ */
 781
 782 #include "SDL_glfuncs.h"
 783 #undef SDL_PROC
 784         }
 785 #endif /* SDL_VIDEO_OPENGL */
 786
 787         /* If we're running OpenGL, make the context current */
 788         if ( (video->screen->flags & SDL_OPENGL) &&
 789               video->GL_MakeCurrent ) {
 790                 if ( video->GL_MakeCurrent(this) < 0 ) {
 791                         return(NULL);
 792                 }
 793         }
 794
 795         /* Set up a fake SDL surface for OpenGL "blitting" */
 796         if ( (flags & SDL_OPENGLBLIT) == SDL_OPENGLBLIT ) {
 797                 /* Load GL functions for performing the texture updates */
 798 #if SDL_VIDEO_OPENGL
 799
 800                 /* Create a software surface for blitting */
 801 #ifdef GL_VERSION_1_2
 802                 /* If the implementation either supports the packed pixels
 803                    extension, or implements the core OpenGL 1.2 API, it will
 804                    support the GL_UNSIGNED_SHORT_5_6_5 texture format.
 805                  */
 806                 if ( (bpp == 16) &&
 807                      (SDL_strstr((const char *)video->glGetString(GL_EXTENSIONS), "GL_EXT_packed_pixels") ||
 808                      (SDL_atof((const char *)video->glGetString(GL_VERSION)) >= 1.2f))
 809                    ) {
 810                         video->is_32bit = 0;
 811                         SDL_VideoSurface = SDL_CreateRGBSurface(
 812                                 flags,
 813                                 width,
 814                                 height,
 815                                 16,
 816                                 31 << 11,
 817                                 63 << 5,
 818                                 31,
 819                                 0
 820                                 );
 821                 }
 822                 else
 823 #endif /* OpenGL 1.2 */
 824                 {
 825                         video->is_32bit = 1;
 826                         SDL_VideoSurface = SDL_CreateRGBSurface(
 827                                 flags,
 828                                 width,
 829                                 height,
 830                                 32,
 831 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
 832                                 0x000000FF,
 833                                 0x0000FF00,
 834                                 0x00FF0000,
 835                                 0xFF000000
 836 #else
 837                                 0xFF000000,
 838                                 0x00FF0000,
 839                                 0x0000FF00,
 840                                 0x000000FF
 841 #endif
 842                                 );
 843                 }
 844                 if ( ! SDL_VideoSurface ) {
 845                         return(NULL);
 846                 }
 847                 SDL_VideoSurface->flags = mode->flags | SDL_OPENGLBLIT;
 848
 849                 /* Free the original video mode surface (is this safe?) */
 850                 SDL_FreeSurface(mode);
 851
 852                 /* Set the surface completely opaque & white by default */
 853                 SDL_memset( SDL_VideoSurface->pixels, 255, SDL_VideoSurface->h * SDL_VideoSurface->pitch );
 854                 video->glGenTextures( 1, &video->texture );
 855                 video->glBindTexture( GL_TEXTURE_2D, video->texture );
 856                 video->glTexImage2D(
 857                         GL_TEXTURE_2D,
 858                         0,
 859                         video->is_32bit ? GL_RGBA : GL_RGB,
 860                         256,
 861                         256,
 862                         0,
 863                         video->is_32bit ? GL_RGBA : GL_RGB,
 864 #ifdef GL_VERSION_1_2
 865                         video->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5,
 866 #else
 867                         GL_UNSIGNED_BYTE,
 868 #endif
 869                         NULL);
 870
 871                 video->UpdateRects = SDL_GL_UpdateRectsLock;
 872 #else
 873                 SDL_SetError("Somebody forgot to #define SDL_VIDEO_OPENGL");
 874                 return(NULL);
 875 #endif
 876         }
 877
 878         /* Create a shadow surface if necessary */
 879         /* There are three conditions under which we create a shadow surface:
 880                 1.  We need a particular bits-per-pixel that we didn't get.
 881                 2.  We need a hardware palette and didn't get one.
 882                 3.  We need a software surface and got a hardware surface.
 883         */
 884         if ( !(SDL_VideoSurface->flags & SDL_OPENGL) &&
 885              (
 886              (  !(flags&SDL_ANYFORMAT) &&
 887                         (SDL_VideoSurface->format->BitsPerPixel != bpp)) ||
 888              (   (flags&SDL_HWPALETTE) &&
 889                                 !(SDL_VideoSurface->flags&SDL_HWPALETTE)) ||
 890                 /* If the surface is in hardware, video writes are visible
 891                    as soon as they are performed, so we need to buffer them
 892                  */
 893              (   ((flags&SDL_HWSURFACE) == SDL_SWSURFACE) &&
 894                                 (SDL_VideoSurface->flags&SDL_HWSURFACE)) ||
 895              (   (flags&SDL_DOUBLEBUF) &&
 896                                 (SDL_VideoSurface->flags&SDL_HWSURFACE) &&
 897                                 !(SDL_VideoSurface->flags&SDL_DOUBLEBUF))
 898              ) ) {
 899                 SDL_CreateShadowSurface(bpp);
 900                 if ( SDL_ShadowSurface == NULL ) {
 901                         SDL_SetError("Couldn't create shadow surface");
 902                         return(NULL);
 903                 }
 904                 SDL_PublicSurface = SDL_ShadowSurface;
 905         } else {
 906                 SDL_PublicSurface = SDL_VideoSurface;
 907         }
 908         video->info.vfmt = SDL_VideoSurface->format;
 909         video->info.current_w = SDL_VideoSurface->w;
 910         video->info.current_h = SDL_VideoSurface->h;
 911
 912         /* We're done! */
 913         return(SDL_PublicSurface);
 914 }
 915
 916 /*
 917  * Convert a surface into the video pixel format.
 918  */
 919 SDL_Surface * SDL_DisplayFormat (SDL_Surface *surface)
 920 {
 921         Uint32 flags;
 922
 923         if ( ! SDL_PublicSurface ) {
 924                 SDL_SetError("No video mode has been set");
 925                 return(NULL);
 926         }
 927         /* Set the flags appropriate for copying to display surface */
 928         if (((SDL_PublicSurface->flags&SDL_HWSURFACE) == SDL_HWSURFACE) && current_video->info.blit_hw)
 929                 flags = SDL_HWSURFACE;
 930         else
 931                 flags = SDL_SWSURFACE;
 932 #ifdef AUTORLE_DISPLAYFORMAT
 933         flags |= (surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA));
 934         flags |= SDL_RLEACCELOK;
 935 #else
 936         flags |= surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA|SDL_RLEACCELOK);
 937 #endif
 938         return(SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags));
 939 }
 940
 941 /*
 942  * Convert a surface into a format that's suitable for blitting to
 943  * the screen, but including an alpha channel.
 944  */
 945 SDL_Surface *SDL_DisplayFormatAlpha(SDL_Surface *surface)
 946 {
 947         SDL_PixelFormat *vf;
 948         SDL_PixelFormat *format;
 949         SDL_Surface *converted;
 950         Uint32 flags;
 951         /* default to ARGB8888 */
 952         Uint32 amask = 0xff000000;
 953         Uint32 rmask = 0x00ff0000;
 954         Uint32 gmask = 0x0000ff00;
 955         Uint32 bmask = 0x000000ff;
 956
 957         if ( ! SDL_PublicSurface ) {
 958                 SDL_SetError("No video mode has been set");
 959                 return(NULL);
 960         }
 961         vf = SDL_PublicSurface->format;
 962
 963         switch(vf->BytesPerPixel) {
 964             case 2:
 965                 /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}.
 966                    For anything else (like ARGB4444) it doesn't matter
 967                    since we have no special code for it anyway */
 968                 if ( (vf->Rmask == 0x1f) &&
 969                      (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) {
 970                         rmask = 0xff;
 971                         bmask = 0xff0000;
 972                 }
 973                 break;
 974
 975             case 3:
 976             case 4:
 977                 /* Keep the video format, as long as the high 8 bits are
 978                    unused or alpha */
 979                 if ( (vf->Rmask == 0xff) && (vf->Bmask == 0xff0000) ) {
 980                         rmask = 0xff;
 981                         bmask = 0xff0000;
 982                 }
 983                 break;
 984
 985             default:
 986                 /* We have no other optimised formats right now. When/if a new
 987                    optimised alpha format is written, add the converter here */
 988                 break;
 989         }
 990         format = SDL_AllocFormat(32, rmask, gmask, bmask, amask);
 991         flags = SDL_PublicSurface->flags & SDL_HWSURFACE;
 992         flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
 993         converted = SDL_ConvertSurface(surface, format, flags);
 994         SDL_FreeFormat(format);
 995         return(converted);
 996 }
 997
 998 /*
 999  * Update a specific portion of the physical screen
1000  */
1001 void SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h)
1002 {
1003         if ( screen ) {
1004                 SDL_Rect rect;
1005
1006                 /* Perform some checking */
1007                 if ( w == 0 )
1008                         w = screen->w;
1009                 if ( h == 0 )
1010                         h = screen->h;
1011                 if ( (int)(x+w) > screen->w )
1012                         return;
1013                 if ( (int)(y+h) > screen->h )
1014                         return;
1015
1016                 /* Fill the rectangle */
1017                 rect.x = (Sint16)x;
1018                 rect.y = (Sint16)y;
1019                 rect.w = (Uint16)w;
1020                 rect.h = (Uint16)h;
1021                 SDL_UpdateRects(screen, 1, &rect);
1022         }
1023 }
1024 void SDL_UpdateRects (SDL_Surface *screen, int numrects, SDL_Rect *rects)
1025 {
1026         int i;
1027         SDL_VideoDevice *video = current_video;
1028         SDL_VideoDevice *this = current_video;
1029
1030         if ( (screen->flags & (SDL_OPENGL | SDL_OPENGLBLIT)) == SDL_OPENGL ) {
1031                 SDL_SetError("OpenGL active, use SDL_GL_SwapBuffers()");
1032                 return;
1033         }
1034         if ( screen == SDL_ShadowSurface ) {
1035                 /* Blit the shadow surface using saved mapping */
1036                 SDL_Palette *pal = screen->format->palette;
1037                 SDL_Color *saved_colors = NULL;
1038                 if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) {
1039                         /* simulated 8bpp, use correct physical palette */
1040                         saved_colors = pal->colors;
1041                         if ( video->gammacols ) {
1042                                 /* gamma-corrected palette */
1043                                 pal->colors = video->gammacols;
1044                         } else if ( video->physpal ) {
1045                                 /* physical palette different from logical */
1046                                 pal->colors = video->physpal->colors;
1047                         }
1048                 }
1049                 if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
1050                         SDL_LockCursor();
1051                         SDL_DrawCursor(SDL_ShadowSurface);
1052                         for ( i=0; i<numrects; ++i ) {
1053                                 SDL_LowerBlit(SDL_ShadowSurface, &rects[i],
1054                                                 SDL_VideoSurface, &rects[i]);
1055                         }
1056                         SDL_EraseCursor(SDL_ShadowSurface);
1057                         SDL_UnlockCursor();
1058                 } else {
1059                         for ( i=0; i<numrects; ++i ) {
1060                                 SDL_LowerBlit(SDL_ShadowSurface, &rects[i],
1061                                                 SDL_VideoSurface, &rects[i]);
1062                         }
1063                 }
1064                 if ( saved_colors ) {
1065                         pal->colors = saved_colors;
1066                 }
1067
1068                 /* Fall through to video surface update */
1069                 screen = SDL_VideoSurface;
1070         }
1071         if ( screen == SDL_VideoSurface ) {
1072                 /* Update the video surface */
1073                 if ( screen->offset ) {
1074                         for ( i=0; i<numrects; ++i ) {
1075                                 rects[i].x += video->offset_x;
1076                                 rects[i].y += video->offset_y;
1077                         }
1078                         video->UpdateRects(this, numrects, rects);
1079                         for ( i=0; i<numrects; ++i ) {
1080                                 rects[i].x -= video->offset_x;
1081                                 rects[i].y -= video->offset_y;
1082                         }
1083                 } else {
1084                         video->UpdateRects(this, numrects, rects);
1085                 }
1086         }
1087 }
1088
1089 /*
1090  * Performs hardware double buffering, if possible, or a full update if not.
1091  */
1092 int SDL_Flip(SDL_Surface *screen)
1093 {
1094         SDL_VideoDevice *video = current_video;
1095         /* Copy the shadow surface to the video surface */
1096         if ( screen == SDL_ShadowSurface ) {
1097                 SDL_Rect rect;
1098                 SDL_Palette *pal = screen->format->palette;
1099                 SDL_Color *saved_colors = NULL;
1100                 if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) {
1101                         /* simulated 8bpp, use correct physical palette */
1102                         saved_colors = pal->colors;
1103                         if ( video->gammacols ) {
1104                                 /* gamma-corrected palette */
1105                                 pal->colors = video->gammacols;
1106                         } else if ( video->physpal ) {
1107                                 /* physical palette different from logical */
1108                                 pal->colors = video->physpal->colors;
1109                         }
1110                 }
1111
1112                 rect.x = 0;
1113                 rect.y = 0;
1114                 rect.w = screen->w;
1115                 rect.h = screen->h;
1116                 if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
1117                         SDL_LockCursor();
1118                         SDL_DrawCursor(SDL_ShadowSurface);
1119                         SDL_LowerBlit(SDL_ShadowSurface, &rect,
1120                                         SDL_VideoSurface, &rect);
1121                         SDL_EraseCursor(SDL_ShadowSurface);
1122                         SDL_UnlockCursor();
1123                 } else {
1124                         SDL_LowerBlit(SDL_ShadowSurface, &rect,
1125                                         SDL_VideoSurface, &rect);
1126                 }
1127                 if ( saved_colors ) {
1128                         pal->colors = saved_colors;
1129                 }
1130
1131                 /* Fall through to video surface update */
1132                 screen = SDL_VideoSurface;
1133         }
1134         if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
1135                 SDL_VideoDevice *this  = current_video;
1136                 return(video->FlipHWSurface(this, SDL_VideoSurface));
1137         } else {
1138                 SDL_UpdateRect(screen, 0, 0, 0, 0);
1139         }
1140         return(0);
1141 }
1142
1143 static void SetPalette_logical(SDL_Surface *screen, SDL_Color *colors,
1144                                int firstcolor, int ncolors)
1145 {
1146         SDL_Palette *pal = screen->format->palette;
1147         SDL_Palette *vidpal;
1148
1149         if ( colors != (pal->colors + firstcolor) ) {
1150                 SDL_memcpy(pal->colors + firstcolor, colors,
1151                        ncolors * sizeof(*colors));
1152         }
1153
1154         if ( current_video && SDL_VideoSurface ) {
1155                 vidpal = SDL_VideoSurface->format->palette;
1156                 if ( (screen == SDL_ShadowSurface) && vidpal ) {
1157                         /*
1158                          * This is a shadow surface, and the physical
1159                          * framebuffer is also indexed. Propagate the
1160                          * changes to its logical palette so that
1161                          * updates are always identity blits
1162                          */
1163                         SDL_memcpy(vidpal->colors + firstcolor, colors,
1164                                ncolors * sizeof(*colors));
1165                 }
1166         }
1167         SDL_FormatChanged(screen);
1168 }
1169
1170 static int SetPalette_physical(SDL_Surface *screen,
1171                                SDL_Color *colors, int firstcolor, int ncolors)
1172 {
1173         SDL_VideoDevice *video = current_video;
1174         int gotall = 1;
1175
1176         if ( video->physpal ) {
1177                 /* We need to copy the new colors, since we haven't
1178                  * already done the copy in the logical set above.
1179                  */
1180                 SDL_memcpy(video->physpal->colors + firstcolor,
1181                        colors, ncolors * sizeof(*colors));
1182         }
1183         if ( screen == SDL_ShadowSurface ) {
1184                 if ( SDL_VideoSurface->flags & SDL_HWPALETTE ) {
1185                         /*
1186                          * The real screen is also indexed - set its physical
1187                          * palette. The physical palette does not include the
1188                          * gamma modification, we apply it directly instead,
1189                          * but this only happens if we have hardware palette.
1190                          */
1191                         screen = SDL_VideoSurface;
1192                 } else {
1193                         /*
1194                          * The video surface is not indexed - invalidate any
1195                          * active shadow-to-video blit mappings.
1196                          */
1197                         if ( screen->map->dst == SDL_VideoSurface ) {
1198                                 SDL_InvalidateMap(screen->map);
1199                         }
1200                         if ( video->gamma ) {
1201                                 if( ! video->gammacols ) {
1202                                         SDL_Palette *pp = video->physpal;
1203                                         if(!pp)
1204                                                 pp = screen->format->palette;
1205                                         video->gammacols = SDL_malloc(pp->ncolors
1206                                                           * sizeof(SDL_Color));
1207                                         SDL_ApplyGamma(video->gamma,
1208                                                        pp->colors,
1209                                                        video->gammacols,
1210                                                        pp->ncolors);
1211                                 } else {
1212                                         SDL_ApplyGamma(video->gamma, colors,
1213                                                        video->gammacols
1214                                                        + firstcolor,
1215                                                        ncolors);
1216                                 }
1217                         }
1218                         SDL_UpdateRect(screen, 0, 0, 0, 0);
1219                 }
1220         }
1221
1222         if ( screen == SDL_VideoSurface ) {
1223                 SDL_Color gcolors[256];
1224
1225                 if ( video->gamma ) {
1226                         SDL_ApplyGamma(video->gamma, colors, gcolors, ncolors);
1227                         colors = gcolors;
1228                 }
1229                 gotall = video->SetColors(video, firstcolor, ncolors, colors);
1230                 if ( ! gotall ) {
1231                         /* The video flags shouldn't have SDL_HWPALETTE, and
1232                            the video driver is responsible for copying back the
1233                            correct colors into the video surface palette.
1234                         */
1235                         ;
1236                 }
1237                 SDL_CursorPaletteChanged();
1238         }
1239         return gotall;
1240 }
1241
1242 /*
1243  * Set the physical and/or logical colormap of a surface:
1244  * Only the screen has a physical colormap. It determines what is actually
1245  * sent to the display.
1246  * The logical colormap is used to map blits to/from the surface.
1247  * 'which' is one or both of SDL_LOGPAL, SDL_PHYSPAL
1248  *
1249  * Return nonzero if all colours were set as requested, or 0 otherwise.
1250  */
1251 int SDL_SetPalette(SDL_Surface *screen, int which,
1252                    SDL_Color *colors, int firstcolor, int ncolors)
1253 {
1254         SDL_Palette *pal;
1255         int gotall;
1256         int palsize;
1257
1258         if ( !screen ) {
1259                 return 0;
1260         }
1261         if ( !current_video || screen != SDL_PublicSurface ) {
1262                 /* only screens have physical palettes */
1263                 which &= ~SDL_PHYSPAL;
1264         } else if ( (screen->flags & SDL_HWPALETTE) != SDL_HWPALETTE ) {
1265                 /* hardware palettes required for split colormaps */
1266                 which |= SDL_PHYSPAL | SDL_LOGPAL;
1267         }
1268
1269         /* Verify the parameters */
1270         pal = screen->format->palette;
1271         if( !pal ) {
1272                 return 0;       /* not a palettized surface */
1273         }
1274         gotall = 1;
1275         palsize = 1 << screen->format->BitsPerPixel;
1276         if ( ncolors > (palsize - firstcolor) ) {
1277                 ncolors = (palsize - firstcolor);
1278                 gotall = 0;
1279         }
1280
1281         if ( which & SDL_LOGPAL ) {
1282                 /*
1283                  * Logical palette change: The actual screen isn't affected,
1284                  * but the internal colormap is altered so that the
1285                  * interpretation of the pixel values (for blits etc) is
1286                  * changed.
1287                  */
1288                 SetPalette_logical(screen, colors, firstcolor, ncolors);
1289         }
1290         if ( which & SDL_PHYSPAL ) {
1291                 SDL_VideoDevice *video = current_video;
1292                 /*
1293                  * Physical palette change: This doesn't affect the
1294                  * program's idea of what the screen looks like, but changes
1295                  * its actual appearance.
1296                  */
1297                 if ( !video->physpal && !(which & SDL_LOGPAL) ) {
1298                         /* Lazy physical palette allocation */
1299                         int size;
1300                         SDL_Palette *pp = SDL_malloc(sizeof(*pp));
1301                         if ( !pp ) {
1302                                 return 0;
1303                         }
1304                         video->physpal = pp;
1305                         pp->ncolors = pal->ncolors;
1306                         size = pp->ncolors * sizeof(SDL_Color);
1307                         pp->colors = SDL_malloc(size);
1308                         if ( !pp->colors ) {
1309                                 return 0;
1310                         }
1311                         SDL_memcpy(pp->colors, pal->colors, size);
1312                 }
1313                 if ( ! SetPalette_physical(screen,
1314                                            colors, firstcolor, ncolors) ) {
1315                         gotall = 0;
1316                 }
1317         }
1318         return gotall;
1319 }
1320
1321 int SDL_SetColors(SDL_Surface *screen, SDL_Color *colors, int firstcolor,
1322                   int ncolors)
1323 {
1324         return SDL_SetPalette(screen, SDL_LOGPAL | SDL_PHYSPAL,
1325                               colors, firstcolor, ncolors);
1326 }
1327
1328 /*
1329  * Clean up the video subsystem
1330  */
1331 void SDL_VideoQuit (void)
1332 {
1333         SDL_Surface *ready_to_go;
1334
1335         if ( current_video ) {
1336                 SDL_VideoDevice *video = current_video;
1337                 SDL_VideoDevice *this  = current_video;
1338
1339                 /* Halt event processing before doing anything else */
1340                 SDL_StopEventLoop();
1341
1342                 /* Clean up allocated window manager items */
1343                 if ( SDL_PublicSurface ) {
1344                         SDL_PublicSurface = NULL;
1345                 }
1346                 SDL_CursorQuit();
1347
1348                 /* Just in case... */
1349                 SDL_WM_GrabInputOff();
1350
1351                 /* Clean up the system video */
1352                 video->VideoQuit(this);
1353
1354                 /* Free any lingering surfaces */
1355                 ready_to_go = SDL_ShadowSurface;
1356                 SDL_ShadowSurface = NULL;
1357                 SDL_FreeSurface(ready_to_go);
1358                 if ( SDL_VideoSurface != NULL ) {
1359                         ready_to_go = SDL_VideoSurface;
1360                         SDL_VideoSurface = NULL;
1361                         SDL_FreeSurface(ready_to_go);
1362                 }
1363                 SDL_PublicSurface = NULL;
1364
1365                 /* Clean up miscellaneous memory */
1366                 if ( video->physpal ) {
1367                         SDL_free(video->physpal->colors);
1368                         SDL_free(video->physpal);
1369                         video->physpal = NULL;
1370                 }
1371                 if ( video->gammacols ) {
1372                         SDL_free(video->gammacols);
1373                         video->gammacols = NULL;
1374                 }
1375                 if ( video->gamma ) {
1376                         SDL_free(video->gamma);
1377                         video->gamma = NULL;
1378                 }
1379                 if ( video->wm_title != NULL ) {
1380                         SDL_free(video->wm_title);
1381                         video->wm_title = NULL;
1382                 }
1383                 if ( video->wm_icon != NULL ) {
1384                         SDL_free(video->wm_icon);
1385                         video->wm_icon = NULL;
1386                 }
1387
1388                 /* Finish cleaning up video subsystem */
1389                 video->free(this);
1390                 current_video = NULL;
1391         }
1392         return;
1393 }
1394
1395 /* Load the GL driver library */
1396 int SDL_GL_LoadLibrary(const char *path)
1397 {
1398         SDL_VideoDevice *video = current_video;
1399         SDL_VideoDevice *this = current_video;
1400         int retval;
1401
1402         retval = -1;
1403         if ( video == NULL ) {
1404                 SDL_SetError("Video subsystem has not been initialized");
1405         } else {
1406                 if ( video->GL_LoadLibrary ) {
1407                         retval = video->GL_LoadLibrary(this, path);
1408                 } else {
1409                         SDL_SetError("No dynamic GL support in video driver");
1410                 }
1411         }
1412         return(retval);
1413 }
1414
1415 void *SDL_GL_GetProcAddress(const char* proc)
1416 {
1417         SDL_VideoDevice *video = current_video;
1418         SDL_VideoDevice *this = current_video;
1419         void *func;
1420
1421         func = NULL;
1422         if ( video->GL_GetProcAddress ) {
1423                 if ( video->gl_config.driver_loaded ) {
1424                         func = video->GL_GetProcAddress(this, proc);
1425                 } else {
1426                         SDL_SetError("No GL driver has been loaded");
1427                 }
1428         } else {
1429                 SDL_SetError("No dynamic GL support in video driver");
1430         }
1431         return func;
1432 }
1433
1434 /* Set the specified GL attribute for setting up a GL video mode */
1435 int SDL_GL_SetAttribute( SDL_GLattr attr, int value )
1436 {
1437         int retval;
1438         SDL_VideoDevice *video = current_video;
1439
1440         retval = 0;
1441         switch (attr) {
1442                 case SDL_GL_RED_SIZE:
1443                         video->gl_config.red_size = value;
1444                         break;
1445                 case SDL_GL_GREEN_SIZE:
1446                         video->gl_config.green_size = value;
1447                         break;
1448                 case SDL_GL_BLUE_SIZE:
1449                         video->gl_config.blue_size = value;
1450                         break;
1451                 case SDL_GL_ALPHA_SIZE:
1452                         video->gl_config.alpha_size = value;
1453                         break;
1454                 case SDL_GL_DOUBLEBUFFER:
1455                         video->gl_config.double_buffer = value;
1456                         break;
1457                 case SDL_GL_BUFFER_SIZE:
1458                         video->gl_config.buffer_size = value;
1459                         break;
1460                 case SDL_GL_DEPTH_SIZE:
1461                         video->gl_config.depth_size = value;
1462                         break;
1463                 case SDL_GL_STENCIL_SIZE:
1464                         video->gl_config.stencil_size = value;
1465                         break;
1466                 case SDL_GL_ACCUM_RED_SIZE:
1467                         video->gl_config.accum_red_size = value;
1468                         break;
1469                 case SDL_GL_ACCUM_GREEN_SIZE:
1470                         video->gl_config.accum_green_size = value;
1471                         break;
1472                 case SDL_GL_ACCUM_BLUE_SIZE:
1473                         video->gl_config.accum_blue_size = value;
1474                         break;
1475                 case SDL_GL_ACCUM_ALPHA_SIZE:
1476                         video->gl_config.accum_alpha_size = value;
1477                         break;
1478                 case SDL_GL_STEREO:
1479                         video->gl_config.stereo = value;
1480                         break;
1481                 case SDL_GL_MULTISAMPLEBUFFERS:
1482                         video->gl_config.multisamplebuffers = value;
1483                         break;
1484                 case SDL_GL_MULTISAMPLESAMPLES:
1485                         video->gl_config.multisamplesamples = value;
1486                         break;
1487                 case SDL_GL_ACCELERATED_VISUAL:
1488                         video->gl_config.accelerated = value;
1489                         break;
1490                 case SDL_GL_SWAP_CONTROL:
1491                         video->gl_config.swap_control = value;
1492                         break;
1493                 default:
1494                         SDL_SetError("Unknown OpenGL attribute");
1495                         retval = -1;
1496                         break;
1497         }
1498         return(retval);
1499 }
1500
1501 /* Retrieve an attribute value from the windowing system. */
1502 int SDL_GL_GetAttribute(SDL_GLattr attr, int* value)
1503 {
1504         int retval = -1;
1505         SDL_VideoDevice* video = current_video;
1506         SDL_VideoDevice* this = current_video;
1507
1508         if ( video->GL_GetAttribute ) {
1509                 retval = this->GL_GetAttribute(this, attr, value);
1510         } else {
1511                 *value = 0;
1512                 SDL_SetError("GL_GetAttribute not supported");
1513         }
1514         return retval;
1515 }
1516
1517 /* Perform a GL buffer swap on the current GL context */
1518 void SDL_GL_SwapBuffers(void)
1519 {
1520         SDL_VideoDevice *video = current_video;
1521         SDL_VideoDevice *this = current_video;
1522
1523         if ( video->screen->flags & SDL_OPENGL ) {
1524                 video->GL_SwapBuffers(this);
1525         } else {
1526                 SDL_SetError("OpenGL video mode has not been set");
1527         }
1528 }
1529
1530 /* Update rects with locking */
1531 void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect *rects)
1532 {
1533         SDL_GL_Lock();
1534         SDL_GL_UpdateRects(numrects, rects);
1535         SDL_GL_Unlock();
1536 }
1537
1538 /* Update rects without state setting and changing (the caller is responsible for it) */
1539 void SDL_GL_UpdateRects(int numrects, SDL_Rect *rects)
1540 {
1541 #if SDL_VIDEO_OPENGL
1542         SDL_VideoDevice *this = current_video;
1543         SDL_Rect update, tmp;
1544         int x, y, i;
1545
1546         for ( i = 0; i < numrects; i++ )
1547         {
1548                 tmp.y = rects[i].y;
1549                 tmp.h = rects[i].h;
1550                 for ( y = 0; y <= rects[i].h / 256; y++ )
1551                 {
1552                         tmp.x = rects[i].x;
1553                         tmp.w = rects[i].w;
1554                         for ( x = 0; x <= rects[i].w / 256; x++ )
1555                         {
1556                                 update.x = tmp.x;
1557                                 update.y = tmp.y;
1558                                 update.w = tmp.w;
1559                                 update.h = tmp.h;
1560
1561                                 if ( update.w > 256 )
1562                                         update.w = 256;
1563
1564                                 if ( update.h > 256 )
1565                                         update.h = 256;
1566
1567                                 this->glFlush();
1568                                 this->glTexSubImage2D(
1569                                         GL_TEXTURE_2D,
1570                                         0,
1571                                         0,
1572                                         0,
1573                                         update.w,
1574                                         update.h,
1575                                         this->is_32bit? GL_RGBA : GL_RGB,
1576 #ifdef GL_VERSION_1_2
1577                                         this->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5,
1578 #else
1579                                         GL_UNSIGNED_BYTE,
1580 #endif
1581                                         (Uint8 *)this->screen->pixels +
1582                                                 this->screen->format->BytesPerPixel * update.x +
1583                                                 update.y * this->screen->pitch );
1584
1585                                 this->glFlush();
1586                                 /*
1587                                 * Note the parens around the function name:
1588                                 * This is because some OpenGL implementations define glTexCoord etc
1589                                 * as macros, and we don't want them expanded here.
1590                                 */
1591                                 this->glBegin(GL_TRIANGLE_STRIP);
1592                                         (this->glTexCoord2f)( 0.0, 0.0 );
1593                                         (this->glVertex2i)( update.x, update.y );
1594                                         (this->glTexCoord2f)( (float)(update.w / 256.0), 0.0 );
1595                                         (this->glVertex2i)( update.x + update.w, update.y );
1596                                         (this->glTexCoord2f)( 0.0, (float)(update.h / 256.0) );
1597                                         (this->glVertex2i)( update.x, update.y + update.h );
1598                                         (this->glTexCoord2f)( (float)(update.w / 256.0), (float)(update.h / 256.0) );
1599                                         (this->glVertex2i)( update.x + update.w , update.y + update.h );
1600                                 this->glEnd();
1601
1602                                 tmp.x += 256;
1603                                 tmp.w -= 256;
1604                         }
1605                         tmp.y += 256;
1606                         tmp.h -= 256;
1607                 }
1608         }
1609 #endif
1610 }
1611
1612 /* Lock == save current state */
1613 void SDL_GL_Lock()
1614 {
1615 #if SDL_VIDEO_OPENGL
1616         lock_count--;
1617         if (lock_count==-1)
1618         {
1619                 SDL_VideoDevice *this = current_video;
1620
1621                 this->glPushAttrib( GL_ALL_ATTRIB_BITS );       /* TODO: narrow range of what is saved */
1622 #ifdef GL_CLIENT_PIXEL_STORE_BIT
1623                 this->glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
1624 #endif
1625
1626                 this->glEnable(GL_TEXTURE_2D);
1627                 this->glEnable(GL_BLEND);
1628                 this->glDisable(GL_FOG);
1629                 this->glDisable(GL_ALPHA_TEST);
1630                 this->glDisable(GL_DEPTH_TEST);
1631                 this->glDisable(GL_SCISSOR_TEST);
1632                 this->glDisable(GL_STENCIL_TEST);
1633                 this->glDisable(GL_CULL_FACE);
1634
1635                 this->glBindTexture( GL_TEXTURE_2D, this->texture );
1636                 this->glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
1637                 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
1638                 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
1639                 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
1640                 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
1641
1642                 this->glPixelStorei( GL_UNPACK_ROW_LENGTH, this->screen->pitch / this->screen->format->BytesPerPixel );
1643                 this->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1644                 (this->glColor4f)(1.0, 1.0, 1.0, 1.0);          /* Solaris workaround */
1645
1646                 this->glViewport(0, 0, this->screen->w, this->screen->h);
1647                 this->glMatrixMode(GL_PROJECTION);
1648                 this->glPushMatrix();
1649                 this->glLoadIdentity();
1650
1651                 this->glOrtho(0.0, (GLdouble) this->screen->w, (GLdouble) this->screen->h, 0.0, 0.0, 1.0);
1652
1653                 this->glMatrixMode(GL_MODELVIEW);
1654                 this->glPushMatrix();
1655                 this->glLoadIdentity();
1656         }
1657 #endif
1658 }
1659
1660 /* Unlock == restore saved state */
1661 void SDL_GL_Unlock()
1662 {
1663 #if SDL_VIDEO_OPENGL
1664         lock_count++;
1665         if (lock_count==0)
1666         {
1667                 SDL_VideoDevice *this = current_video;
1668
1669                 this->glPopMatrix();
1670                 this->glMatrixMode(GL_PROJECTION);
1671                 this->glPopMatrix();
1672
1673                 this->glPopClientAttrib();
1674                 this->glPopAttrib();
1675         }
1676 #endif
1677 }
1678
1679 /*
1680  * Sets/Gets the title and icon text of the display window, if any.
1681  */
1682 void SDL_WM_SetCaption (const char *title, const char *icon)
1683 {
1684         SDL_VideoDevice *video = current_video;
1685         SDL_VideoDevice *this  = current_video;
1686
1687         if ( video ) {
1688                 if ( title ) {
1689                         if ( video->wm_title ) {
1690                                 SDL_free(video->wm_title);
1691                         }
1692                         video->wm_title = SDL_strdup(title);
1693                 }
1694                 if ( icon ) {
1695                         if ( video->wm_icon ) {
1696                                 SDL_free(video->wm_icon);
1697                         }
1698                         video->wm_icon = SDL_strdup(icon);
1699                 }
1700                 if ( (title || icon) && (video->SetCaption != NULL) ) {
1701                         video->SetCaption(this, video->wm_title,video->wm_icon);
1702                 }
1703         }
1704 }
1705 void SDL_WM_GetCaption (char **title, char **icon)
1706 {
1707         SDL_VideoDevice *video = current_video;
1708
1709         if ( video ) {
1710                 if ( title ) {
1711                         *title = video->wm_title;
1712                 }
1713                 if ( icon ) {
1714                         *icon = video->wm_icon;
1715                 }
1716         }
1717 }
1718
1719 /* Utility function used by SDL_WM_SetIcon();
1720  * flags & 1 for color key, flags & 2 for alpha channel. */
1721 static void CreateMaskFromColorKeyOrAlpha(SDL_Surface *icon, Uint8 *mask, int flags)
1722 {
1723         int x, y;
1724         Uint32 colorkey;
1725 #define SET_MASKBIT(icon, x, y, mask) \
1726         mask[(y*((icon->w+7)/8))+(x/8)] &= ~(0x01<<(7-(x%8)))
1727
1728         colorkey = icon->format->colorkey;
1729         switch (icon->format->BytesPerPixel) {
1730                 case 1: { Uint8 *pixels;
1731                         for ( y=0; y<icon->h; ++y ) {
1732                                 pixels = (Uint8 *)icon->pixels + y*icon->pitch;
1733                                 for ( x=0; x<icon->w; ++x ) {
1734                                         if ( *pixels++ == colorkey ) {
1735                                                 SET_MASKBIT(icon, x, y, mask);
1736                                         }
1737                                 }
1738                         }
1739                 }
1740                 break;
1741
1742                 case 2: { Uint16 *pixels;
1743                         for ( y=0; y<icon->h; ++y ) {
1744                                 pixels = (Uint16 *)icon->pixels +
1745                                                    y*icon->pitch/2;
1746                                 for ( x=0; x<icon->w; ++x ) {
1747                                         if ( (flags & 1) && *pixels == colorkey ) {
1748                                                 SET_MASKBIT(icon, x, y, mask);
1749                                         } else if((flags & 2) && (*pixels & icon->format->Amask) == 0) {
1750                                                 SET_MASKBIT(icon, x, y, mask);
1751                                         }
1752                                         pixels++;
1753                                 }
1754                         }
1755                 }
1756                 break;
1757
1758                 case 4: { Uint32 *pixels;
1759                         for ( y=0; y<icon->h; ++y ) {
1760                                 pixels = (Uint32 *)icon->pixels +
1761                                                    y*icon->pitch/4;
1762                                 for ( x=0; x<icon->w; ++x ) {
1763                                         if ( (flags & 1) && *pixels == colorkey ) {
1764                                                 SET_MASKBIT(icon, x, y, mask);
1765                                         } else if((flags & 2) && (*pixels & icon->format->Amask) == 0) {
1766                                                 SET_MASKBIT(icon, x, y, mask);
1767                                         }
1768                                         pixels++;
1769                                 }
1770                         }
1771                 }
1772                 break;
1773         }
1774 }
1775
1776 /*
1777  * Sets the window manager icon for the display window.
1778  */
1779 void SDL_WM_SetIcon (SDL_Surface *icon, Uint8 *mask)
1780 {
1781         SDL_VideoDevice *video = current_video;
1782         SDL_VideoDevice *this  = current_video;
1783
1784         if ( icon && video->SetIcon ) {
1785                 /* Generate a mask if necessary, and create the icon! */
1786                 if ( mask == NULL ) {
1787                         int mask_len = icon->h*(icon->w+7)/8;
1788                         int flags = 0;
1789                         mask = (Uint8 *)SDL_malloc(mask_len);
1790                         if ( mask == NULL ) {
1791                                 return;
1792                         }
1793                         SDL_memset(mask, ~0, mask_len);
1794                         if ( icon->flags & SDL_SRCCOLORKEY ) flags |= 1;
1795                         if ( icon->flags & SDL_SRCALPHA ) flags |= 2;
1796                         if( flags ) {
1797                                 CreateMaskFromColorKeyOrAlpha(icon, mask, flags);
1798                         }
1799                         video->SetIcon(video, icon, mask);
1800                         SDL_free(mask);
1801                 } else {
1802                         video->SetIcon(this, icon, mask);
1803                 }
1804         }
1805 }
1806
1807 /*
1808  * Grab or ungrab the keyboard and mouse input.
1809  * This function returns the final grab mode after calling the
1810  * driver dependent function.
1811  */
1812 static SDL_GrabMode SDL_WM_GrabInputRaw(SDL_GrabMode mode)
1813 {
1814         SDL_VideoDevice *video = current_video;
1815         SDL_VideoDevice *this  = current_video;
1816
1817         /* Only do something if we have support for grabs */
1818         if ( video->GrabInput == NULL ) {
1819                 return(video->input_grab);
1820         }
1821
1822         /* If the final grab mode if off, only then do we actually grab */
1823 #ifdef DEBUG_GRAB
1824   printf("SDL_WM_GrabInputRaw(%d) ... ", mode);
1825 #endif
1826         if ( mode == SDL_GRAB_OFF ) {
1827                 if ( video->input_grab != SDL_GRAB_OFF ) {
1828                         mode = video->GrabInput(this, mode);
1829                 }
1830         } else {
1831                 if ( video->input_grab == SDL_GRAB_OFF ) {
1832                         mode = video->GrabInput(this, mode);
1833                 }
1834         }
1835         if ( mode != video->input_grab ) {
1836                 video->input_grab = mode;
1837                 if ( video->CheckMouseMode ) {
1838                         video->CheckMouseMode(this);
1839                 }
1840         }
1841 #ifdef DEBUG_GRAB
1842   printf("Final mode %d\n", video->input_grab);
1843 #endif
1844
1845         /* Return the final grab state */
1846         if ( mode >= SDL_GRAB_FULLSCREEN ) {
1847                 mode -= SDL_GRAB_FULLSCREEN;
1848         }
1849         return(mode);
1850 }
1851 SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode)
1852 {
1853         SDL_VideoDevice *video = current_video;
1854
1855         /* If the video isn't initialized yet, we can't do anything */
1856         if ( ! video ) {
1857                 return SDL_GRAB_OFF;
1858         }
1859
1860         /* Return the current mode on query */
1861         if ( mode == SDL_GRAB_QUERY ) {
1862                 mode = video->input_grab;
1863                 if ( mode >= SDL_GRAB_FULLSCREEN ) {
1864                         mode -= SDL_GRAB_FULLSCREEN;
1865                 }
1866                 return(mode);
1867         }
1868
1869 #ifdef DEBUG_GRAB
1870   printf("SDL_WM_GrabInput(%d) ... ", mode);
1871 #endif
1872         /* If the video surface is fullscreen, we always grab */
1873         if ( mode >= SDL_GRAB_FULLSCREEN ) {
1874                 mode -= SDL_GRAB_FULLSCREEN;
1875         }
1876         if ( SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_FULLSCREEN) ) {
1877                 mode += SDL_GRAB_FULLSCREEN;
1878         }
1879         return(SDL_WM_GrabInputRaw(mode));
1880 }
1881 static SDL_GrabMode SDL_WM_GrabInputOff(void)
1882 {
1883         SDL_GrabMode mode;
1884
1885         /* First query the current grab state */
1886         mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
1887
1888         /* Now explicitly turn off input grab */
1889         SDL_WM_GrabInputRaw(SDL_GRAB_OFF);
1890
1891         /* Return the old state */
1892         return(mode);
1893 }
1894
1895 /*
1896  * Iconify the window in window managed environments.
1897  * A successful iconification will result in an SDL_APPACTIVE loss event.
1898  */
1899 int SDL_WM_IconifyWindow(void)
1900 {
1901         SDL_VideoDevice *video = current_video;
1902         SDL_VideoDevice *this  = current_video;
1903         int retval;
1904
1905         retval = 0;
1906         if ( video->IconifyWindow ) {
1907                 retval = video->IconifyWindow(this);
1908         }
1909         return(retval);
1910 }
1911
1912 /*
1913  * Toggle fullscreen mode
1914  */
1915 int SDL_WM_ToggleFullScreen(SDL_Surface *surface)
1916 {
1917         SDL_VideoDevice *video = current_video;
1918         SDL_VideoDevice *this  = current_video;
1919         int toggled;
1920
1921         toggled = 0;
1922         if ( SDL_PublicSurface && (surface == SDL_PublicSurface) &&
1923              video->ToggleFullScreen ) {
1924                 if ( surface->flags & SDL_FULLSCREEN ) {
1925                         toggled = video->ToggleFullScreen(this, 0);
1926                         if ( toggled ) {
1927                                 SDL_VideoSurface->flags &= ~SDL_FULLSCREEN;
1928                                 SDL_PublicSurface->flags &= ~SDL_FULLSCREEN;
1929                         }
1930                 } else {
1931                         toggled = video->ToggleFullScreen(this, 1);
1932                         if ( toggled ) {
1933                                 SDL_VideoSurface->flags |= SDL_FULLSCREEN;
1934                                 SDL_PublicSurface->flags |= SDL_FULLSCREEN;
1935                         }
1936                 }
1937                 /* Double-check the grab state inside SDL_WM_GrabInput() */
1938                 if ( toggled ) {
1939                         SDL_WM_GrabInput(video->input_grab);
1940                 }
1941         }
1942         return(toggled);
1943 }
1944
1945 /*
1946  * Get some platform dependent window manager information
1947  */
1948 int SDL_GetWMInfo (SDL_SysWMinfo *info)
1949 {
1950         SDL_VideoDevice *video = current_video;
1951         SDL_VideoDevice *this  = current_video;
1952
1953         if ( video && video->GetWMInfo ) {
1954                 return(video->GetWMInfo(this, info));
1955         } else {
1956                 return(0);
1957         }
1958 }