Mercurial > sdl-ios-xcode

comparison src/video/SDL_cursor.c @ 1668:4da1ee79c9af SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more tweaking indent options
author Sam Lantinga <slouken@libsdl.org>
date Mon, 29 May 2006 04:04:35 +0000
parents 782fd950bd46
children eef792d31de8
comparison
equal deleted inserted replaced
1667:1fddae038bc8 1668:4da1ee79c9af
40 static SDL_Cursor *SDL_defcursor = NULL; 40 static SDL_Cursor *SDL_defcursor = NULL;
41 SDL_mutex *SDL_cursorlock = NULL; 41 SDL_mutex *SDL_cursorlock = NULL;
42 42
43 /* Public functions */ 43 /* Public functions */
44 void 44 void
45 SDL_CursorQuit (void) 45 SDL_CursorQuit(void)
46 { 46 {
47 if (SDL_cursor != NULL) { 47 if (SDL_cursor != NULL) {
48 SDL_Cursor *cursor; 48 SDL_Cursor *cursor;
49 49
50 SDL_cursorstate &= ~CURSOR_VISIBLE; 50 SDL_cursorstate &= ~CURSOR_VISIBLE;
51 if (SDL_cursor != SDL_defcursor) { 51 if (SDL_cursor != SDL_defcursor) {
52 SDL_FreeCursor (SDL_cursor); 52 SDL_FreeCursor(SDL_cursor);
53 } 53 }
54 SDL_cursor = NULL; 54 SDL_cursor = NULL;
55 if (SDL_defcursor != NULL) { 55 if (SDL_defcursor != NULL) {
56 cursor = SDL_defcursor; 56 cursor = SDL_defcursor;
57 SDL_defcursor = NULL; 57 SDL_defcursor = NULL;
58 SDL_FreeCursor (cursor); 58 SDL_FreeCursor(cursor);
59 } 59 }
60 } 60 }
61 if (SDL_cursorlock != NULL) { 61 if (SDL_cursorlock != NULL) {
62 SDL_DestroyMutex (SDL_cursorlock); 62 SDL_DestroyMutex(SDL_cursorlock);
63 SDL_cursorlock = NULL; 63 SDL_cursorlock = NULL;
64 } 64 }
65 } 65 }
66 int 66 int
67 SDL_CursorInit (Uint32 multithreaded) 67 SDL_CursorInit(Uint32 multithreaded)
68 { 68 {
69 /* We don't have mouse focus, and the cursor isn't drawn yet */ 69 /* We don't have mouse focus, and the cursor isn't drawn yet */
70 #ifndef IPOD 70 #ifndef IPOD
71 SDL_cursorstate = CURSOR_VISIBLE; 71 SDL_cursorstate = CURSOR_VISIBLE;
72 #endif 72 #endif
73 73
74 /* Create the default cursor */ 74 /* Create the default cursor */
75 if (SDL_defcursor == NULL) { 75 if (SDL_defcursor == NULL) {
76 SDL_defcursor = SDL_CreateCursor (default_cdata, default_cmask, 76 SDL_defcursor = SDL_CreateCursor(default_cdata, default_cmask,
77 DEFAULT_CWIDTH, DEFAULT_CHEIGHT, 77 DEFAULT_CWIDTH, DEFAULT_CHEIGHT,
78 DEFAULT_CHOTX, DEFAULT_CHOTY); 78 DEFAULT_CHOTX, DEFAULT_CHOTY);
79 SDL_SetCursor (SDL_defcursor); 79 SDL_SetCursor(SDL_defcursor);
80 } 80 }
81 81
82 /* Create a lock if necessary */ 82 /* Create a lock if necessary */
83 if (multithreaded) { 83 if (multithreaded) {
84 SDL_cursorlock = SDL_CreateMutex (); 84 SDL_cursorlock = SDL_CreateMutex();
85 } 85 }
86 86
87 /* That's it! */ 87 /* That's it! */
88 return (0); 88 return (0);
89 } 89 }
90 90
91 /* Multi-thread support for cursors */ 91 /* Multi-thread support for cursors */
92 #ifndef SDL_LockCursor 92 #ifndef SDL_LockCursor
93 void 93 void
94 SDL_LockCursor (void) 94 SDL_LockCursor(void)
95 { 95 {
96 if (SDL_cursorlock) { 96 if (SDL_cursorlock) {
97 SDL_mutexP (SDL_cursorlock); 97 SDL_mutexP(SDL_cursorlock);
98 } 98 }
99 } 99 }
100 #endif 100 #endif
101 #ifndef SDL_UnlockCursor 101 #ifndef SDL_UnlockCursor
102 void 102 void
103 SDL_UnlockCursor (void) 103 SDL_UnlockCursor(void)
104 { 104 {
105 if (SDL_cursorlock) { 105 if (SDL_cursorlock) {
106 SDL_mutexV (SDL_cursorlock); 106 SDL_mutexV(SDL_cursorlock);
107 } 107 }
108 } 108 }
109 #endif 109 #endif
110 110
111 /* Software cursor drawing support */ 111 /* Software cursor drawing support */
112 SDL_Cursor * 112 SDL_Cursor *
113 SDL_CreateCursor (Uint8 * data, Uint8 * mask, 113 SDL_CreateCursor(Uint8 * data, Uint8 * mask,
114 int w, int h, int hot_x, int hot_y) 114 int w, int h, int hot_x, int hot_y)
115 { 115 {
116 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 116 SDL_VideoDevice *_this = SDL_GetVideoDevice();
117 int savelen; 117 int savelen;
118 int i; 118 int i;
119 SDL_Cursor *cursor; 119 SDL_Cursor *cursor;
120 120
121 /* Make sure the width is a multiple of 8 */ 121 /* Make sure the width is a multiple of 8 */
122 w = ((w + 7) & ~7); 122 w = ((w + 7) & ~7);
123 123
124 /* Sanity check the hot spot */ 124 /* Sanity check the hot spot */
125 if ((hot_x < 0) || (hot_y < 0) || (hot_x >= w) || (hot_y >= h)) { 125 if ((hot_x < 0) || (hot_y < 0) || (hot_x >= w) || (hot_y >= h)) {
126 SDL_SetError ("Cursor hot spot doesn't lie within cursor"); 126 SDL_SetError("Cursor hot spot doesn't lie within cursor");
127 return (NULL); 127 return (NULL);
128 } 128 }
129 129
130 /* Allocate memory for the cursor */ 130 /* Allocate memory for the cursor */
131 cursor = (SDL_Cursor *) SDL_malloc (sizeof *cursor); 131 cursor = (SDL_Cursor *) SDL_malloc(sizeof *cursor);
132 if (cursor == NULL) { 132 if (cursor == NULL) {
133 SDL_OutOfMemory (); 133 SDL_OutOfMemory();
134 return (NULL); 134 return (NULL);
135 } 135 }
136 savelen = (w * 4) * h; 136 savelen = (w * 4) * h;
137 cursor->area.x = 0; 137 cursor->area.x = 0;
138 cursor->area.y = 0; 138 cursor->area.y = 0;
139 cursor->area.w = w; 139 cursor->area.w = w;
140 cursor->area.h = h; 140 cursor->area.h = h;
141 cursor->hot_x = hot_x; 141 cursor->hot_x = hot_x;
142 cursor->hot_y = hot_y; 142 cursor->hot_y = hot_y;
143 cursor->data = (Uint8 *) SDL_malloc ((w / 8) * h * 2); 143 cursor->data = (Uint8 *) SDL_malloc((w / 8) * h * 2);
144 cursor->mask = cursor->data + ((w / 8) * h); 144 cursor->mask = cursor->data + ((w / 8) * h);
145 cursor->save[0] = (Uint8 *) SDL_malloc (savelen * 2); 145 cursor->save[0] = (Uint8 *) SDL_malloc(savelen * 2);
146 cursor->save[1] = cursor->save[0] + savelen; 146 cursor->save[1] = cursor->save[0] + savelen;
147 cursor->wm_cursor = NULL; 147 cursor->wm_cursor = NULL;
148 if (!cursor->data || !cursor->save[0]) { 148 if (!cursor->data || !cursor->save[0]) {
149 SDL_FreeCursor (cursor); 149 SDL_FreeCursor(cursor);
150 SDL_OutOfMemory (); 150 SDL_OutOfMemory();
151 return (NULL); 151 return (NULL);
152 } 152 }
153 for (i = ((w / 8) * h) - 1; i >= 0; --i) { 153 for (i = ((w / 8) * h) - 1; i >= 0; --i) {
154 cursor->data[i] = data[i]; 154 cursor->data[i] = data[i];
155 cursor->mask[i] = mask[i] | data[i]; 155 cursor->mask[i] = mask[i] | data[i];
156 } 156 }
157 SDL_memset (cursor->save[0], 0, savelen * 2); 157 SDL_memset(cursor->save[0], 0, savelen * 2);
158 158
159 /* If the window manager gives us a good cursor, we're done! */ 159 /* If the window manager gives us a good cursor, we're done! */
160 if (_this->CreateWMCursor) { 160 if (_this->CreateWMCursor) {
161 cursor->wm_cursor = _this->CreateWMCursor (_this, data, mask, 161 cursor->wm_cursor = _this->CreateWMCursor(_this, data, mask,
162 w, h, hot_x, hot_y); 162 w, h, hot_x, hot_y);
163 } else { 163 } else {
164 cursor->wm_cursor = NULL; 164 cursor->wm_cursor = NULL;
165 } 165 }
166 return (cursor); 166 return (cursor);
167 } 167 }
169 /* SDL_SetCursor(NULL) can be used to force the cursor redraw, 169 /* SDL_SetCursor(NULL) can be used to force the cursor redraw,
170 if this is desired for any reason. This is used when setting 170 if this is desired for any reason. This is used when setting
171 the video mode and when the SDL window gains the mouse focus. 171 the video mode and when the SDL window gains the mouse focus.
172 */ 172 */
173 void 173 void
174 SDL_SetCursor (SDL_Cursor * cursor) 174 SDL_SetCursor(SDL_Cursor * cursor)
175 { 175 {
176 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 176 SDL_VideoDevice *_this = SDL_GetVideoDevice();
177 177
178 /* Make sure that the video subsystem has been initialized */ 178 /* Make sure that the video subsystem has been initialized */
179 if (!_this) { 179 if (!_this) {
180 return; 180 return;
181 } 181 }
182 182
183 /* Prevent the event thread from moving the mouse */ 183 /* Prevent the event thread from moving the mouse */
184 SDL_LockCursor (); 184 SDL_LockCursor();
185 185
186 /* Set the new cursor */ 186 /* Set the new cursor */
187 if (cursor && (cursor != SDL_cursor)) { 187 if (cursor && (cursor != SDL_cursor)) {
188 /* Erase the current mouse position */ 188 /* Erase the current mouse position */
189 if (SHOULD_DRAWCURSOR (SDL_cursorstate)) { 189 if (SHOULD_DRAWCURSOR(SDL_cursorstate)) {
190 SDL_EraseCursor (SDL_VideoSurface); 190 SDL_EraseCursor(SDL_VideoSurface);
191 } else if (_this->MoveWMCursor) { 191 } else if (_this->MoveWMCursor) {
192 /* If the video driver is moving the cursor directly, 192 /* If the video driver is moving the cursor directly,
193 it needs to hide the old cursor before (possibly) 193 it needs to hide the old cursor before (possibly)
194 showing the new one. (But don't erase NULL cursor) 194 showing the new one. (But don't erase NULL cursor)
195 */ 195 */
196 if (SDL_cursor) { 196 if (SDL_cursor) {
197 _this->ShowWMCursor (_this, NULL); 197 _this->ShowWMCursor(_this, NULL);
198 } 198 }
199 } 199 }
200 SDL_cursor = cursor; 200 SDL_cursor = cursor;
201 } 201 }
202 202
203 /* Draw the new mouse cursor */ 203 /* Draw the new mouse cursor */
204 if (SDL_cursor && (SDL_cursorstate & CURSOR_VISIBLE)) { 204 if (SDL_cursor && (SDL_cursorstate & CURSOR_VISIBLE)) {
205 /* Use window manager cursor if possible */ 205 /* Use window manager cursor if possible */
206 if (SDL_cursor->wm_cursor && 206 if (SDL_cursor->wm_cursor &&
207 _this->ShowWMCursor (_this, SDL_cursor->wm_cursor)) { 207 _this->ShowWMCursor(_this, SDL_cursor->wm_cursor)) {
208 SDL_cursorstate &= ~CURSOR_USINGSW; 208 SDL_cursorstate &= ~CURSOR_USINGSW;
209 } else { 209 } else {
210 SDL_cursorstate |= CURSOR_USINGSW; 210 SDL_cursorstate |= CURSOR_USINGSW;
211 if (_this->ShowWMCursor) { 211 if (_this->ShowWMCursor) {
212 _this->ShowWMCursor (_this, NULL); 212 _this->ShowWMCursor(_this, NULL);
213 } 213 }
214 { 214 {
215 int x, y; 215 int x, y;
216 SDL_GetMouseState (&x, &y); 216 SDL_GetMouseState(&x, &y);
217 SDL_cursor->area.x = (x - SDL_cursor->hot_x); 217 SDL_cursor->area.x = (x - SDL_cursor->hot_x);
218 SDL_cursor->area.y = (y - SDL_cursor->hot_y); 218 SDL_cursor->area.y = (y - SDL_cursor->hot_y);
219 } 219 }
220 SDL_DrawCursor (SDL_VideoSurface); 220 SDL_DrawCursor(SDL_VideoSurface);
221 } 221 }
222 } else { 222 } else {
223 /* Erase window manager mouse (cursor not visible) */ 223 /* Erase window manager mouse (cursor not visible) */
224 if (SDL_cursor && (SDL_cursorstate & CURSOR_USINGSW)) { 224 if (SDL_cursor && (SDL_cursorstate & CURSOR_USINGSW)) {
225 SDL_EraseCursor (SDL_VideoSurface); 225 SDL_EraseCursor(SDL_VideoSurface);
226 } else { 226 } else {
227 if (_this) { 227 if (_this) {
228 _this->ShowWMCursor (_this, NULL); 228 _this->ShowWMCursor(_this, NULL);
229 } 229 }
230 } 230 }
231 } 231 }
232 SDL_UnlockCursor (); 232 SDL_UnlockCursor();
233 } 233 }
234 234
235 SDL_Cursor * 235 SDL_Cursor *
236 SDL_GetCursor (void) 236 SDL_GetCursor(void)
237 { 237 {
238 return (SDL_cursor); 238 return (SDL_cursor);
239 } 239 }
240 240
241 void 241 void
242 SDL_FreeCursor (SDL_Cursor * cursor) 242 SDL_FreeCursor(SDL_Cursor * cursor)
243 { 243 {
244 if (cursor) { 244 if (cursor) {
245 if (cursor == SDL_cursor) { 245 if (cursor == SDL_cursor) {
246 SDL_SetCursor (SDL_defcursor); 246 SDL_SetCursor(SDL_defcursor);
247 } 247 }
248 if (cursor != SDL_defcursor) { 248 if (cursor != SDL_defcursor) {
249 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 249 SDL_VideoDevice *_this = SDL_GetVideoDevice();
250 250
251 if (cursor->data) { 251 if (cursor->data) {
252 SDL_free (cursor->data); 252 SDL_free(cursor->data);
253 } 253 }
254 if (cursor->save[0]) { 254 if (cursor->save[0]) {
255 SDL_free (cursor->save[0]); 255 SDL_free(cursor->save[0]);
256 } 256 }
257 if (_this && cursor->wm_cursor) { 257 if (_this && cursor->wm_cursor) {
258 _this->FreeWMCursor (_this, cursor->wm_cursor); 258 _this->FreeWMCursor(_this, cursor->wm_cursor);
259 } 259 }
260 SDL_free (cursor); 260 SDL_free(cursor);
261 } 261 }
262 } 262 }
263 } 263 }
264 264
265 int 265 int
266 SDL_ShowCursor (int toggle) 266 SDL_ShowCursor(int toggle)
267 { 267 {
268 int showing; 268 int showing;
269 269
270 showing = (SDL_cursorstate & CURSOR_VISIBLE); 270 showing = (SDL_cursorstate & CURSOR_VISIBLE);
271 if (toggle >= 0) { 271 if (toggle >= 0) {
272 SDL_LockCursor (); 272 SDL_LockCursor();
273 if (toggle) { 273 if (toggle) {
274 SDL_cursorstate |= CURSOR_VISIBLE; 274 SDL_cursorstate |= CURSOR_VISIBLE;
275 } else { 275 } else {
276 SDL_cursorstate &= ~CURSOR_VISIBLE; 276 SDL_cursorstate &= ~CURSOR_VISIBLE;
277 } 277 }
278 SDL_UnlockCursor (); 278 SDL_UnlockCursor();
279 if ((SDL_cursorstate & CURSOR_VISIBLE) != showing) { 279 if ((SDL_cursorstate & CURSOR_VISIBLE) != showing) {
280 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 280 SDL_VideoDevice *_this = SDL_GetVideoDevice();
281 281
282 SDL_SetCursor (NULL); 282 SDL_SetCursor(NULL);
283 if (_this && _this->CheckMouseMode) { 283 if (_this && _this->CheckMouseMode) {
284 _this->CheckMouseMode (_this); 284 _this->CheckMouseMode(_this);
285 } 285 }
286 } 286 }
287 } else { 287 } else {
288 /* Query current state */ ; 288 /* Query current state */ ;
289 } 289 }
290 return (showing ? 1 : 0); 290 return (showing ? 1 : 0);
291 } 291 }
292 292
293 void 293 void
294 SDL_WarpMouse (Uint16 x, Uint16 y) 294 SDL_WarpMouse(Uint16 x, Uint16 y)
295 { 295 {
296 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 296 SDL_VideoDevice *_this = SDL_GetVideoDevice();
297 297
298 if (!_this || !SDL_PublicSurface) { 298 if (!_this || !SDL_PublicSurface) {
299 SDL_SetError ("A video mode must be set before warping mouse"); 299 SDL_SetError("A video mode must be set before warping mouse");
300 return; 300 return;
301 } 301 }
302 302
303 /* If we have an offset video mode, offset the mouse coordinates */ 303 /* If we have an offset video mode, offset the mouse coordinates */
304 if (SDL_VideoSurface->pitch == 0) { 304 if (SDL_VideoSurface->pitch == 0) {
311 y += (SDL_VideoSurface->offset / SDL_VideoSurface->pitch); 311 y += (SDL_VideoSurface->offset / SDL_VideoSurface->pitch);
312 } 312 }
313 313
314 /* This generates a mouse motion event */ 314 /* This generates a mouse motion event */
315 if (_this->WarpWMCursor) { 315 if (_this->WarpWMCursor) {
316 _this->WarpWMCursor (_this, x, y); 316 _this->WarpWMCursor(_this, x, y);
317 } else { 317 } else {
318 SDL_PrivateMouseMotion (0, 0, x, y); 318 SDL_PrivateMouseMotion(0, 0, x, y);
319 } 319 }
320 } 320 }
321 321
322 void 322 void
323 SDL_MoveCursor (int x, int y) 323 SDL_MoveCursor(int x, int y)
324 { 324 {
325 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 325 SDL_VideoDevice *_this = SDL_GetVideoDevice();
326 326
327 /* Erase and update the current mouse position */ 327 /* Erase and update the current mouse position */
328 if (SHOULD_DRAWCURSOR (SDL_cursorstate)) { 328 if (SHOULD_DRAWCURSOR(SDL_cursorstate)) {
329 /* Erase and redraw mouse cursor in new position */ 329 /* Erase and redraw mouse cursor in new position */
330 SDL_LockCursor (); 330 SDL_LockCursor();
331 SDL_EraseCursor (SDL_VideoSurface); 331 SDL_EraseCursor(SDL_VideoSurface);
332 SDL_cursor->area.x = (x - SDL_cursor->hot_x); 332 SDL_cursor->area.x = (x - SDL_cursor->hot_x);
333 SDL_cursor->area.y = (y - SDL_cursor->hot_y); 333 SDL_cursor->area.y = (y - SDL_cursor->hot_y);
334 SDL_DrawCursor (SDL_VideoSurface); 334 SDL_DrawCursor(SDL_VideoSurface);
335 SDL_UnlockCursor (); 335 SDL_UnlockCursor();
336 } else if (_this->MoveWMCursor) { 336 } else if (_this->MoveWMCursor) {
337 _this->MoveWMCursor (_this, x, y); 337 _this->MoveWMCursor(_this, x, y);
338 } 338 }
339 } 339 }
340 340
341 /* Keep track of the current cursor colors */ 341 /* Keep track of the current cursor colors */
342 static int palette_changed = 1; 342 static int palette_changed = 1;
343 static Uint8 pixels8[2]; 343 static Uint8 pixels8[2];
344 344
345 void 345 void
346 SDL_CursorPaletteChanged (void) 346 SDL_CursorPaletteChanged(void)
347 { 347 {
348 palette_changed = 1; 348 palette_changed = 1;
349 } 349 }
350 350
351 void 351 void
352 SDL_MouseRect (SDL_Rect * area) 352 SDL_MouseRect(SDL_Rect * area)
353 { 353 {
354 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 354 SDL_VideoDevice *_this = SDL_GetVideoDevice();
355 int clip_diff; 355 int clip_diff;
356 356
357 *area = SDL_cursor->area; 357 *area = SDL_cursor->area;
358 if (area->x < 0) { 358 if (area->x < 0) {
359 area->w += area->x; 359 area->w += area->x;
372 area->h = area->h < clip_diff ? 0 : area->h - clip_diff; 372 area->h = area->h < clip_diff ? 0 : area->h - clip_diff;
373 } 373 }
374 } 374 }
375 375
376 static void 376 static void
377 SDL_DrawCursorFast (SDL_Surface * screen, SDL_Rect * area) 377 SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area)
378 { 378 {
379 const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 }; 379 const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 };
380 int i, w, h; 380 int i, w, h;
381 Uint8 *data, datab; 381 Uint8 *data, datab;
382 Uint8 *mask, maskb; 382 Uint8 *mask, maskb;
390 Uint8 *dst; 390 Uint8 *dst;
391 int dstskip; 391 int dstskip;
392 392
393 if (palette_changed) { 393 if (palette_changed) {
394 pixels8[0] = 394 pixels8[0] =
395 (Uint8) SDL_MapRGB (screen->format, 255, 255, 255); 395 (Uint8) SDL_MapRGB(screen->format, 255, 255, 255);
396 pixels8[1] = (Uint8) SDL_MapRGB (screen->format, 0, 0, 0); 396 pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0);
397 palette_changed = 0; 397 palette_changed = 0;
398 } 398 }
399 dst = (Uint8 *) screen->pixels + 399 dst = (Uint8 *) screen->pixels +
400 (SDL_cursor->area.y + area->y) * screen->pitch + 400 (SDL_cursor->area.y + area->y) * screen->pitch +
401 SDL_cursor->area.x; 401 SDL_cursor->area.x;
461 for (w = area->w / 8; w; w--) { 461 for (w = area->w / 8; w; w--) {
462 maskb = *mask++; 462 maskb = *mask++;
463 datab = *data++; 463 datab = *data++;
464 for (i = 0; i < 8; ++i) { 464 for (i = 0; i < 8; ++i) {
465 if (maskb & 0x80) { 465 if (maskb & 0x80) {
466 SDL_memset (dst, pixels[datab >> 7], 3); 466 SDL_memset(dst, pixels[datab >> 7], 3);
467 } 467 }
468 maskb <<= 1; 468 maskb <<= 1;
469 datab <<= 1; 469 datab <<= 1;
470 dst += 3; 470 dst += 3;
471 } 471 }
504 break; 504 break;
505 } 505 }
506 } 506 }
507 507
508 static void 508 static void
509 SDL_DrawCursorSlow (SDL_Surface * screen, SDL_Rect * area) 509 SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area)
510 { 510 {
511 const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 }; 511 const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 };
512 int h; 512 int h;
513 int x, minx, maxx; 513 int x, minx, maxx;
514 Uint8 *data, datab = 0; 514 Uint8 *data, datab = 0;
526 526
527 minx = area->x; 527 minx = area->x;
528 maxx = area->x + area->w; 528 maxx = area->x + area->w;
529 if (screen->format->BytesPerPixel == 1) { 529 if (screen->format->BytesPerPixel == 1) {
530 if (palette_changed) { 530 if (palette_changed) {
531 pixels8[0] = (Uint8) SDL_MapRGB (screen->format, 255, 255, 255); 531 pixels8[0] = (Uint8) SDL_MapRGB(screen->format, 255, 255, 255);
532 pixels8[1] = (Uint8) SDL_MapRGB (screen->format, 0, 0, 0); 532 pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0);
533 palette_changed = 0; 533 palette_changed = 0;
534 } 534 }
535 for (h = area->h; h; h--) { 535 for (h = area->h; h; h--) {
536 for (x = 0; x < SDL_cursor->area.w; ++x) { 536 for (x = 0; x < SDL_cursor->area.w; ++x) {
537 if ((x % 8) == 0) { 537 if ((x % 8) == 0) {
538 maskb = *mask++; 538 maskb = *mask++;
539 datab = *data++; 539 datab = *data++;
540 } 540 }
541 if ((x >= minx) && (x < maxx)) { 541 if ((x >= minx) && (x < maxx)) {
542 if (maskb & 0x80) { 542 if (maskb & 0x80) {
543 SDL_memset (dst, pixels8[datab >> 7], dstbpp); 543 SDL_memset(dst, pixels8[datab >> 7], dstbpp);
544 } 544 }
545 } 545 }
546 maskb <<= 1; 546 maskb <<= 1;
547 datab <<= 1; 547 datab <<= 1;
548 dst += dstbpp; 548 dst += dstbpp;
556 maskb = *mask++; 556 maskb = *mask++;
557 datab = *data++; 557 datab = *data++;
558 } 558 }
559 if ((x >= minx) && (x < maxx)) { 559 if ((x >= minx) && (x < maxx)) {
560 if (maskb & 0x80) { 560 if (maskb & 0x80) {
561 SDL_memset (dst, pixels[datab >> 7], dstbpp); 561 SDL_memset(dst, pixels[datab >> 7], dstbpp);
562 } 562 }
563 } 563 }
564 maskb <<= 1; 564 maskb <<= 1;
565 datab <<= 1; 565 datab <<= 1;
566 dst += dstbpp; 566 dst += dstbpp;
574 the pixel format of the shadow surface to that of the video surface. 574 the pixel format of the shadow surface to that of the video surface.
575 This is only necessary when blitting from a shadow surface of a different 575 This is only necessary when blitting from a shadow surface of a different
576 pixel format than the video surface, and using a software rendered cursor. 576 pixel format than the video surface, and using a software rendered cursor.
577 */ 577 */
578 static void 578 static void
579 SDL_ConvertCursorSave (SDL_Surface * screen, int w, int h) 579 SDL_ConvertCursorSave(SDL_Surface * screen, int w, int h)
580 { 580 {
581 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 581 SDL_VideoDevice *_this = SDL_GetVideoDevice();
582 SDL_BlitInfo info; 582 SDL_BlitInfo info;
583 SDL_loblit RunBlit; 583 SDL_loblit RunBlit;
584 584
585 /* Make sure we can steal the blit mapping */ 585 /* Make sure we can steal the blit mapping */
586 if (screen->map->dst != SDL_VideoSurface) { 586 if (screen->map->dst != SDL_VideoSurface) {
601 info.table = screen->map->table; 601 info.table = screen->map->table;
602 info.dst = SDL_VideoSurface->format; 602 info.dst = SDL_VideoSurface->format;
603 RunBlit = screen->map->sw_data->blit; 603 RunBlit = screen->map->sw_data->blit;
604 604
605 /* Run the actual software blit */ 605 /* Run the actual software blit */
606 RunBlit (&info); 606 RunBlit(&info);
607 } 607 }
608 608
609 void 609 void
610 SDL_DrawCursorNoLock (SDL_Surface * screen) 610 SDL_DrawCursorNoLock(SDL_Surface * screen)
611 { 611 {
612 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 612 SDL_VideoDevice *_this = SDL_GetVideoDevice();
613 SDL_Rect area; 613 SDL_Rect area;
614 614
615 /* Get the mouse rectangle, clipped to the screen */ 615 /* Get the mouse rectangle, clipped to the screen */
616 SDL_MouseRect (&area); 616 SDL_MouseRect(&area);
617 if ((area.w == 0) || (area.h == 0)) { 617 if ((area.w == 0) || (area.h == 0)) {
618 return; 618 return;
619 } 619 }
620 620
621 /* Copy mouse background */ 621 /* Copy mouse background */
624 Uint8 *src, *dst; 624 Uint8 *src, *dst;
625 625
626 /* Set up the copy pointers */ 626 /* Set up the copy pointers */
627 screenbpp = screen->format->BytesPerPixel; 627 screenbpp = screen->format->BytesPerPixel;
628 if ((screen == SDL_VideoSurface) || 628 if ((screen == SDL_VideoSurface) ||
629 FORMAT_EQUAL (screen->format, SDL_VideoSurface->format)) { 629 FORMAT_EQUAL(screen->format, SDL_VideoSurface->format)) {
630 dst = SDL_cursor->save[0]; 630 dst = SDL_cursor->save[0];
631 } else { 631 } else {
632 dst = SDL_cursor->save[1]; 632 dst = SDL_cursor->save[1];
633 } 633 }
634 src = (Uint8 *) screen->pixels + area.y * screen->pitch + 634 src = (Uint8 *) screen->pixels + area.y * screen->pitch +
636 636
637 /* Perform the copy */ 637 /* Perform the copy */
638 w = area.w * screenbpp; 638 w = area.w * screenbpp;
639 h = area.h; 639 h = area.h;
640 while (h--) { 640 while (h--) {
641 SDL_memcpy (dst, src, w); 641 SDL_memcpy(dst, src, w);
642 dst += w; 642 dst += w;
643 src += screen->pitch; 643 src += screen->pitch;
644 } 644 }
645 } 645 }
646 646
647 /* Draw the mouse cursor */ 647 /* Draw the mouse cursor */
648 area.x -= SDL_cursor->area.x; 648 area.x -= SDL_cursor->area.x;
649 area.y -= SDL_cursor->area.y; 649 area.y -= SDL_cursor->area.y;
650 if ((area.x == 0) && (area.w == SDL_cursor->area.w)) { 650 if ((area.x == 0) && (area.w == SDL_cursor->area.w)) {
651 SDL_DrawCursorFast (screen, &area); 651 SDL_DrawCursorFast(screen, &area);
652 } else { 652 } else {
653 SDL_DrawCursorSlow (screen, &area); 653 SDL_DrawCursorSlow(screen, &area);
654 } 654 }
655 } 655 }
656 656
657 void 657 void
658 SDL_DrawCursor (SDL_Surface * screen) 658 SDL_DrawCursor(SDL_Surface * screen)
659 { 659 {
660 /* Lock the screen if necessary */ 660 /* Lock the screen if necessary */
661 if (screen == NULL) { 661 if (screen == NULL) {
662 return; 662 return;
663 } 663 }
664 if (SDL_MUSTLOCK (screen)) { 664 if (SDL_MUSTLOCK(screen)) {
665 if (SDL_LockSurface (screen) < 0) { 665 if (SDL_LockSurface(screen) < 0) {
666 return; 666 return;
667 } 667 }
668 } 668 }
669 669
670 SDL_DrawCursorNoLock (screen); 670 SDL_DrawCursorNoLock(screen);
671 671
672 /* Unlock the screen and update if necessary */ 672 /* Unlock the screen and update if necessary */
673 if (SDL_MUSTLOCK (screen)) { 673 if (SDL_MUSTLOCK(screen)) {
674 SDL_UnlockSurface (screen); 674 SDL_UnlockSurface(screen);
675 } 675 }
676 if ((screen->flags & SDL_SCREEN_SURFACE) && 676 if ((screen->flags & SDL_SCREEN_SURFACE) &&
677 !(screen->flags & SDL_HWSURFACE)) { 677 !(screen->flags & SDL_HWSURFACE)) {
678 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 678 SDL_VideoDevice *_this = SDL_GetVideoDevice();
679 SDL_Window *window; 679 SDL_Window *window;
680 SDL_Rect area; 680 SDL_Rect area;
681 681
682 window = SDL_GetWindowFromSurface (screen); 682 window = SDL_GetWindowFromSurface(screen);
683 if (!window) { 683 if (!window) {
684 return; 684 return;
685 } 685 }
686 686
687 SDL_MouseRect (&area); 687 SDL_MouseRect(&area);
688 688
689 if (_this->UpdateWindowSurface) { 689 if (_this->UpdateWindowSurface) {
690 _this->UpdateWindowSurface (_this, window, 1, &area); 690 _this->UpdateWindowSurface(_this, window, 1, &area);
691 } 691 }
692 } 692 }
693 } 693 }
694 694
695 void 695 void
696 SDL_EraseCursorNoLock (SDL_Surface * screen) 696 SDL_EraseCursorNoLock(SDL_Surface * screen)
697 { 697 {
698 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 698 SDL_VideoDevice *_this = SDL_GetVideoDevice();
699 SDL_Window *window; 699 SDL_Window *window;
700 SDL_Rect area; 700 SDL_Rect area;
701 701
702 /* Get the window associated with the surface */ 702 /* Get the window associated with the surface */
703 window = SDL_GetWindowFromSurface (screen); 703 window = SDL_GetWindowFromSurface(screen);
704 if (!window || !window->surface) { 704 if (!window || !window->surface) {
705 return; 705 return;
706 } 706 }
707 707
708 /* Get the mouse rectangle, clipped to the screen */ 708 /* Get the mouse rectangle, clipped to the screen */
709 SDL_MouseRect (&area); 709 SDL_MouseRect(&area);
710 if ((area.w == 0) || (area.h == 0)) { 710 if ((area.w == 0) || (area.h == 0)) {
711 return; 711 return;
712 } 712 }
713 713
714 /* Copy mouse background */ 714 /* Copy mouse background */
717 Uint8 *src, *dst; 717 Uint8 *src, *dst;
718 718
719 /* Set up the copy pointers */ 719 /* Set up the copy pointers */
720 screenbpp = screen->format->BytesPerPixel; 720 screenbpp = screen->format->BytesPerPixel;
721 if ((screen->flags & SDL_SCREEN_SURFACE) || 721 if ((screen->flags & SDL_SCREEN_SURFACE) ||
722 FORMAT_EQUAL (screen->format, window->surface->format)) { 722 FORMAT_EQUAL(screen->format, window->surface->format)) {
723 src = SDL_cursor->save[0]; 723 src = SDL_cursor->save[0];
724 } else { 724 } else {
725 src = SDL_cursor->save[1]; 725 src = SDL_cursor->save[1];
726 } 726 }
727 dst = (Uint8 *) screen->pixels + area.y * screen->pitch + 727 dst = (Uint8 *) screen->pixels + area.y * screen->pitch +
729 729
730 /* Perform the copy */ 730 /* Perform the copy */
731 w = area.w * screenbpp; 731 w = area.w * screenbpp;
732 h = area.h; 732 h = area.h;
733 while (h--) { 733 while (h--) {
734 SDL_memcpy (dst, src, w); 734 SDL_memcpy(dst, src, w);
735 src += w; 735 src += w;
736 dst += screen->pitch; 736 dst += screen->pitch;
737 } 737 }
738 738
739 /* Perform pixel conversion on cursor background */ 739 /* Perform pixel conversion on cursor background */
740 if (src > SDL_cursor->save[1]) { 740 if (src > SDL_cursor->save[1]) {
741 SDL_ConvertCursorSave (screen, area.w, area.h); 741 SDL_ConvertCursorSave(screen, area.w, area.h);
742 } 742 }
743 } 743 }
744 } 744 }
745 745
746 void 746 void
747 SDL_EraseCursor (SDL_Surface * screen) 747 SDL_EraseCursor(SDL_Surface * screen)
748 { 748 {
749 /* Lock the screen if necessary */ 749 /* Lock the screen if necessary */
750 if (screen == NULL) { 750 if (screen == NULL) {
751 return; 751 return;
752 } 752 }
753 if (SDL_MUSTLOCK (screen)) { 753 if (SDL_MUSTLOCK(screen)) {
754 if (SDL_LockSurface (screen) < 0) { 754 if (SDL_LockSurface(screen) < 0) {
755 return; 755 return;
756 } 756 }
757 } 757 }
758 758
759 SDL_EraseCursorNoLock (screen); 759 SDL_EraseCursorNoLock(screen);
760 760
761 /* Unlock the screen and update if necessary */ 761 /* Unlock the screen and update if necessary */
762 if (SDL_MUSTLOCK (screen)) { 762 if (SDL_MUSTLOCK(screen)) {
763 SDL_UnlockSurface (screen); 763 SDL_UnlockSurface(screen);
764 } 764 }
765 if ((screen->flags & SDL_SCREEN_SURFACE) && 765 if ((screen->flags & SDL_SCREEN_SURFACE) &&
766 !(screen->flags & SDL_HWSURFACE)) { 766 !(screen->flags & SDL_HWSURFACE)) {
767 SDL_VideoDevice *_this = SDL_GetVideoDevice (); 767 SDL_VideoDevice *_this = SDL_GetVideoDevice();
768 SDL_Window *window; 768 SDL_Window *window;
769 SDL_Rect area; 769 SDL_Rect area;
770 770
771 window = SDL_GetWindowFromSurface (screen); 771 window = SDL_GetWindowFromSurface(screen);
772 if (!window) { 772 if (!window) {
773 return; 773 return;
774 } 774 }
775 775
776 SDL_MouseRect (&area); 776 SDL_MouseRect(&area);
777 777
778 if (_this->UpdateWindowSurface) { 778 if (_this->UpdateWindowSurface) {
779 _this->UpdateWindowSurface (_this, window, 1, &area); 779 _this->UpdateWindowSurface(_this, window, 1, &area);
780 } 780 }
781 } 781 }
782 } 782 }
783 783
784 /* Reset the cursor on video mode change 784 /* Reset the cursor on video mode change
785 FIXME: Keep track of all cursors, and reset them all. 785 FIXME: Keep track of all cursors, and reset them all.
786 */ 786 */
787 void 787 void
788 SDL_ResetCursor (void) 788 SDL_ResetCursor(void)
789 { 789 {
790 int savelen; 790 int savelen;
791 791
792 if (SDL_cursor) { 792 if (SDL_cursor) {
793 savelen = SDL_cursor->area.w * 4 * SDL_cursor->area.h; 793 savelen = SDL_cursor->area.w * 4 * SDL_cursor->area.h;
794 SDL_cursor->area.x = 0; 794 SDL_cursor->area.x = 0;
795 SDL_cursor->area.y = 0; 795 SDL_cursor->area.y = 0;
796 SDL_memset (SDL_cursor->save[0], 0, savelen); 796 SDL_memset(SDL_cursor->save[0], 0, savelen);
797 } 797 }
798 } 798 }
799 799
800 /* vi: set ts=4 sw=4 expandtab: */ 800 /* vi: set ts=4 sw=4 expandtab: */