src/video/SDL_cursor.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 /* General cursor handling code for SDL */
  25
  26 #include "SDL_mutex.h"
  27 #include "SDL_video.h"
  28 #include "SDL_mouse.h"
  29 #include "SDL_blit.h"
  30 #include "SDL_sysvideo.h"
  31 #include "SDL_cursor_c.h"
  32 #include "SDL_pixels_c.h"
  33 #include "default_cursor.h"
  34 #include "../events/SDL_sysevents.h"
  35 #include "../events/SDL_events_c.h"
  36
  37 /* These are static for our cursor handling code */
  38 volatile int SDL_cursorstate = CURSOR_VISIBLE;
  39 SDL_Cursor *SDL_cursor = NULL;
  40 static SDL_Cursor *SDL_defcursor = NULL;
  41 SDL_mutex *SDL_cursorlock = NULL;
  42
  43 /* Public functions */
  44 void SDL_CursorQuit(void)
  45 {
  46         if ( SDL_cursor != NULL ) {
  47                 SDL_Cursor *cursor;
  48
  49                 SDL_cursorstate &= ~CURSOR_VISIBLE;
  50                 if ( SDL_cursor != SDL_defcursor ) {
  51                         SDL_FreeCursor(SDL_cursor);
  52                 }
  53                 SDL_cursor = NULL;
  54                 if ( SDL_defcursor != NULL ) {
  55                         cursor = SDL_defcursor;
  56                         SDL_defcursor = NULL;
  57                         SDL_FreeCursor(cursor);
  58                 }
  59         }
  60         if ( SDL_cursorlock != NULL ) {
  61                 SDL_DestroyMutex(SDL_cursorlock);
  62                 SDL_cursorlock = NULL;
  63         }
  64 }
  65 int SDL_CursorInit(Uint32 multithreaded)
  66 {
  67         /* We don't have mouse focus, and the cursor isn't drawn yet */
  68 #ifndef IPOD
  69         SDL_cursorstate = CURSOR_VISIBLE;
  70 #endif
  71
  72         /* Create the default cursor */
  73         if ( SDL_defcursor == NULL ) {
  74                 SDL_defcursor = SDL_CreateCursor(default_cdata, default_cmask,
  75                                         DEFAULT_CWIDTH, DEFAULT_CHEIGHT,
  76                                                 DEFAULT_CHOTX, DEFAULT_CHOTY);
  77                 SDL_SetCursor(SDL_defcursor);
  78         }
  79
  80         /* Create a lock if necessary */
  81         if ( multithreaded ) {
  82                 SDL_cursorlock = SDL_CreateMutex();
  83         }
  84
  85         /* That's it! */
  86         return(0);
  87 }
  88
  89 /* Multi-thread support for cursors */
  90 #ifndef SDL_LockCursor
  91 void SDL_LockCursor(void)
  92 {
  93         if ( SDL_cursorlock ) {
  94                 SDL_mutexP(SDL_cursorlock);
  95         }
  96 }
  97 #endif
  98 #ifndef SDL_UnlockCursor
  99 void SDL_UnlockCursor(void)
 100 {
 101         if ( SDL_cursorlock ) {
 102                 SDL_mutexV(SDL_cursorlock);
 103         }
 104 }
 105 #endif
 106
 107 /* Software cursor drawing support */
 108 SDL_Cursor * SDL_CreateCursor (Uint8 *data, Uint8 *mask,
 109                                         int w, int h, int hot_x, int hot_y)
 110 {
 111         SDL_VideoDevice *video = current_video;
 112         int savelen;
 113         int i;
 114         SDL_Cursor *cursor;
 115
 116         /* Make sure the width is a multiple of 8 */
 117         w = ((w+7)&~7);
 118
 119         /* Sanity check the hot spot */
 120         if ( (hot_x < 0) || (hot_y < 0) || (hot_x >= w) || (hot_y >= h) ) {
 121                 SDL_SetError("Cursor hot spot doesn't lie within cursor");
 122                 return(NULL);
 123         }
 124
 125         /* Allocate memory for the cursor */
 126         cursor = (SDL_Cursor *)SDL_malloc(sizeof *cursor);
 127         if ( cursor == NULL ) {
 128                 SDL_OutOfMemory();
 129                 return(NULL);
 130         }
 131         savelen = (w*4)*h;
 132         cursor->area.x = 0;
 133         cursor->area.y = 0;
 134         cursor->area.w = w;
 135         cursor->area.h = h;
 136         cursor->hot_x = hot_x;
 137         cursor->hot_y = hot_y;
 138         cursor->data = (Uint8 *)SDL_malloc((w/8)*h*2);
 139         cursor->mask = cursor->data+((w/8)*h);
 140         cursor->save[0] = (Uint8 *)SDL_malloc(savelen*2);
 141         cursor->save[1] = cursor->save[0] + savelen;
 142         cursor->wm_cursor = NULL;
 143         if ( ! cursor->data || ! cursor->save[0] ) {
 144                 SDL_FreeCursor(cursor);
 145                 SDL_OutOfMemory();
 146                 return(NULL);
 147         }
 148         for ( i=((w/8)*h)-1; i>=0; --i ) {
 149                 cursor->data[i] = data[i];
 150                 cursor->mask[i] = mask[i] | data[i];
 151         }
 152         SDL_memset(cursor->save[0], 0, savelen*2);
 153
 154         /* If the window manager gives us a good cursor, we're done! */
 155         if ( video->CreateWMCursor ) {
 156                 cursor->wm_cursor = video->CreateWMCursor(video, data, mask,
 157                                                         w, h, hot_x, hot_y);
 158         } else {
 159                 cursor->wm_cursor = NULL;
 160         }
 161         return(cursor);
 162 }
 163
 164 /* SDL_SetCursor(NULL) can be used to force the cursor redraw,
 165    if this is desired for any reason.  This is used when setting
 166    the video mode and when the SDL window gains the mouse focus.
 167  */
 168 void SDL_SetCursor (SDL_Cursor *cursor)
 169 {
 170         SDL_VideoDevice *video = current_video;
 171         SDL_VideoDevice *this  = current_video;
 172
 173         /* Make sure that the video subsystem has been initialized */
 174         if ( ! video ) {
 175                 return;
 176         }
 177
 178         /* Prevent the event thread from moving the mouse */
 179         SDL_LockCursor();
 180
 181         /* Set the new cursor */
 182         if ( cursor && (cursor != SDL_cursor) ) {
 183                 /* Erase the current mouse position */
 184                 if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
 185                         SDL_EraseCursor(SDL_VideoSurface);
 186                 } else if ( video->MoveWMCursor ) {
 187                         /* If the video driver is moving the cursor directly,
 188                            it needs to hide the old cursor before (possibly)
 189                            showing the new one.  (But don't erase NULL cursor)
 190                          */
 191                         if ( SDL_cursor && video->ShowWMCursor ) {
 192                                 video->ShowWMCursor(this, NULL);
 193                         }
 194                 }
 195                 SDL_cursor = cursor;
 196         }
 197
 198         /* Draw the new mouse cursor */
 199         if ( SDL_cursor && (SDL_cursorstate&CURSOR_VISIBLE) ) {
 200                 /* Use window manager cursor if possible */
 201                 int show_wm_cursor = 0;
 202                 if ( SDL_cursor->wm_cursor && video->ShowWMCursor ) {
 203                         show_wm_cursor = video->ShowWMCursor(this, SDL_cursor->wm_cursor);
 204                 }
 205                 if ( show_wm_cursor ) {
 206                         SDL_cursorstate &= ~CURSOR_USINGSW;
 207                 } else {
 208                         SDL_cursorstate |= CURSOR_USINGSW;
 209                         if ( video->ShowWMCursor ) {
 210                                 video->ShowWMCursor(this, NULL);
 211                         }
 212                         { int x, y;
 213                                 SDL_GetMouseState(&x, &y);
 214                                 SDL_cursor->area.x = (x - SDL_cursor->hot_x);
 215                                 SDL_cursor->area.y = (y - SDL_cursor->hot_y);
 216                         }
 217                         SDL_DrawCursor(SDL_VideoSurface);
 218                 }
 219         } else {
 220                 /* Erase window manager mouse (cursor not visible) */
 221                 if ( SDL_cursor && (SDL_cursorstate & CURSOR_USINGSW) ) {
 222                         SDL_EraseCursor(SDL_VideoSurface);
 223                 } else {
 224                         if ( video ) {
 225                                 if ( video->ShowWMCursor ) {
 226                                         video->ShowWMCursor(this, NULL);
 227                                 }
 228                         }
 229                 }
 230         }
 231         SDL_UnlockCursor();
 232 }
 233
 234 SDL_Cursor * SDL_GetCursor (void)
 235 {
 236         return(SDL_cursor);
 237 }
 238
 239 void SDL_FreeCursor (SDL_Cursor *cursor)
 240 {
 241         if ( cursor ) {
 242                 if ( cursor == SDL_cursor ) {
 243                         SDL_SetCursor(SDL_defcursor);
 244                 }
 245                 if ( cursor != SDL_defcursor ) {
 246                         SDL_VideoDevice *video = current_video;
 247                         SDL_VideoDevice *this  = current_video;
 248
 249                         if ( cursor->data ) {
 250                                 SDL_free(cursor->data);
 251                         }
 252                         if ( cursor->save[0] ) {
 253                                 SDL_free(cursor->save[0]);
 254                         }
 255                         if ( video && cursor->wm_cursor ) {
 256                                 if ( video->FreeWMCursor ) {
 257                                         video->FreeWMCursor(this, cursor->wm_cursor);
 258                                 }
 259                         }
 260                         SDL_free(cursor);
 261                 }
 262         }
 263 }
 264
 265 int SDL_ShowCursor (int toggle)
 266 {
 267         int showing;
 268
 269         showing = (SDL_cursorstate & CURSOR_VISIBLE);
 270         if ( toggle >= 0 ) {
 271                 SDL_LockCursor();
 272                 if ( toggle ) {
 273                         SDL_cursorstate |= CURSOR_VISIBLE;
 274                 } else {
 275                         SDL_cursorstate &= ~CURSOR_VISIBLE;
 276                 }
 277                 SDL_UnlockCursor();
 278                 if ( (SDL_cursorstate & CURSOR_VISIBLE) != showing ) {
 279                         SDL_VideoDevice *video = current_video;
 280                         SDL_VideoDevice *this  = current_video;
 281
 282                         SDL_SetCursor(NULL);
 283                         if ( video && video->CheckMouseMode ) {
 284                                 video->CheckMouseMode(this);
 285                         }
 286                 }
 287         } else {
 288                 /* Query current state */ ;
 289         }
 290         return(showing ? 1 : 0);
 291 }
 292
 293 void SDL_WarpMouse (Uint16 x, Uint16 y)
 294 {
 295         SDL_VideoDevice *video = current_video;
 296         SDL_VideoDevice *this  = current_video;
 297
 298         if ( !video || !SDL_PublicSurface ) {
 299                 SDL_SetError("A video mode must be set before warping mouse");
 300                 return;
 301         }
 302
 303         /* If we have an offset video mode, offset the mouse coordinates */
 304         if (this->screen->pitch == 0) {
 305                 x += this->screen->offset / this->screen->format->BytesPerPixel;
 306                 y += this->screen->offset;
 307         } else {
 308                 x += (this->screen->offset % this->screen->pitch) /
 309                       this->screen->format->BytesPerPixel;
 310                 y += (this->screen->offset / this->screen->pitch);
 311         }
 312
 313         /* This generates a mouse motion event */
 314         if ( video->WarpWMCursor ) {
 315                 video->WarpWMCursor(this, x, y);
 316         } else {
 317                 SDL_PrivateMouseMotion(0, 0, x, y);
 318         }
 319 }
 320
 321 void SDL_MoveCursor(int x, int y)
 322 {
 323         SDL_VideoDevice *video = current_video;
 324
 325         /* Erase and update the current mouse position */
 326         if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) {
 327                 /* Erase and redraw mouse cursor in new position */
 328                 SDL_LockCursor();
 329                 SDL_EraseCursor(SDL_VideoSurface);
 330                 SDL_cursor->area.x = (x - SDL_cursor->hot_x);
 331                 SDL_cursor->area.y = (y - SDL_cursor->hot_y);
 332                 SDL_DrawCursor(SDL_VideoSurface);
 333                 SDL_UnlockCursor();
 334         } else if ( video->MoveWMCursor ) {
 335                 video->MoveWMCursor(video, x, y);
 336         }
 337 }
 338
 339 /* Keep track of the current cursor colors */
 340 static int palette_changed = 1;
 341 static Uint8 pixels8[2];
 342
 343 void SDL_CursorPaletteChanged(void)
 344 {
 345         palette_changed = 1;
 346 }
 347
 348 void SDL_MouseRect(SDL_Rect *area)
 349 {
 350         int clip_diff;
 351
 352         *area = SDL_cursor->area;
 353         if ( area->x < 0 ) {
 354                 area->w += area->x;
 355                 area->x = 0;
 356         }
 357         if ( area->y < 0 ) {
 358                 area->h += area->y;
 359                 area->y = 0;
 360         }
 361         clip_diff = (area->x+area->w)-SDL_VideoSurface->w;
 362         if ( clip_diff > 0 ) {
 363                 area->w = area->w < clip_diff ? 0 : area->w-clip_diff;
 364         }
 365         clip_diff = (area->y+area->h)-SDL_VideoSurface->h;
 366         if ( clip_diff > 0 ) {
 367                 area->h = area->h < clip_diff ? 0 : area->h-clip_diff;
 368         }
 369 }
 370
 371 static void SDL_DrawCursorFast(SDL_Surface *screen, SDL_Rect *area)
 372 {
 373         const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 };
 374         int i, w, h;
 375         Uint8 *data, datab;
 376         Uint8 *mask, maskb;
 377
 378         data = SDL_cursor->data + area->y * SDL_cursor->area.w/8;
 379         mask = SDL_cursor->mask + area->y * SDL_cursor->area.w/8;
 380         switch (screen->format->BytesPerPixel) {
 381
 382             case 1: {
 383                 Uint8 *dst;
 384                 int dstskip;
 385
 386                 if ( palette_changed ) {
 387                         pixels8[0] = (Uint8)SDL_MapRGB(screen->format, 255, 255, 255);
 388                         pixels8[1] = (Uint8)SDL_MapRGB(screen->format, 0, 0, 0);
 389                         palette_changed = 0;
 390                 }
 391                 dst = (Uint8 *)screen->pixels +
 392                        (SDL_cursor->area.y+area->y)*screen->pitch +
 393                        SDL_cursor->area.x;
 394                 dstskip = screen->pitch-area->w;
 395
 396                 for ( h=area->h; h; h-- ) {
 397                         for ( w=area->w/8; w; w-- ) {
 398                                 maskb = *mask++;
 399                                 datab = *data++;
 400                                 for ( i=0; i<8; ++i ) {
 401                                         if ( maskb & 0x80 ) {
 402                                                 *dst = pixels8[datab>>7];
 403                                         }
 404                                         maskb <<= 1;
 405                                         datab <<= 1;
 406                                         dst++;
 407                                 }
 408                         }
 409                         dst += dstskip;
 410                 }
 411             }
 412             break;
 413
 414             case 2: {
 415                 Uint16 *dst;
 416                 int dstskip;
 417
 418                 dst = (Uint16 *)screen->pixels +
 419                        (SDL_cursor->area.y+area->y)*screen->pitch/2 +
 420                        SDL_cursor->area.x;
 421                 dstskip = (screen->pitch/2)-area->w;
 422
 423                 for ( h=area->h; h; h-- ) {
 424                         for ( w=area->w/8; w; w-- ) {
 425                                 maskb = *mask++;
 426                                 datab = *data++;
 427                                 for ( i=0; i<8; ++i ) {
 428                                         if ( maskb & 0x80 ) {
 429                                                 *dst = (Uint16)pixels[datab>>7];
 430                                         }
 431                                         maskb <<= 1;
 432                                         datab <<= 1;
 433                                         dst++;
 434                                 }
 435                         }
 436                         dst += dstskip;
 437                 }
 438             }
 439             break;
 440
 441             case 3: {
 442                 Uint8 *dst;
 443                 int dstskip;
 444
 445                 dst = (Uint8 *)screen->pixels +
 446                        (SDL_cursor->area.y+area->y)*screen->pitch +
 447                        SDL_cursor->area.x*3;
 448                 dstskip = screen->pitch-area->w*3;
 449
 450                 for ( h=area->h; h; h-- ) {
 451                         for ( w=area->w/8; w; w-- ) {
 452                                 maskb = *mask++;
 453                                 datab = *data++;
 454                                 for ( i=0; i<8; ++i ) {
 455                                         if ( maskb & 0x80 ) {
 456                                                 SDL_memset(dst,pixels[datab>>7],3);
 457                                         }
 458                                         maskb <<= 1;
 459                                         datab <<= 1;
 460                                         dst += 3;
 461                                 }
 462                         }
 463                         dst += dstskip;
 464                 }
 465             }
 466             break;
 467
 468             case 4: {
 469                 Uint32 *dst;
 470                 int dstskip;
 471
 472                 dst = (Uint32 *)screen->pixels +
 473                        (SDL_cursor->area.y+area->y)*screen->pitch/4 +
 474                        SDL_cursor->area.x;
 475                 dstskip = (screen->pitch/4)-area->w;
 476
 477                 for ( h=area->h; h; h-- ) {
 478                         for ( w=area->w/8; w; w-- ) {
 479                                 maskb = *mask++;
 480                                 datab = *data++;
 481                                 for ( i=0; i<8; ++i ) {
 482                                         if ( maskb & 0x80 ) {
 483                                                 *dst = pixels[datab>>7];
 484                                         }
 485                                         maskb <<= 1;
 486                                         datab <<= 1;
 487                                         dst++;
 488                                 }
 489                         }
 490                         dst += dstskip;
 491                 }
 492             }
 493             break;
 494         }
 495 }
 496
 497 static void SDL_DrawCursorSlow(SDL_Surface *screen, SDL_Rect *area)
 498 {
 499         const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 };
 500         int h;
 501         int x, minx, maxx;
 502         Uint8 *data, datab = 0;
 503         Uint8 *mask, maskb = 0;
 504         Uint8 *dst;
 505         int dstbpp, dstskip;
 506
 507         data = SDL_cursor->data + area->y * SDL_cursor->area.w/8;
 508         mask = SDL_cursor->mask + area->y * SDL_cursor->area.w/8;
 509         dstbpp = screen->format->BytesPerPixel;
 510         dst = (Uint8 *)screen->pixels +
 511                        (SDL_cursor->area.y+area->y)*screen->pitch +
 512                        SDL_cursor->area.x*dstbpp;
 513         dstskip = screen->pitch-SDL_cursor->area.w*dstbpp;
 514
 515         minx = area->x;
 516         maxx = area->x+area->w;
 517         if ( screen->format->BytesPerPixel == 1 ) {
 518                 if ( palette_changed ) {
 519                         pixels8[0] = (Uint8)SDL_MapRGB(screen->format, 255, 255, 255);
 520                         pixels8[1] = (Uint8)SDL_MapRGB(screen->format, 0, 0, 0);
 521                         palette_changed = 0;
 522                 }
 523                 for ( h=area->h; h; h-- ) {
 524                         for ( x=0; x<SDL_cursor->area.w; ++x ) {
 525                                 if ( (x%8) == 0 ) {
 526                                         maskb = *mask++;
 527                                         datab = *data++;
 528                                 }
 529                                 if ( (x >= minx) && (x < maxx) ) {
 530                                         if ( maskb & 0x80 ) {
 531                                                 SDL_memset(dst, pixels8[datab>>7], dstbpp);
 532                                         }
 533                                 }
 534                                 maskb <<= 1;
 535                                 datab <<= 1;
 536                                 dst += dstbpp;
 537                         }
 538                         dst += dstskip;
 539                 }
 540         } else {
 541                 for ( h=area->h; h; h-- ) {
 542                         for ( x=0; x<SDL_cursor->area.w; ++x ) {
 543                                 if ( (x%8) == 0 ) {
 544                                         maskb = *mask++;
 545                                         datab = *data++;
 546                                 }
 547                                 if ( (x >= minx) && (x < maxx) ) {
 548                                         if ( maskb & 0x80 ) {
 549                                                 SDL_memset(dst, pixels[datab>>7], dstbpp);
 550                                         }
 551                                 }
 552                                 maskb <<= 1;
 553                                 datab <<= 1;
 554                                 dst += dstbpp;
 555                         }
 556                         dst += dstskip;
 557                 }
 558         }
 559 }
 560
 561 /* This handles the ugly work of converting the saved cursor background from
 562    the pixel format of the shadow surface to that of the video surface.
 563    This is only necessary when blitting from a shadow surface of a different
 564    pixel format than the video surface, and using a software rendered cursor.
 565 */
 566 static void SDL_ConvertCursorSave(SDL_Surface *screen, int w, int h)
 567 {
 568         SDL_BlitInfo info;
 569         SDL_loblit RunBlit;
 570
 571         /* Make sure we can steal the blit mapping */
 572         if ( screen->map->dst != SDL_VideoSurface ) {
 573                 return;
 574         }
 575
 576         /* Set up the blit information */
 577         info.s_pixels = SDL_cursor->save[1];
 578         info.s_width = w;
 579         info.s_height = h;
 580         info.s_skip = 0;
 581         info.d_pixels = SDL_cursor->save[0];
 582         info.d_width = w;
 583         info.d_height = h;
 584         info.d_skip = 0;
 585         info.aux_data = screen->map->sw_data->aux_data;
 586         info.src = screen->format;
 587         info.table = screen->map->table;
 588         info.dst = SDL_VideoSurface->format;
 589         RunBlit = screen->map->sw_data->blit;
 590
 591         /* Run the actual software blit */
 592         RunBlit(&info);
 593 }
 594
 595 void SDL_DrawCursorNoLock(SDL_Surface *screen)
 596 {
 597         SDL_Rect area;
 598
 599         /* Get the mouse rectangle, clipped to the screen */
 600         SDL_MouseRect(&area);
 601         if ( (area.w == 0) || (area.h == 0) ) {
 602                 return;
 603         }
 604
 605         /* Copy mouse background */
 606         { int w, h, screenbpp;
 607           Uint8 *src, *dst;
 608
 609           /* Set up the copy pointers */
 610           screenbpp = screen->format->BytesPerPixel;
 611           if ( (screen == SDL_VideoSurface) ||
 612                   FORMAT_EQUAL(screen->format, SDL_VideoSurface->format) ) {
 613                 dst = SDL_cursor->save[0];
 614           } else {
 615                 dst = SDL_cursor->save[1];
 616           }
 617           src = (Uint8 *)screen->pixels + area.y * screen->pitch +
 618                                           area.x * screenbpp;
 619
 620           /* Perform the copy */
 621           w = area.w*screenbpp;
 622           h = area.h;
 623           while ( h-- ) {
 624                   SDL_memcpy(dst, src, w);
 625                   dst += w;
 626                   src += screen->pitch;
 627           }
 628         }
 629
 630         /* Draw the mouse cursor */
 631         area.x -= SDL_cursor->area.x;
 632         area.y -= SDL_cursor->area.y;
 633         if ( (area.x == 0) && (area.w == SDL_cursor->area.w) ) {
 634                 SDL_DrawCursorFast(screen, &area);
 635         } else {
 636                 SDL_DrawCursorSlow(screen, &area);
 637         }
 638 }
 639
 640 void SDL_DrawCursor(SDL_Surface *screen)
 641 {
 642         /* Lock the screen if necessary */
 643         if ( screen == NULL ) {
 644                 return;
 645         }
 646         if ( SDL_MUSTLOCK(screen) ) {
 647                 if ( SDL_LockSurface(screen) < 0 ) {
 648                         return;
 649                 }
 650         }
 651
 652         SDL_DrawCursorNoLock(screen);
 653
 654         /* Unlock the screen and update if necessary */
 655         if ( SDL_MUSTLOCK(screen) ) {
 656                 SDL_UnlockSurface(screen);
 657         }
 658         if ( (screen == SDL_VideoSurface) &&
 659              ((screen->flags & SDL_HWSURFACE) != SDL_HWSURFACE) ) {
 660                 SDL_VideoDevice *video = current_video;
 661                 SDL_VideoDevice *this  = current_video;
 662                 SDL_Rect area;
 663
 664                 SDL_MouseRect(&area);
 665
 666                 /* This can be called before a video mode is set */
 667                 if ( video->UpdateRects ) {
 668                         video->UpdateRects(this, 1, &area);
 669                 }
 670         }
 671 }
 672
 673 void SDL_EraseCursorNoLock(SDL_Surface *screen)
 674 {
 675         SDL_Rect area;
 676
 677         /* Get the mouse rectangle, clipped to the screen */
 678         SDL_MouseRect(&area);
 679         if ( (area.w == 0) || (area.h == 0) ) {
 680                 return;
 681         }
 682
 683         /* Copy mouse background */
 684         { int w, h, screenbpp;
 685           Uint8 *src, *dst;
 686
 687           /* Set up the copy pointers */
 688           screenbpp = screen->format->BytesPerPixel;
 689           if ( (screen == SDL_VideoSurface) ||
 690                   FORMAT_EQUAL(screen->format, SDL_VideoSurface->format) ) {
 691                 src = SDL_cursor->save[0];
 692           } else {
 693                 src = SDL_cursor->save[1];
 694           }
 695           dst = (Uint8 *)screen->pixels + area.y * screen->pitch +
 696                                           area.x * screenbpp;
 697
 698           /* Perform the copy */
 699           w = area.w*screenbpp;
 700           h = area.h;
 701           while ( h-- ) {
 702                   SDL_memcpy(dst, src, w);
 703                   src += w;
 704                   dst += screen->pitch;
 705           }
 706
 707           /* Perform pixel conversion on cursor background */
 708           if ( src > SDL_cursor->save[1] ) {
 709                 SDL_ConvertCursorSave(screen, area.w, area.h);
 710           }
 711         }
 712 }
 713
 714 void SDL_EraseCursor(SDL_Surface *screen)
 715 {
 716         /* Lock the screen if necessary */
 717         if ( screen == NULL ) {
 718                 return;
 719         }
 720         if ( SDL_MUSTLOCK(screen) ) {
 721                 if ( SDL_LockSurface(screen) < 0 ) {
 722                         return;
 723                 }
 724         }
 725
 726         SDL_EraseCursorNoLock(screen);
 727
 728         /* Unlock the screen and update if necessary */
 729         if ( SDL_MUSTLOCK(screen) ) {
 730                 SDL_UnlockSurface(screen);
 731         }
 732         if ( (screen == SDL_VideoSurface) &&
 733              ((screen->flags & SDL_HWSURFACE) != SDL_HWSURFACE) ) {
 734                 SDL_VideoDevice *video = current_video;
 735                 SDL_VideoDevice *this  = current_video;
 736                 SDL_Rect area;
 737
 738                 SDL_MouseRect(&area);
 739                 if ( video->UpdateRects ) {
 740                         video->UpdateRects(this, 1, &area);
 741                 }
 742         }
 743 }
 744
 745 /* Reset the cursor on video mode change
 746    FIXME:  Keep track of all cursors, and reset them all.
 747  */
 748 void SDL_ResetCursor(void)
 749 {
 750         int savelen;
 751
 752         if ( SDL_cursor ) {
 753                 savelen = SDL_cursor->area.w*4*SDL_cursor->area.h;
 754                 SDL_cursor->area.x = 0;
 755                 SDL_cursor->area.y = 0;
 756                 SDL_memset(SDL_cursor->save[0], 0, savelen);
 757         }
 758 }