diff options
author | Franklin Wei <git@fwei.tk> | 2018-02-07 20:04:46 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2018-03-12 20:52:01 -0400 |
commit | 6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch) | |
tree | 9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m | |
parent | ef373c03b96b0be08babca581d9f10bccfd4931f (diff) | |
download | rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip |
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes
up space.
Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m')
-rw-r--r-- | apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m | 444 |
1 files changed, 0 insertions, 444 deletions
diff --git a/apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m b/apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m deleted file mode 100644 index d526424d4c..0000000000 --- a/apps/plugins/sdl/src/video/quartz/SDL_QuartzWM.m +++ /dev/null | |||
@@ -1,444 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Library General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2 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 | Library General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Library General Public | ||
16 | License along with this library; if not, write to the Free | ||
17 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_QuartzVideo.h" | ||
25 | #include "SDL_QuartzWM.h" | ||
26 | |||
27 | |||
28 | void QZ_FreeWMCursor (_THIS, WMcursor *cursor) { | ||
29 | |||
30 | if ( cursor != NULL ) { | ||
31 | [ cursor->nscursor release ]; | ||
32 | free (cursor); | ||
33 | } | ||
34 | } | ||
35 | |||
36 | WMcursor* QZ_CreateWMCursor (_THIS, Uint8 *data, Uint8 *mask, | ||
37 | int w, int h, int hot_x, int hot_y) { | ||
38 | WMcursor *cursor; | ||
39 | NSBitmapImageRep *imgrep; | ||
40 | NSImage *img; | ||
41 | unsigned char *planes[5]; | ||
42 | int i; | ||
43 | NSAutoreleasePool *pool; | ||
44 | |||
45 | pool = [ [ NSAutoreleasePool alloc ] init ]; | ||
46 | |||
47 | /* Allocate the cursor memory */ | ||
48 | cursor = (WMcursor *)SDL_malloc(sizeof(WMcursor)); | ||
49 | if (cursor == NULL) goto outOfMemory; | ||
50 | |||
51 | /* create the image representation and get the pointers to its storage */ | ||
52 | imgrep = [ [ [ NSBitmapImageRep alloc ] initWithBitmapDataPlanes: NULL pixelsWide: w pixelsHigh: h bitsPerSample: 1 samplesPerPixel: 2 hasAlpha: YES isPlanar: YES colorSpaceName: NSDeviceWhiteColorSpace bytesPerRow: (w+7)/8 bitsPerPixel: 0 ] autorelease ]; | ||
53 | if (imgrep == nil) goto outOfMemory; | ||
54 | [ imgrep getBitmapDataPlanes: planes ]; | ||
55 | |||
56 | /* copy data and mask, extending the mask to all black pixels because the inversion effect doesn't work with Cocoa's alpha-blended cursors */ | ||
57 | for (i = 0; i < (w+7)/8*h; i++) { | ||
58 | planes[0][i] = data[i] ^ 0xFF; | ||
59 | planes[1][i] = mask[i] | data[i]; | ||
60 | } | ||
61 | |||
62 | /* create image and cursor */ | ||
63 | img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(w, h) ] autorelease ]; | ||
64 | if (img == nil) goto outOfMemory; | ||
65 | [ img addRepresentation: imgrep ]; | ||
66 | if (system_version < 0x1030) { /* on 10.2, cursors must be 16*16 */ | ||
67 | if (w > 16 || h > 16) { /* too big: scale it down */ | ||
68 | [ img setScalesWhenResized: YES ]; | ||
69 | hot_x = hot_x*16/w; | ||
70 | hot_y = hot_y*16/h; | ||
71 | } | ||
72 | else { /* too small (or just right): extend it (from the bottom left corner, so hot_y must be adjusted) */ | ||
73 | hot_y += 16 - h; | ||
74 | } | ||
75 | [ img setSize: NSMakeSize(16, 16) ]; | ||
76 | } | ||
77 | cursor->nscursor = [ [ NSCursor alloc ] initWithImage: img hotSpot: NSMakePoint(hot_x, hot_y) ]; | ||
78 | if (cursor->nscursor == nil) goto outOfMemory; | ||
79 | |||
80 | [ pool release ]; | ||
81 | return(cursor); | ||
82 | |||
83 | outOfMemory: | ||
84 | [ pool release ]; | ||
85 | if (cursor != NULL) SDL_free(cursor); | ||
86 | SDL_OutOfMemory(); | ||
87 | return(NULL); | ||
88 | } | ||
89 | |||
90 | void QZ_UpdateCursor (_THIS) { | ||
91 | BOOL state; | ||
92 | |||
93 | if (cursor_should_be_visible || !(SDL_GetAppState() & SDL_APPMOUSEFOCUS)) { | ||
94 | state = YES; | ||
95 | } else { | ||
96 | state = NO; | ||
97 | } | ||
98 | if (state != cursor_visible) { | ||
99 | if (state) { | ||
100 | [ NSCursor unhide ]; | ||
101 | } else { | ||
102 | [ NSCursor hide ]; | ||
103 | } | ||
104 | cursor_visible = state; | ||
105 | } | ||
106 | } | ||
107 | |||
108 | BOOL QZ_IsMouseInWindow (_THIS) { | ||
109 | if (qz_window == nil || (mode_flags & SDL_FULLSCREEN)) return YES; /*fullscreen*/ | ||
110 | else { | ||
111 | NSPoint p = [ qz_window mouseLocationOutsideOfEventStream ]; | ||
112 | p.y -= 1.0f; /* Apparently y goes from 1 to h, not from 0 to h-1 (i.e. the "location of the mouse" seems to be defined as "the location of the top left corner of the mouse pointer's hot pixel" */ | ||
113 | return NSPointInRect(p, [ window_view frame ]); | ||
114 | } | ||
115 | } | ||
116 | |||
117 | int QZ_ShowWMCursor (_THIS, WMcursor *cursor) { | ||
118 | |||
119 | if ( cursor == NULL) { | ||
120 | if ( cursor_should_be_visible ) { | ||
121 | cursor_should_be_visible = NO; | ||
122 | QZ_ChangeGrabState (this, QZ_HIDECURSOR); | ||
123 | } | ||
124 | QZ_UpdateCursor(this); | ||
125 | } | ||
126 | else { | ||
127 | if ( qz_window != nil && !(mode_flags & SDL_FULLSCREEN) ) { | ||
128 | [ qz_window invalidateCursorRectsForView: [ qz_window contentView ] ]; | ||
129 | } | ||
130 | if ( ! cursor_should_be_visible ) { | ||
131 | cursor_should_be_visible = YES; | ||
132 | QZ_ChangeGrabState (this, QZ_SHOWCURSOR); | ||
133 | } | ||
134 | [ cursor->nscursor performSelectorOnMainThread:@selector(set) withObject:nil waitUntilDone:NO ]; | ||
135 | QZ_UpdateCursor(this); | ||
136 | } | ||
137 | |||
138 | return 1; | ||
139 | } | ||
140 | |||
141 | /* | ||
142 | Coordinate conversion functions, for convenience | ||
143 | Cocoa sets the origin at the lower left corner of the window/screen | ||
144 | SDL, CoreGraphics/WindowServer, and QuickDraw use the origin at the upper left corner | ||
145 | The routines were written so they could be called before SetVideoMode() has finished; | ||
146 | this might have limited usefulness at the moment, but the extra cost is trivial. | ||
147 | */ | ||
148 | |||
149 | /* Convert Cocoa screen coordinate to Cocoa window coordinate */ | ||
150 | void QZ_PrivateGlobalToLocal (_THIS, NSPoint *p) { | ||
151 | |||
152 | if ( ! CGDisplayIsCaptured (display_id) ) | ||
153 | *p = [ qz_window convertScreenToBase:*p ]; | ||
154 | } | ||
155 | |||
156 | |||
157 | /* Convert Cocoa window coordinate to Cocoa screen coordinate */ | ||
158 | void QZ_PrivateLocalToGlobal (_THIS, NSPoint *p) { | ||
159 | |||
160 | if ( ! CGDisplayIsCaptured (display_id) ) | ||
161 | *p = [ qz_window convertBaseToScreen:*p ]; | ||
162 | } | ||
163 | |||
164 | /* Convert SDL coordinate to Cocoa coordinate */ | ||
165 | void QZ_PrivateSDLToCocoa (_THIS, NSPoint *p) { | ||
166 | |||
167 | if ( CGDisplayIsCaptured (display_id) ) { /* capture signals fullscreen */ | ||
168 | |||
169 | p->y = CGDisplayPixelsHigh (display_id) - p->y; | ||
170 | } | ||
171 | else { | ||
172 | |||
173 | *p = [ window_view convertPoint:*p toView: nil ]; | ||
174 | p->y = [window_view frame].size.height - p->y; | ||
175 | } | ||
176 | } | ||
177 | |||
178 | /* Convert Cocoa coordinate to SDL coordinate */ | ||
179 | void QZ_PrivateCocoaToSDL (_THIS, NSPoint *p) { | ||
180 | |||
181 | if ( CGDisplayIsCaptured (display_id) ) { /* capture signals fullscreen */ | ||
182 | |||
183 | p->y = CGDisplayPixelsHigh (display_id) - p->y; | ||
184 | } | ||
185 | else { | ||
186 | |||
187 | *p = [ window_view convertPoint:*p fromView: nil ]; | ||
188 | p->y = [window_view frame].size.height - p->y; | ||
189 | } | ||
190 | } | ||
191 | |||
192 | /* Convert SDL coordinate to window server (CoreGraphics) coordinate */ | ||
193 | CGPoint QZ_PrivateSDLToCG (_THIS, NSPoint *p) { | ||
194 | |||
195 | CGPoint cgp; | ||
196 | |||
197 | if ( ! CGDisplayIsCaptured (display_id) ) { /* not captured => not fullscreen => local coord */ | ||
198 | |||
199 | int height; | ||
200 | |||
201 | QZ_PrivateSDLToCocoa (this, p); | ||
202 | QZ_PrivateLocalToGlobal (this, p); | ||
203 | |||
204 | height = CGDisplayPixelsHigh (display_id); | ||
205 | p->y = height - p->y; | ||
206 | } | ||
207 | |||
208 | cgp.x = p->x; | ||
209 | cgp.y = p->y; | ||
210 | |||
211 | return cgp; | ||
212 | } | ||
213 | |||
214 | #if 0 /* Dead code */ | ||
215 | /* Convert window server (CoreGraphics) coordinate to SDL coordinate */ | ||
216 | void QZ_PrivateCGToSDL (_THIS, NSPoint *p) { | ||
217 | |||
218 | if ( ! CGDisplayIsCaptured (display_id) ) { /* not captured => not fullscreen => local coord */ | ||
219 | |||
220 | int height; | ||
221 | |||
222 | /* Convert CG Global to Cocoa Global */ | ||
223 | height = CGDisplayPixelsHigh (display_id); | ||
224 | p->y = height - p->y; | ||
225 | |||
226 | QZ_PrivateGlobalToLocal (this, p); | ||
227 | QZ_PrivateCocoaToSDL (this, p); | ||
228 | } | ||
229 | } | ||
230 | #endif /* Dead code */ | ||
231 | |||
232 | void QZ_PrivateWarpCursor (_THIS, int x, int y) { | ||
233 | NSPoint p; | ||
234 | CGPoint cgp; | ||
235 | |||
236 | p = NSMakePoint (x, y); | ||
237 | cgp = QZ_PrivateSDLToCG (this, &p); | ||
238 | |||
239 | /* this is the magic call that fixes cursor "freezing" after warp */ | ||
240 | CGAssociateMouseAndMouseCursorPosition (0); | ||
241 | CGWarpMouseCursorPosition (cgp); | ||
242 | if (grab_state != QZ_INVISIBLE_GRAB) { /* can't leave it disassociated? */ | ||
243 | CGAssociateMouseAndMouseCursorPosition (1); | ||
244 | } | ||
245 | SDL_PrivateAppActive (QZ_IsMouseInWindow (this), SDL_APPMOUSEFOCUS); | ||
246 | } | ||
247 | |||
248 | void QZ_WarpWMCursor (_THIS, Uint16 x, Uint16 y) { | ||
249 | |||
250 | /* Only allow warping when in foreground */ | ||
251 | if ( ! [ NSApp isActive ] ) | ||
252 | return; | ||
253 | |||
254 | /* Do the actual warp */ | ||
255 | if (grab_state != QZ_INVISIBLE_GRAB) QZ_PrivateWarpCursor (this, x, y); | ||
256 | |||
257 | /* Generate the mouse moved event */ | ||
258 | SDL_PrivateMouseMotion (0, 0, x, y); | ||
259 | } | ||
260 | |||
261 | void QZ_MoveWMCursor (_THIS, int x, int y) { } | ||
262 | void QZ_CheckMouseMode (_THIS) { } | ||
263 | |||
264 | void QZ_SetCaption (_THIS, const char *title, const char *icon) { | ||
265 | |||
266 | if ( qz_window != nil ) { | ||
267 | NSString *string; | ||
268 | if ( title != NULL ) { | ||
269 | string = [ [ NSString alloc ] initWithUTF8String:title ]; | ||
270 | [ qz_window setTitle:string ]; | ||
271 | [ string release ]; | ||
272 | } | ||
273 | if ( icon != NULL ) { | ||
274 | string = [ [ NSString alloc ] initWithUTF8String:icon ]; | ||
275 | [ qz_window setMiniwindowTitle:string ]; | ||
276 | [ string release ]; | ||
277 | } | ||
278 | } | ||
279 | } | ||
280 | |||
281 | void QZ_SetIcon (_THIS, SDL_Surface *icon, Uint8 *mask) | ||
282 | { | ||
283 | NSBitmapImageRep *imgrep; | ||
284 | NSImage *img; | ||
285 | SDL_Surface *mergedSurface; | ||
286 | NSAutoreleasePool *pool; | ||
287 | Uint8 *pixels; | ||
288 | SDL_bool iconSrcAlpha; | ||
289 | Uint8 iconAlphaValue; | ||
290 | int i, j, maskPitch, index; | ||
291 | |||
292 | pool = [ [ NSAutoreleasePool alloc ] init ]; | ||
293 | |||
294 | imgrep = [ [ [ NSBitmapImageRep alloc ] initWithBitmapDataPlanes: NULL pixelsWide: icon->w pixelsHigh: icon->h bitsPerSample: 8 samplesPerPixel: 4 hasAlpha: YES isPlanar: NO colorSpaceName: NSDeviceRGBColorSpace bytesPerRow: 4*icon->w bitsPerPixel: 32 ] autorelease ]; | ||
295 | if (imgrep == nil) goto freePool; | ||
296 | pixels = [ imgrep bitmapData ]; | ||
297 | SDL_memset(pixels, 0, 4*icon->w*icon->h); /* make the background, which will survive in colorkeyed areas, completely transparent */ | ||
298 | |||
299 | #if SDL_BYTEORDER == SDL_BIG_ENDIAN | ||
300 | #define BYTEORDER_DEPENDENT_RGBA_MASKS 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF | ||
301 | #else | ||
302 | #define BYTEORDER_DEPENDENT_RGBA_MASKS 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 | ||
303 | #endif | ||
304 | mergedSurface = SDL_CreateRGBSurfaceFrom(pixels, icon->w, icon->h, 32, 4*icon->w, BYTEORDER_DEPENDENT_RGBA_MASKS); | ||
305 | if (mergedSurface == NULL) goto freePool; | ||
306 | |||
307 | /* blit, with temporarily cleared SRCALPHA flag because we want to copy, not alpha-blend */ | ||
308 | iconSrcAlpha = ((icon->flags & SDL_SRCALPHA) != 0); | ||
309 | iconAlphaValue = icon->format->alpha; | ||
310 | SDL_SetAlpha(icon, 0, 255); | ||
311 | SDL_BlitSurface(icon, NULL, mergedSurface, NULL); | ||
312 | if (iconSrcAlpha) SDL_SetAlpha(icon, SDL_SRCALPHA, iconAlphaValue); | ||
313 | |||
314 | SDL_FreeSurface(mergedSurface); | ||
315 | |||
316 | /* apply mask, source alpha, and premultiply color values by alpha */ | ||
317 | maskPitch = (icon->w+7)/8; | ||
318 | for (i = 0; i < icon->h; i++) { | ||
319 | for (j = 0; j < icon->w; j++) { | ||
320 | index = i*4*icon->w + j*4; | ||
321 | if (!(mask[i*maskPitch + j/8] & (128 >> j%8))) { | ||
322 | pixels[index + 3] = 0; | ||
323 | } | ||
324 | else { | ||
325 | if (iconSrcAlpha) { | ||
326 | if (icon->format->Amask == 0) pixels[index + 3] = icon->format->alpha; | ||
327 | } | ||
328 | else { | ||
329 | pixels[index + 3] = 255; | ||
330 | } | ||
331 | } | ||
332 | if (pixels[index + 3] < 255) { | ||
333 | pixels[index + 0] = (Uint16)pixels[index + 0]*pixels[index + 3]/255; | ||
334 | pixels[index + 1] = (Uint16)pixels[index + 1]*pixels[index + 3]/255; | ||
335 | pixels[index + 2] = (Uint16)pixels[index + 2]*pixels[index + 3]/255; | ||
336 | } | ||
337 | } | ||
338 | } | ||
339 | |||
340 | img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(icon->w, icon->h) ] autorelease ]; | ||
341 | if (img == nil) goto freePool; | ||
342 | [ img addRepresentation: imgrep ]; | ||
343 | [ NSApp setApplicationIconImage:img ]; | ||
344 | |||
345 | freePool: | ||
346 | [ pool release ]; | ||
347 | } | ||
348 | |||
349 | int QZ_IconifyWindow (_THIS) { | ||
350 | |||
351 | if ( ! [ qz_window isMiniaturized ] ) { | ||
352 | [ qz_window miniaturize:nil ]; | ||
353 | if ( ! [ qz_window isMiniaturized ] ) { | ||
354 | SDL_SetError ("window iconification failed"); | ||
355 | return 0; | ||
356 | } | ||
357 | return 1; | ||
358 | } | ||
359 | else { | ||
360 | SDL_SetError ("window already iconified"); | ||
361 | return 0; | ||
362 | } | ||
363 | } | ||
364 | |||
365 | /* | ||
366 | int QZ_GetWMInfo (_THIS, SDL_SysWMinfo *info) { | ||
367 | info->nsWindowPtr = qz_window; | ||
368 | return 0; | ||
369 | }*/ | ||
370 | |||
371 | void QZ_ChangeGrabState (_THIS, int action) { | ||
372 | |||
373 | /* | ||
374 | Figure out what the next state should be based on the action. | ||
375 | Ignore actions that can't change the current state. | ||
376 | */ | ||
377 | if ( grab_state == QZ_UNGRABBED ) { | ||
378 | if ( action == QZ_ENABLE_GRAB ) { | ||
379 | if ( cursor_should_be_visible ) | ||
380 | grab_state = QZ_VISIBLE_GRAB; | ||
381 | else | ||
382 | grab_state = QZ_INVISIBLE_GRAB; | ||
383 | } | ||
384 | } | ||
385 | else if ( grab_state == QZ_VISIBLE_GRAB ) { | ||
386 | if ( action == QZ_DISABLE_GRAB ) | ||
387 | grab_state = QZ_UNGRABBED; | ||
388 | else if ( action == QZ_HIDECURSOR ) | ||
389 | grab_state = QZ_INVISIBLE_GRAB; | ||
390 | } | ||
391 | else { | ||
392 | assert( grab_state == QZ_INVISIBLE_GRAB ); | ||
393 | |||
394 | if ( action == QZ_DISABLE_GRAB ) | ||
395 | grab_state = QZ_UNGRABBED; | ||
396 | else if ( action == QZ_SHOWCURSOR ) | ||
397 | grab_state = QZ_VISIBLE_GRAB; | ||
398 | } | ||
399 | |||
400 | /* now apply the new state */ | ||
401 | if (grab_state == QZ_UNGRABBED) { | ||
402 | |||
403 | CGAssociateMouseAndMouseCursorPosition (1); | ||
404 | } | ||
405 | else if (grab_state == QZ_VISIBLE_GRAB) { | ||
406 | |||
407 | CGAssociateMouseAndMouseCursorPosition (1); | ||
408 | } | ||
409 | else { | ||
410 | assert( grab_state == QZ_INVISIBLE_GRAB ); | ||
411 | |||
412 | QZ_PrivateWarpCursor (this, SDL_VideoSurface->w / 2, SDL_VideoSurface->h / 2); | ||
413 | CGAssociateMouseAndMouseCursorPosition (0); | ||
414 | } | ||
415 | } | ||
416 | |||
417 | SDL_GrabMode QZ_GrabInput (_THIS, SDL_GrabMode grab_mode) { | ||
418 | |||
419 | int doGrab = grab_mode & SDL_GRAB_ON; | ||
420 | /*int fullscreen = grab_mode & SDL_GRAB_FULLSCREEN;*/ | ||
421 | |||
422 | if ( this->screen == NULL ) { | ||
423 | SDL_SetError ("QZ_GrabInput: screen is NULL"); | ||
424 | return SDL_GRAB_OFF; | ||
425 | } | ||
426 | |||
427 | if ( ! video_set ) { | ||
428 | /*SDL_SetError ("QZ_GrabInput: video is not set, grab will take effect on mode switch"); */ | ||
429 | current_grab_mode = grab_mode; | ||
430 | return grab_mode; /* Will be set later on mode switch */ | ||
431 | } | ||
432 | |||
433 | if ( grab_mode != SDL_GRAB_QUERY ) { | ||
434 | if ( doGrab ) | ||
435 | QZ_ChangeGrabState (this, QZ_ENABLE_GRAB); | ||
436 | else | ||
437 | QZ_ChangeGrabState (this, QZ_DISABLE_GRAB); | ||
438 | |||
439 | current_grab_mode = doGrab ? SDL_GRAB_ON : SDL_GRAB_OFF; | ||
440 | QZ_UpdateCursor(this); | ||
441 | } | ||
442 | |||
443 | return current_grab_mode; | ||
444 | } | ||