This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_cocoawindow.m
1141 lines (951 loc) · 32.9 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#if SDL_VIDEO_DRIVER_COCOA
#include "SDL_syswm.h"
#include "SDL_timer.h" /* For SDL_GetTicks() */
#include "../SDL_sysvideo.h"
#include "../../events/SDL_keyboard_c.h"
#include "../../events/SDL_mouse_c.h"
#include "../../events/SDL_touch_c.h"
#include "../../events/SDL_windowevents_c.h"
#include "SDL_cocoavideo.h"
#include "SDL_cocoashape.h"
#include "SDL_cocoamouse.h"
static Uint32 s_moveHack;
static __inline__ void ConvertNSRect(NSRect *r)
{
r->origin.y = CGDisplayPixelsHigh(kCGDirectMainDisplay) - r->origin.y - r->size.height;
}
@implementation Cocoa_WindowListener
- (void)listen:(SDL_WindowData *)data
{
NSNotificationCenter *center;
NSWindow *window = data->nswindow;
NSView *view = [window contentView];
_data = data;
53
54
observingVisible = YES;
wasVisible = [window isVisible];
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
center = [NSNotificationCenter defaultCenter];
if ([window delegate] != nil) {
[center addObserver:self selector:@selector(windowDidExpose:) name:NSWindowDidExposeNotification object:window];
[center addObserver:self selector:@selector(windowDidMove:) name:NSWindowDidMoveNotification object:window];
[center addObserver:self selector:@selector(windowDidResize:) name:NSWindowDidResizeNotification object:window];
[center addObserver:self selector:@selector(windowDidMiniaturize:) name:NSWindowDidMiniaturizeNotification object:window];
[center addObserver:self selector:@selector(windowDidDeminiaturize:) name:NSWindowDidDeminiaturizeNotification object:window];
[center addObserver:self selector:@selector(windowDidBecomeKey:) name:NSWindowDidBecomeKeyNotification object:window];
[center addObserver:self selector:@selector(windowDidResignKey:) name:NSWindowDidResignKeyNotification object:window];
} else {
[window setDelegate:self];
}
70
71
72
73
/* Haven't found a delegate / notification that triggers when the window is
* ordered out (is not visible any more). You can be ordered out without
* minimizing, so DidMiniaturize doesn't work. (e.g. -[NSWindow orderOut:])
*/
74
75
76
77
78
[window addObserver:self
forKeyPath:@"visible"
options:NSKeyValueObservingOptionNew
context:NULL];
79
80
81
82
83
84
85
86
87
88
[window setNextResponder:self];
[window setAcceptsMouseMovedEvents:YES];
[view setNextResponder:self];
if ([view respondsToSelector:@selector(setAcceptsTouchEvents:)]) {
[view setAcceptsTouchEvents:YES];
}
}
89
90
91
92
93
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
94
95
96
97
if (!observingVisible) {
return;
}
98
99
100
101
102
103
104
105
106
107
if (object == _data->nswindow && [keyPath isEqualToString:@"visible"]) {
int newVisibility = [[change objectForKey:@"new"] intValue];
if (newVisibility) {
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
} else {
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
}
}
}
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
-(void) pauseVisibleObservation
{
observingVisible = NO;
wasVisible = [_data->nswindow isVisible];
}
-(void) resumeVisibleObservation
{
BOOL isVisible = [_data->nswindow isVisible];
observingVisible = YES;
if (wasVisible != isVisible) {
if (isVisible) {
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
} else {
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
}
wasVisible = isVisible;
}
}
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
- (void)close
{
NSNotificationCenter *center;
NSWindow *window = _data->nswindow;
NSView *view = [window contentView];
center = [NSNotificationCenter defaultCenter];
if ([window delegate] != self) {
[center removeObserver:self name:NSWindowDidExposeNotification object:window];
[center removeObserver:self name:NSWindowDidMoveNotification object:window];
[center removeObserver:self name:NSWindowDidResizeNotification object:window];
[center removeObserver:self name:NSWindowDidMiniaturizeNotification object:window];
[center removeObserver:self name:NSWindowDidDeminiaturizeNotification object:window];
[center removeObserver:self name:NSWindowDidBecomeKeyNotification object:window];
[center removeObserver:self name:NSWindowDidResignKeyNotification object:window];
} else {
[window setDelegate:nil];
}
149
150
151
[window removeObserver:self
forKeyPath:@"visible"];
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
if ([window nextResponder] == self) {
[window setNextResponder:nil];
}
if ([view nextResponder] == self) {
[view setNextResponder:nil];
}
}
- (BOOL)windowShouldClose:(id)sender
{
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
return NO;
}
- (void)windowDidExpose:(NSNotification *)aNotification
{
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_EXPOSED, 0, 0);
}
- (void)windowDidMove:(NSNotification *)aNotification
{
int x, y;
SDL_VideoDevice *device = SDL_GetVideoDevice();
SDL_Window *window = _data->window;
NSWindow *nswindow = _data->nswindow;
NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];
ConvertNSRect(&rect);
if (s_moveHack) {
SDL_bool blockMove = ((SDL_GetTicks() - s_moveHack) < 500);
s_moveHack = 0;
if (blockMove) {
/* Cocoa is adjusting the window in response to a mode change */
rect.origin.x = window->x;
rect.origin.y = window->y;
ConvertNSRect(&rect);
[nswindow setFrameOrigin:rect.origin];
return;
}
}
x = (int)rect.origin.x;
y = (int)rect.origin.y;
if (window == device->current_glwin) {
[((NSOpenGLContext *) device->current_glctx) update];
}
SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, x, y);
}
- (void)windowDidResize:(NSNotification *)aNotification
{
SDL_VideoDevice *device = SDL_GetVideoDevice();
int x, y, w, h;
NSRect rect = [_data->nswindow contentRectForFrameRect:[_data->nswindow frame]];
ConvertNSRect(&rect);
x = (int)rect.origin.x;
y = (int)rect.origin.y;
w = (int)rect.size.width;
h = (int)rect.size.height;
if (SDL_IsShapedWindow(_data->window))
Cocoa_ResizeWindowShape(_data->window);
if (_data->window == device->current_glwin) {
[((NSOpenGLContext *) device->current_glctx) update];
}
/* The window can move during a resize event, such as when maximizing
or resizing from a corner */
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_MOVED, x, y);
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_RESIZED, w, h);
}
- (void)windowDidMiniaturize:(NSNotification *)aNotification
{
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
}
- (void)windowDidDeminiaturize:(NSNotification *)aNotification
{
SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_RESTORED, 0, 0);
}
- (void)windowDidBecomeKey:(NSNotification *)aNotification
{
SDL_Window *window = _data->window;
241
SDL_Mouse *mouse = SDL_GetMouse();
242
243
244
245
246
/* We're going to get keyboard events, since we're key. */
SDL_SetKeyboardFocus(window);
/* If we just gained focus we need the updated mouse position */
247
if (!mouse->relative_mode) {
248
249
250
251
252
253
254
255
NSPoint point;
int x, y;
point = [_data->nswindow mouseLocationOutsideOfEventStream];
x = (int)point.x;
y = (int)(window->h - point.y);
if (x >= 0 && x < window->w && y >= 0 && y < window->h) {
256
SDL_SendMouseMotion(window, 0, 0, x, y);
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
}
}
/* Check to see if someone updated the clipboard */
Cocoa_CheckClipboardUpdate(_data->videodata);
}
- (void)windowDidResignKey:(NSNotification *)aNotification
{
/* Some other window will get mouse events, since we're not key. */
if (SDL_GetMouseFocus() == _data->window) {
SDL_SetMouseFocus(NULL);
}
/* Some other window will get keyboard events, since we're not key. */
if (SDL_GetKeyboardFocus() == _data->window) {
SDL_SetKeyboardFocus(NULL);
}
}
277
278
279
280
/* We'll respond to key events by doing nothing so we don't beep.
* We could handle key messages here, but we lose some in the NSApp dispatch,
* where they get converted to action messages, etc.
*/
281
282
- (void)flagsChanged:(NSEvent *)theEvent
{
283
/*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/
284
285
286
}
- (void)keyDown:(NSEvent *)theEvent
{
287
/*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/
288
289
290
}
- (void)keyUp:(NSEvent *)theEvent
{
291
/*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/
292
293
}
294
295
296
/* We'll respond to selectors by doing nothing so we don't beep.
* The escape key gets converted to a "cancel" selector, etc.
*/
297
298
- (void)doCommandBySelector:(SEL)aSelector
{
299
/*NSLog(@"doCommandBySelector: %@\n", NSStringFromSelector(aSelector));*/
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
}
- (void)mouseDown:(NSEvent *)theEvent
{
int button;
switch ([theEvent buttonNumber]) {
case 0:
button = SDL_BUTTON_LEFT;
break;
case 1:
button = SDL_BUTTON_RIGHT;
break;
case 2:
button = SDL_BUTTON_MIDDLE;
break;
default:
button = [theEvent buttonNumber] + 1;
break;
}
320
SDL_SendMouseButton(_data->window, 0, SDL_PRESSED, button);
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
}
- (void)rightMouseDown:(NSEvent *)theEvent
{
[self mouseDown:theEvent];
}
- (void)otherMouseDown:(NSEvent *)theEvent
{
[self mouseDown:theEvent];
}
- (void)mouseUp:(NSEvent *)theEvent
{
int button;
switch ([theEvent buttonNumber]) {
case 0:
button = SDL_BUTTON_LEFT;
break;
case 1:
button = SDL_BUTTON_RIGHT;
break;
case 2:
button = SDL_BUTTON_MIDDLE;
break;
default:
button = [theEvent buttonNumber] + 1;
break;
}
351
SDL_SendMouseButton(_data->window, 0, SDL_RELEASED, button);
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
}
- (void)rightMouseUp:(NSEvent *)theEvent
{
[self mouseUp:theEvent];
}
- (void)otherMouseUp:(NSEvent *)theEvent
{
[self mouseUp:theEvent];
}
- (void)mouseMoved:(NSEvent *)theEvent
{
SDL_Mouse *mouse = SDL_GetMouse();
SDL_Window *window = _data->window;
NSPoint point;
int x, y;
if (mouse->relative_mode) {
return;
}
point = [theEvent locationInWindow];
x = (int)point.x;
y = (int)(window->h - point.y);
if (x < 0 || x >= window->w || y < 0 || y >= window->h) {
if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
CGPoint cgpoint;
if (x < 0) {
x = 0;
} else if (x >= window->w) {
x = window->w - 1;
}
if (y < 0) {
y = 0;
} else if (y >= window->h) {
y = window->h - 1;
}
cgpoint.x = window->x + x;
cgpoint.y = window->y + y;
396
397
398
399
/* According to the docs, this was deprecated in 10.6, but it's still
* around. The substitute requires a CGEventSource, but I'm not entirely
* sure how we'd procure the right one for this event.
400
*/
401
CGSetLocalEventsSuppressionInterval(0.0);
402
CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
403
CGSetLocalEventsSuppressionInterval(0.25);
404
405
}
}
406
SDL_SendMouseMotion(window, 0, 0, x, y);
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
466
467
468
469
470
}
- (void)mouseDragged:(NSEvent *)theEvent
{
[self mouseMoved:theEvent];
}
- (void)rightMouseDragged:(NSEvent *)theEvent
{
[self mouseMoved:theEvent];
}
- (void)otherMouseDragged:(NSEvent *)theEvent
{
[self mouseMoved:theEvent];
}
- (void)scrollWheel:(NSEvent *)theEvent
{
Cocoa_HandleMouseWheel(_data->window, theEvent);
}
- (void)touchesBeganWithEvent:(NSEvent *) theEvent
{
[self handleTouches:COCOA_TOUCH_DOWN withEvent:theEvent];
}
- (void)touchesMovedWithEvent:(NSEvent *) theEvent
{
[self handleTouches:COCOA_TOUCH_MOVE withEvent:theEvent];
}
- (void)touchesEndedWithEvent:(NSEvent *) theEvent
{
[self handleTouches:COCOA_TOUCH_UP withEvent:theEvent];
}
- (void)touchesCancelledWithEvent:(NSEvent *) theEvent
{
[self handleTouches:COCOA_TOUCH_CANCELLED withEvent:theEvent];
}
- (void)handleTouches:(cocoaTouchType)type withEvent:(NSEvent *)event
{
NSSet *touches = 0;
NSEnumerator *enumerator;
NSTouch *touch;
switch (type) {
case COCOA_TOUCH_DOWN:
touches = [event touchesMatchingPhase:NSTouchPhaseBegan inView:nil];
break;
case COCOA_TOUCH_UP:
case COCOA_TOUCH_CANCELLED:
touches = [event touchesMatchingPhase:NSTouchPhaseEnded inView:nil];
break;
case COCOA_TOUCH_MOVE:
touches = [event touchesMatchingPhase:NSTouchPhaseMoved inView:nil];
break;
}
enumerator = [touches objectEnumerator];
touch = (NSTouch*)[enumerator nextObject];
while (touch) {
471
const SDL_TouchID touchId = (SDL_TouchID)(intptr_t)[touch device];
472
if (!SDL_GetTouch(touchId)) {
473
if (SDL_AddTouch(touchId, "") < 0) {
474
475
return;
}
476
}
477
478
const SDL_FingerID fingerId = (SDL_FingerID)(intptr_t)[touch identity];
479
480
481
482
483
484
485
float x = [touch normalizedPosition].x;
float y = [touch normalizedPosition].y;
/* Make the origin the upper left instead of the lower left */
y = 1.0f - y;
switch (type) {
case COCOA_TOUCH_DOWN:
486
SDL_SendTouch(touchId, fingerId, SDL_TRUE, x, y, 1.0f);
487
488
489
break;
case COCOA_TOUCH_UP:
case COCOA_TOUCH_CANCELLED:
490
SDL_SendTouch(touchId, fingerId, SDL_FALSE, x, y, 1.0f);
491
492
break;
case COCOA_TOUCH_MOVE:
493
SDL_SendTouchMotion(touchId, fingerId, x, y, 1.0f);
494
495
break;
}
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
touch = (NSTouch*)[enumerator nextObject];
}
}
@end
@interface SDLWindow : NSWindow
/* These are needed for borderless/fullscreen windows */
- (BOOL)canBecomeKeyWindow;
- (BOOL)canBecomeMainWindow;
@end
@implementation SDLWindow
- (BOOL)canBecomeKeyWindow
{
return YES;
}
- (BOOL)canBecomeMainWindow
{
return YES;
}
@end
@interface SDLView : NSView
522
523
524
525
526
527
528
529
530
531
/* The default implementation doesn't pass rightMouseDown to responder chain */
- (void)rightMouseDown:(NSEvent *)theEvent;
@end
@implementation SDLView
- (void)rightMouseDown:(NSEvent *)theEvent
{
[[self nextResponder] rightMouseDown:theEvent];
}
532
533
534
535
536
537
- (void)resetCursorRects
{
[super resetCursorRects];
SDL_Mouse *mouse = SDL_GetMouse();
538
if (mouse->cursor_shown && mouse->cur_cursor && !mouse->relative_mode) {
539
540
541
542
543
544
545
[self addCursorRect:[self bounds]
cursor:mouse->cur_cursor->driverdata];
} else {
[self addCursorRect:[self bounds]
cursor:[NSCursor invisibleCursor]];
}
}
546
547
548
549
550
551
552
@end
static unsigned int
GetWindowStyle(SDL_Window * window)
{
unsigned int style;
553
if (window->flags & SDL_WINDOW_FULLSCREEN) {
554
style = NSBorderlessWindowMask;
555
556
557
558
559
560
561
562
563
564
} else {
if (window->flags & SDL_WINDOW_BORDERLESS) {
style = NSBorderlessWindowMask;
} else {
style = (NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask);
}
if (window->flags & SDL_WINDOW_RESIZABLE) {
style |= NSResizableWindowMask;
}
}
565
566
567
568
569
570
return style;
}
static int
SetupWindowData(_THIS, SDL_Window * window, NSWindow *nswindow, SDL_bool created)
{
571
NSAutoreleasePool *pool;
572
573
574
575
576
577
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data;
/* Allocate the window data */
data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));
if (!data) {
578
return SDL_OutOfMemory();
579
580
581
582
583
584
}
data->window = window;
data->nswindow = nswindow;
data->created = created;
data->videodata = videodata;
585
pool = [[NSAutoreleasePool alloc] init];
586
587
588
/* Create an event listener for the window */
data->listener = [[Cocoa_WindowListener alloc] init];
589
590
591
592
593
594
595
596
597
598
/* Fill in the SDL window with the window data */
{
NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];
ConvertNSRect(&rect);
window->x = (int)rect.origin.x;
window->y = (int)rect.origin.y;
window->w = (int)rect.size.width;
window->h = (int)rect.size.height;
}
599
600
601
/* Set up the listener after we create the view */
[data->listener listen:data];
602
603
604
605
606
607
if ([nswindow isVisible]) {
window->flags |= SDL_WINDOW_SHOWN;
} else {
window->flags &= ~SDL_WINDOW_SHOWN;
}
608
609
610
611
612
613
{
unsigned int style = [nswindow styleMask];
if (style == NSBorderlessWindowMask) {
window->flags |= SDL_WINDOW_BORDERLESS;
614
} else {
615
window->flags &= ~SDL_WINDOW_BORDERLESS;
616
}
617
618
if (style & NSResizableWindowMask) {
window->flags |= SDL_WINDOW_RESIZABLE;
619
} else {
620
window->flags &= ~SDL_WINDOW_RESIZABLE;
621
622
}
}
623
624
625
626
627
628
629
/* isZoomed always returns true if the window is not resizable */
if ((window->flags & SDL_WINDOW_RESIZABLE) && [nswindow isZoomed]) {
window->flags |= SDL_WINDOW_MAXIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MAXIMIZED;
}
630
631
632
633
634
635
if ([nswindow isMiniaturized]) {
window->flags |= SDL_WINDOW_MINIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MINIMIZED;
}
636
637
638
639
640
641
if ([nswindow isKeyWindow]) {
window->flags |= SDL_WINDOW_INPUT_FOCUS;
SDL_SetKeyboardFocus(data->window);
}
642
643
644
645
646
/* Prevents the window's "window device" from being destroyed when it is
* hidden. See http://www.mikeash.com/pyblog/nsopenglcontext-and-one-shot.html
*/
[nswindow setOneShot:NO];
647
648
649
650
/* All done! */
[pool release];
window->driverdata = data;
return 0;
651
652
653
654
655
}
int
Cocoa_CreateWindow(_THIS, SDL_Window * window)
{
656
657
658
659
660
661
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow;
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
NSRect rect;
SDL_Rect bounds;
unsigned int style;
662
663
664
665
666
667
668
Cocoa_GetDisplayBounds(_this, display, &bounds);
rect.origin.x = window->x;
rect.origin.y = window->y;
rect.size.width = window->w;
rect.size.height = window->h;
ConvertNSRect(&rect);
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
style = GetWindowStyle(window);
/* Figure out which screen to place this window */
NSArray *screens = [NSScreen screens];
NSScreen *screen = nil;
NSScreen *candidate;
int i, count = [screens count];
for (i = 0; i < count; ++i) {
candidate = [screens objectAtIndex:i];
NSRect screenRect = [candidate frame];
if (rect.origin.x >= screenRect.origin.x &&
rect.origin.x < screenRect.origin.x + screenRect.size.width &&
rect.origin.y >= screenRect.origin.y &&
rect.origin.y < screenRect.origin.y + screenRect.size.height) {
screen = candidate;
rect.origin.x -= screenRect.origin.x;
rect.origin.y -= screenRect.origin.y;
687
}
688
}
689
nswindow = [[SDLWindow alloc] initWithContentRect:rect styleMask:style backing:NSBackingStoreBuffered defer:NO screen:screen];
690
[nswindow setBackgroundColor:[NSColor blackColor]];
691
692
/* Create a default view for this window */
693
694
695
696
rect = [nswindow contentRectForFrameRect:[nswindow frame]];
NSView *contentView = [[SDLView alloc] initWithFrame:rect];
[nswindow setContentView: contentView];
[contentView release];
697
698
699
700
701
702
[pool release];
if (SetupWindowData(_this, window, nswindow, SDL_TRUE) < 0) {
[nswindow release];
return -1;
703
}
704
return 0;
705
706
707
708
709
}
int
Cocoa_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
710
NSAutoreleasePool *pool;
711
712
713
NSWindow *nswindow = (NSWindow *) data;
NSString *title;
714
715
716
717
718
719
pool = [[NSAutoreleasePool alloc] init];
/* Query the title from the existing window */
title = [nswindow title];
if (title) {
window->title = SDL_strdup([title UTF8String]);
720
721
}
722
723
[pool release];
724
725
726
727
728
729
return SetupWindowData(_this, window, nswindow, SDL_FALSE);
}
void
Cocoa_SetWindowTitle(_THIS, SDL_Window * window)
{
730
731
732
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
NSString *string;
733
734
735
736
737
if(window->title) {
string = [[NSString alloc] initWithUTF8String:window->title];
} else {
string = [[NSString alloc] init];
738
}
739
740
741
742
[nswindow setTitle:string];
[string release];
[pool release];
743
744
745
746
747
}
void
Cocoa_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
748
749
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSImage *nsimage = Cocoa_CreateImage(icon);
750
751
752
if (nsimage) {
[NSApp setApplicationIconImage:nsimage];
753
}
754
755
[pool release];
756
757
758
759
760
}
void
Cocoa_SetWindowPosition(_THIS, SDL_Window * window)
{
761
762
763
764
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
NSRect rect;
Uint32 moveHack;
765
766
767
768
769
770
rect.origin.x = window->x;
rect.origin.y = window->y;
rect.size.width = window->w;
rect.size.height = window->h;
ConvertNSRect(&rect);
771
772
773
774
775
776
777
778
moveHack = s_moveHack;
s_moveHack = 0;
[nswindow setFrameOrigin:rect.origin];
s_moveHack = moveHack;
if (window == _this->current_glwin) {
[((NSOpenGLContext *) _this->current_glctx) update];
779
}
780
781
[pool release];
782
783
784
785
786
}
void
Cocoa_SetWindowSize(_THIS, SDL_Window * window)
{
787
788
789
790
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
NSWindow *nswindow = windata->nswindow;
NSSize size;
791
792
793
794
size.width = window->w;
size.height = window->h;
[nswindow setContentSize:size];
795
796
797
if (window == _this->current_glwin) {
[((NSOpenGLContext *) _this->current_glctx) update];
798
}
799
800
[pool release];
801
802
}
803
804
805
void
Cocoa_SetWindowMinimumSize(_THIS, SDL_Window * window)
{
806
807
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
808
809
810
811
NSSize minSize;
minSize.width = window->min_w;
minSize.height = window->min_h;
812
813
[windata->nswindow setContentMinSize:minSize];
814
815
[pool release];
816
817
818
819
820
}
void
Cocoa_SetWindowMaximumSize(_THIS, SDL_Window * window)
{
821
822
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
SDL_WindowData *windata = (SDL_WindowData *) window->driverdata;
823
824
825
826
NSSize maxSize;
maxSize.width = window->max_w;
maxSize.height = window->max_h;
827
828
[windata->nswindow setContentMaxSize:maxSize];
829
830
[pool release];
831
832
}
833
834
835
void
Cocoa_ShowWindow(_THIS, SDL_Window * window)
{
836
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
837
838
SDL_WindowData *windowData = ((SDL_WindowData *) window->driverdata);
NSWindow *nswindow = windowData->nswindow;
839
840
if (![nswindow isMiniaturized]) {
841
[windowData->listener pauseVisibleObservation];
842
[nswindow makeKeyAndOrderFront:nil];
843
[windowData->listener resumeVisibleObservation];
844
}
845
[pool release];
846
847
848
849
850
}
void
Cocoa_HideWindow(_THIS, SDL_Window * window)
{
851
852
853
854
855
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
[nswindow orderOut:nil];
[pool release];
856
857
858
859
860
}
void
Cocoa_RaiseWindow(_THIS, SDL_Window * window)
{
861
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
862
863
SDL_WindowData *windowData = ((SDL_WindowData *) window->driverdata);
NSWindow *nswindow = windowData->nswindow;
864
865
866
// makeKeyAndOrderFront: has the side-effect of deminiaturizing and showing
// a minimized or hidden window, so check for that before showing it.
867
[windowData->listener pauseVisibleObservation];
868
869
870
if (![nswindow isMiniaturized] && [nswindow isVisible]) {
[nswindow makeKeyAndOrderFront:nil];
}
871
872
[windowData->listener resumeVisibleObservation];
873
[pool release];
874
875
876
877
878
}
void
Cocoa_MaximizeWindow(_THIS, SDL_Window * window)
{
879
880
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
881
882
883
884
885
[nswindow zoom:nil];
if (window == _this->current_glwin) {
[((NSOpenGLContext *) _this->current_glctx) update];
886
}
887
888
[pool release];
889
890
891
892
893
}
void
Cocoa_MinimizeWindow(_THIS, SDL_Window * window)
{
894
895
896
897
898
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
[nswindow miniaturize:nil];
[pool release];
899
900
901
902
903
}
void
Cocoa_RestoreWindow(_THIS, SDL_Window * window)
{
904
905
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
906
907
908
909
910
if ([nswindow isMiniaturized]) {
[nswindow deminiaturize:nil];
} else if ((window->flags & SDL_WINDOW_RESIZABLE) && [nswindow isZoomed]) {
[nswindow zoom:nil];
911
}
912
[pool release];
913
914
915
916
917
918
919
920
921
922
923
}
static NSWindow *
Cocoa_RebuildWindow(SDL_WindowData * data, NSWindow * nswindow, unsigned style)
{
if (!data->created) {
/* Don't mess with other people's windows... */
return nswindow;
}
[data->listener close];
924
data->nswindow = [[SDLWindow alloc] initWithContentRect:[[nswindow contentView] frame] styleMask:style backing:NSBackingStoreBuffered defer:NO screen:[nswindow screen]];
925
[data->nswindow setContentView:[nswindow contentView]];
926
927
/* See comment in SetupWindowData. */
[data->nswindow setOneShot:NO];
928
929
930
931
932
933
934
935
936
937
[data->listener listen:data];
[nswindow close];
return data->nswindow;
}
void
Cocoa_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
{
938
939
940
941
942
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSWindow *nswindow = ((SDL_WindowData *) window->driverdata)->nswindow;
if ([nswindow respondsToSelector:@selector(setStyleMask:)]) {
[nswindow setStyleMask:GetWindowStyle(window)];
if (bordered) {
943
Cocoa_SetWindowTitle(_this, window); /* this got blanked out. */
944
945
}
}
946
[pool release];
947
948
949
950
951
}
void
Cocoa_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)
{
952
953
954
955
956
957
958
959
960
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
NSWindow *nswindow = data->nswindow;
NSRect rect;
/* The view responder chain gets messed with during setStyleMask */
if ([[nswindow contentView] nextResponder] == data->listener) {
[[nswindow contentView] setNextResponder:nil];
}
961
962
963
if (fullscreen) {
SDL_Rect bounds;
964
965
966
967
968
969
970
Cocoa_GetDisplayBounds(_this, display, &bounds);
rect.origin.x = bounds.x;
rect.origin.y = bounds.y;
rect.size.width = bounds.w;
rect.size.height = bounds.h;
ConvertNSRect(&rect);
971
972
973
974
975
976
/* Hack to fix origin on Mac OS X 10.4 */
NSRect screenRect = [[nswindow screen] frame];
if (screenRect.size.height >= 1.0f) {
rect.origin.y += (screenRect.size.height - rect.size.height);
}
977
978
979
if ([nswindow respondsToSelector: @selector(setStyleMask:)]) {
[nswindow performSelector: @selector(setStyleMask:) withObject: (id)NSBorderlessWindowMask];
980
} else {
981
nswindow = Cocoa_RebuildWindow(data, nswindow, NSBorderlessWindowMask);
982
}
983
984
985
986
987
988
} else {
rect.origin.x = window->windowed.x;
rect.origin.y = window->windowed.y;
rect.size.width = window->windowed.w;
rect.size.height = window->windowed.h;
ConvertNSRect(&rect);
989
990
991
992
993
if ([nswindow respondsToSelector: @selector(setStyleMask:)]) {
[nswindow performSelector: @selector(setStyleMask:) withObject: (id)(uintptr_t)GetWindowStyle(window)];
} else {
nswindow = Cocoa_RebuildWindow(data, nswindow, GetWindowStyle(window));
994
}
995
}
996
997
998
999
1000
/* The view responder chain gets messed with during setStyleMask */
if ([[nswindow contentView] nextResponder] != data->listener) {
[[nswindow contentView] setNextResponder:data->listener];
}