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