[sdl_omap.git] / src / video / quartz / SDL_QuartzWM.m

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009  Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#include "SDL_QuartzVideo.h"
#include "SDL_QuartzWM.h"


void QZ_FreeWMCursor     (_THIS, WMcursor *cursor) { 

    if ( cursor != NULL ) {
        [ cursor->nscursor release ];
        free (cursor);
    }
}

WMcursor*    QZ_CreateWMCursor   (_THIS, Uint8 *data, Uint8 *mask, 
                                         int w, int h, int hot_x, int hot_y) { 
    WMcursor *cursor;
    NSBitmapImageRep *imgrep;
    NSImage *img;
    unsigned char *planes[5];
    int i;
    NSAutoreleasePool *pool;
    
    pool = [ [ NSAutoreleasePool alloc ] init ];
    
    /* Allocate the cursor memory */
    cursor = (WMcursor *)SDL_malloc(sizeof(WMcursor));
    if (cursor == NULL) goto outOfMemory;
    
    /* create the image representation and get the pointers to its storage */
    imgrep = [ [ [ NSBitmapImageRep alloc ] initWithBitmapDataPlanes: NULL pixelsWide: w pixelsHigh: h bitsPerSample: 1 samplesPerPixel: 2 hasAlpha: YES isPlanar: YES colorSpaceName: NSDeviceBlackColorSpace bytesPerRow: (w+7)/8 bitsPerPixel: 0 ] autorelease ];
    if (imgrep == nil) goto outOfMemory;
    [ imgrep getBitmapDataPlanes: planes ];
    
    /* copy data and mask, extending the mask to all black pixels because the inversion effect doesn't work with Cocoa's alpha-blended cursors */
    for (i = 0; i < (w+7)/8*h; i++) {
        planes[0][i] = data[i];
        planes[1][i] = mask[i] | data[i];
    }
    
    /* create image and cursor */
    img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(w, h) ] autorelease ];
    if (img == nil) goto outOfMemory;
    [ img addRepresentation: imgrep ];
    if (system_version < 0x1030) { /* on 10.2, cursors must be 16*16 */
        if (w > 16 || h > 16) { /* too big: scale it down */
            [ img setScalesWhenResized: YES ];
            hot_x = hot_x*16/w;
            hot_y = hot_y*16/h;
        }
        else { /* too small (or just right): extend it (from the bottom left corner, so hot_y must be adjusted) */
            hot_y += 16 - h;
        }
        [ img setSize: NSMakeSize(16, 16) ];
    }
    cursor->nscursor = [ [ NSCursor alloc ] initWithImage: img hotSpot: NSMakePoint(hot_x, hot_y) ];
    if (cursor->nscursor == nil) goto outOfMemory;
    
    [ pool release ];
    return(cursor);

outOfMemory:
    [ pool release ];
    if (cursor != NULL) SDL_free(cursor);
    SDL_OutOfMemory();
    return(NULL);
}

void QZ_UpdateCursor (_THIS) {
    BOOL state;

    if (cursor_should_be_visible || !(SDL_GetAppState() & SDL_APPMOUSEFOCUS)) {
        state = YES;
    } else {
        state = NO;
    }
    if (state != cursor_visible) {
        if (state) {
            [ NSCursor unhide ];
        } else {
            [ NSCursor hide ];
        }
        cursor_visible = state;
    }
}

BOOL QZ_IsMouseInWindow (_THIS) {
    if (qz_window == nil || (mode_flags & SDL_FULLSCREEN)) return YES; /*fullscreen*/
    else {
        NSPoint p = [ qz_window mouseLocationOutsideOfEventStream ];
        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" */
        return NSPointInRect(p, [ window_view frame ]);
    }
}

int QZ_ShowWMCursor (_THIS, WMcursor *cursor) { 

    if ( cursor == NULL) {
        if ( cursor_should_be_visible ) {
            cursor_should_be_visible = NO;
            QZ_ChangeGrabState (this, QZ_HIDECURSOR);
        }
        QZ_UpdateCursor(this);
    }
    else {
        if (qz_window ==nil || (mode_flags & SDL_FULLSCREEN)) {
            [ cursor->nscursor set ];
        }
        else {
            [ qz_window invalidateCursorRectsForView: [ qz_window contentView ] ];
        }
        if ( ! cursor_should_be_visible ) {
            cursor_should_be_visible = YES;
            QZ_ChangeGrabState (this, QZ_SHOWCURSOR);
        }
        QZ_UpdateCursor(this);
    }

    return 1;
}

/*
    Coordinate conversion functions, for convenience
    Cocoa sets the origin at the lower left corner of the window/screen
    SDL, CoreGraphics/WindowServer, and QuickDraw use the origin at the upper left corner
    The routines were written so they could be called before SetVideoMode() has finished;
    this might have limited usefulness at the moment, but the extra cost is trivial.
*/

/* Convert Cocoa screen coordinate to Cocoa window coordinate */
void QZ_PrivateGlobalToLocal (_THIS, NSPoint *p) {

    *p = [ qz_window convertScreenToBase:*p ];
}


/* Convert Cocoa window coordinate to Cocoa screen coordinate */
void QZ_PrivateLocalToGlobal (_THIS, NSPoint *p) {

    *p = [ qz_window convertBaseToScreen:*p ];
}

/* Convert SDL coordinate to Cocoa coordinate */
void QZ_PrivateSDLToCocoa (_THIS, NSPoint *p) {

    if ( CGDisplayIsCaptured (display_id) ) { /* capture signals fullscreen */
    
        p->y = CGDisplayPixelsHigh (display_id) - p->y;
    }
    else {
       
        *p = [ window_view convertPoint:*p toView: nil ];
        p->y = [window_view frame].size.height - p->y;
    }
}

/* Convert Cocoa coordinate to SDL coordinate */
void QZ_PrivateCocoaToSDL (_THIS, NSPoint *p) {

    if ( CGDisplayIsCaptured (display_id) ) { /* capture signals fullscreen */
    
        p->y = CGDisplayPixelsHigh (display_id) - p->y;
    }
    else {

        *p = [ window_view convertPoint:*p fromView: nil ];
        p->y = [window_view frame].size.height - p->y;
    }
}

/* Convert SDL coordinate to window server (CoreGraphics) coordinate */
CGPoint QZ_PrivateSDLToCG (_THIS, NSPoint *p) {
    
    CGPoint cgp;
    
    if ( ! CGDisplayIsCaptured (display_id) ) { /* not captured => not fullscreen => local coord */
    
        int height;
        
        QZ_PrivateSDLToCocoa (this, p);
        QZ_PrivateLocalToGlobal (this, p);
        
        height = CGDisplayPixelsHigh (display_id);
        p->y = height - p->y;
    }
    
    cgp.x = p->x;
    cgp.y = p->y;
    
    return cgp;
}

#if 0 /* Dead code */
/* Convert window server (CoreGraphics) coordinate to SDL coordinate */
void QZ_PrivateCGToSDL (_THIS, NSPoint *p) {
            
    if ( ! CGDisplayIsCaptured (display_id) ) { /* not captured => not fullscreen => local coord */
    
        int height;

        /* Convert CG Global to Cocoa Global */
        height = CGDisplayPixelsHigh (display_id);
        p->y = height - p->y;

        QZ_PrivateGlobalToLocal (this, p);
        QZ_PrivateCocoaToSDL (this, p);
    }
}
#endif /* Dead code */

void  QZ_PrivateWarpCursor (_THIS, int x, int y) {
    
    NSPoint p;
    CGPoint cgp;
    
    p = NSMakePoint (x, y);
    cgp = QZ_PrivateSDLToCG (this, &p);
    
    /* this is the magic call that fixes cursor "freezing" after warp */
    CGSetLocalEventsSuppressionInterval (0.0);
    CGWarpMouseCursorPosition (cgp);
}

void QZ_WarpWMCursor (_THIS, Uint16 x, Uint16 y) {

    /* Only allow warping when in foreground */
    if ( ! [ NSApp isActive ] )
        return;
            
    /* Do the actual warp */
    if (grab_state != QZ_INVISIBLE_GRAB) QZ_PrivateWarpCursor (this, x, y);

    /* Generate the mouse moved event */
    SDL_PrivateMouseMotion (0, 0, x, y);
}

void QZ_MoveWMCursor     (_THIS, int x, int y) { }
void QZ_CheckMouseMode   (_THIS) { }

void QZ_SetCaption    (_THIS, const char *title, const char *icon) {

    if ( qz_window != nil ) {
        NSString *string;
        if ( title != NULL ) {
            string = [ [ NSString alloc ] initWithUTF8String:title ];
            [ qz_window setTitle:string ];
            [ string release ];
        }
        if ( icon != NULL ) {
            string = [ [ NSString alloc ] initWithUTF8String:icon ];
            [ qz_window setMiniwindowTitle:string ];
            [ string release ];
        }
    }
}

void QZ_SetIcon       (_THIS, SDL_Surface *icon, Uint8 *mask)
{
    NSBitmapImageRep *imgrep;
    NSImage *img;
    SDL_Surface *mergedSurface;
    NSAutoreleasePool *pool;
    Uint8 *pixels;
    SDL_bool iconSrcAlpha;
    Uint8 iconAlphaValue;
    int i, j, maskPitch, index;
    
    pool = [ [ NSAutoreleasePool alloc ] init ];
    
    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 ];
    if (imgrep == nil) goto freePool;
    pixels = [ imgrep bitmapData ];
    SDL_memset(pixels, 0, 4*icon->w*icon->h); /* make the background, which will survive in colorkeyed areas, completely transparent */
    
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
#define BYTEORDER_DEPENDENT_RGBA_MASKS 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#else
#define BYTEORDER_DEPENDENT_RGBA_MASKS 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#endif
    mergedSurface = SDL_CreateRGBSurfaceFrom(pixels, icon->w, icon->h, 32, 4*icon->w, BYTEORDER_DEPENDENT_RGBA_MASKS);
    if (mergedSurface == NULL) goto freePool;
    
    /* blit, with temporarily cleared SRCALPHA flag because we want to copy, not alpha-blend */
    iconSrcAlpha = ((icon->flags & SDL_SRCALPHA) != 0);
    iconAlphaValue = icon->format->alpha;
    SDL_SetAlpha(icon, 0, 255);
    SDL_BlitSurface(icon, NULL, mergedSurface, NULL);
    if (iconSrcAlpha) SDL_SetAlpha(icon, SDL_SRCALPHA, iconAlphaValue);
    
    SDL_FreeSurface(mergedSurface);
    
    /* apply mask, source alpha, and premultiply color values by alpha */
    maskPitch = (icon->w+7)/8;
    for (i = 0; i < icon->h; i++) {
        for (j = 0; j < icon->w; j++) {
            index = i*4*icon->w + j*4;
            if (!(mask[i*maskPitch + j/8] & (128 >> j%8))) {
                pixels[index + 3] = 0;
            }
            else {
                if (iconSrcAlpha) {
                    if (icon->format->Amask == 0) pixels[index + 3] = icon->format->alpha;
                }
                else {
                    pixels[index + 3] = 255;
                }
            }
            if (pixels[index + 3] < 255) {
                pixels[index + 0] = (Uint16)pixels[index + 0]*pixels[index + 3]/255;
                pixels[index + 1] = (Uint16)pixels[index + 1]*pixels[index + 3]/255;
                pixels[index + 2] = (Uint16)pixels[index + 2]*pixels[index + 3]/255;
            }
        }
    }
    
    img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(icon->w, icon->h) ] autorelease ];
    if (img == nil) goto freePool;
    [ img addRepresentation: imgrep ];
    [ NSApp setApplicationIconImage:img ];
    
freePool:
    [ pool release ];
}

int  QZ_IconifyWindow (_THIS) { 

    if ( ! [ qz_window isMiniaturized ] ) {
        [ qz_window miniaturize:nil ];
        if ( ! [ qz_window isMiniaturized ] ) {
            SDL_SetError ("window iconification failed");
            return 0;
        }
        return 1;
    }
    else {
        SDL_SetError ("window already iconified");
        return 0;
    }
}

/*
int  QZ_GetWMInfo  (_THIS, SDL_SysWMinfo *info) { 
    info->nsWindowPtr = qz_window;
    return 0; 
}*/

void QZ_ChangeGrabState (_THIS, int action) {

    /* 
        Figure out what the next state should be based on the action.
        Ignore actions that can't change the current state.
    */
    if ( grab_state == QZ_UNGRABBED ) {
        if ( action == QZ_ENABLE_GRAB ) {
            if ( cursor_should_be_visible )
                grab_state = QZ_VISIBLE_GRAB;
            else
                grab_state = QZ_INVISIBLE_GRAB;
        }
    }
    else if ( grab_state == QZ_VISIBLE_GRAB ) {
        if ( action == QZ_DISABLE_GRAB )
            grab_state = QZ_UNGRABBED;
        else if ( action == QZ_HIDECURSOR )
            grab_state = QZ_INVISIBLE_GRAB;
    }
    else {
        assert( grab_state == QZ_INVISIBLE_GRAB );
        
        if ( action == QZ_DISABLE_GRAB )
            grab_state = QZ_UNGRABBED;
        else if ( action == QZ_SHOWCURSOR )
            grab_state = QZ_VISIBLE_GRAB;
    }
    
    /* now apply the new state */
    if (grab_state == QZ_UNGRABBED) {
    
        CGAssociateMouseAndMouseCursorPosition (1);
    }
    else if (grab_state == QZ_VISIBLE_GRAB) {
    
        CGAssociateMouseAndMouseCursorPosition (1);
    }
    else {
        assert( grab_state == QZ_INVISIBLE_GRAB );

        QZ_PrivateWarpCursor (this, SDL_VideoSurface->w / 2, SDL_VideoSurface->h / 2);
        CGAssociateMouseAndMouseCursorPosition (0);
    }
}

SDL_GrabMode QZ_GrabInput (_THIS, SDL_GrabMode grab_mode) {

    int doGrab = grab_mode & SDL_GRAB_ON;
    /*int fullscreen = grab_mode & SDL_GRAB_FULLSCREEN;*/

    if ( this->screen == NULL ) {
        SDL_SetError ("QZ_GrabInput: screen is NULL");
        return SDL_GRAB_OFF;
    }
        
    if ( ! video_set ) {
        /*SDL_SetError ("QZ_GrabInput: video is not set, grab will take effect on mode switch"); */
        current_grab_mode = grab_mode;
        return grab_mode;       /* Will be set later on mode switch */
    }

    if ( grab_mode != SDL_GRAB_QUERY ) {
        if ( doGrab )
            QZ_ChangeGrabState (this, QZ_ENABLE_GRAB);
        else
            QZ_ChangeGrabState (this, QZ_DISABLE_GRAB);
        
        current_grab_mode = doGrab ? SDL_GRAB_ON : SDL_GRAB_OFF;
    }

    return current_grab_mode;
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU 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: NSDeviceBlackColorSpace 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];
	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 1616 /
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	[ cursor->nscursor set ];
129	}
130	else {
131	[ qz_window invalidateCursorRectsForView: [ qz_window contentView ] ];
132	}
133	if ( ! cursor_should_be_visible ) {
134	cursor_should_be_visible = YES;
135	QZ_ChangeGrabState (this, QZ_SHOWCURSOR);
136	}
137	QZ_UpdateCursor(this);
138	}
139
140	return 1;
141	}
142
143	/*
144	Coordinate conversion functions, for convenience
145	Cocoa sets the origin at the lower left corner of the window/screen
146	SDL, CoreGraphics/WindowServer, and QuickDraw use the origin at the upper left corner
147	The routines were written so they could be called before SetVideoMode() has finished;
148	this might have limited usefulness at the moment, but the extra cost is trivial.
149	*/
150
151	/* Convert Cocoa screen coordinate to Cocoa window coordinate */
152	void QZ_PrivateGlobalToLocal (_THIS, NSPoint *p) {
153
154	p = [ qz_window convertScreenToBase:p ];
155	}
156
157
158	/* Convert Cocoa window coordinate to Cocoa screen coordinate */
159	void QZ_PrivateLocalToGlobal (_THIS, NSPoint *p) {
160
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
234	NSPoint p;
235	CGPoint cgp;
236
237	p = NSMakePoint (x, y);
238	cgp = QZ_PrivateSDLToCG (this, &p);
239
240	/* this is the magic call that fixes cursor "freezing" after warp */
241	CGSetLocalEventsSuppressionInterval (0.0);
242	CGWarpMouseCursorPosition (cgp);
243	}
244
245	void QZ_WarpWMCursor (_THIS, Uint16 x, Uint16 y) {
246
247	/* Only allow warping when in foreground */
248	if ( ! [ NSApp isActive ] )
249	return;
250
251	/* Do the actual warp */
252	if (grab_state != QZ_INVISIBLE_GRAB) QZ_PrivateWarpCursor (this, x, y);
253
254	/* Generate the mouse moved event */
255	SDL_PrivateMouseMotion (0, 0, x, y);
256	}
257
258	void QZ_MoveWMCursor (_THIS, int x, int y) { }
259	void QZ_CheckMouseMode (_THIS) { }
260
261	void QZ_SetCaption (_THIS, const char title, const char icon) {
262
263	if ( qz_window != nil ) {
264	NSString *string;
265	if ( title != NULL ) {
266	string = [ [ NSString alloc ] initWithUTF8String:title ];
267	[ qz_window setTitle:string ];
268	[ string release ];
269	}
270	if ( icon != NULL ) {
271	string = [ [ NSString alloc ] initWithUTF8String:icon ];
272	[ qz_window setMiniwindowTitle:string ];
273	[ string release ];
274	}
275	}
276	}
277
278	void QZ_SetIcon (_THIS, SDL_Surface icon, Uint8 mask)
279	{
280	NSBitmapImageRep *imgrep;
281	NSImage *img;
282	SDL_Surface *mergedSurface;
283	NSAutoreleasePool *pool;
284	Uint8 *pixels;
285	SDL_bool iconSrcAlpha;
286	Uint8 iconAlphaValue;
287	int i, j, maskPitch, index;
288
289	pool = [ [ NSAutoreleasePool alloc ] init ];
290
291	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 ];
292	if (imgrep == nil) goto freePool;
293	pixels = [ imgrep bitmapData ];
294	SDL_memset(pixels, 0, 4icon->wicon->h); /* make the background, which will survive in colorkeyed areas, completely transparent */
295
296	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
297	#define BYTEORDER_DEPENDENT_RGBA_MASKS 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
298	#else
299	#define BYTEORDER_DEPENDENT_RGBA_MASKS 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
300	#endif
301	mergedSurface = SDL_CreateRGBSurfaceFrom(pixels, icon->w, icon->h, 32, 4*icon->w, BYTEORDER_DEPENDENT_RGBA_MASKS);
302	if (mergedSurface == NULL) goto freePool;
303
304	/* blit, with temporarily cleared SRCALPHA flag because we want to copy, not alpha-blend */
305	iconSrcAlpha = ((icon->flags & SDL_SRCALPHA) != 0);
306	iconAlphaValue = icon->format->alpha;
307	SDL_SetAlpha(icon, 0, 255);
308	SDL_BlitSurface(icon, NULL, mergedSurface, NULL);
309	if (iconSrcAlpha) SDL_SetAlpha(icon, SDL_SRCALPHA, iconAlphaValue);
310
311	SDL_FreeSurface(mergedSurface);
312
313	/* apply mask, source alpha, and premultiply color values by alpha */
314	maskPitch = (icon->w+7)/8;
315	for (i = 0; i < icon->h; i++) {
316	for (j = 0; j < icon->w; j++) {
317	index = i4icon->w + j*4;
318	if (!(mask[i*maskPitch + j/8] & (128 >> j%8))) {
319	pixels[index + 3] = 0;
320	}
321	else {
322	if (iconSrcAlpha) {
323	if (icon->format->Amask == 0) pixels[index + 3] = icon->format->alpha;
324	}
325	else {
326	pixels[index + 3] = 255;
327	}
328	}
329	if (pixels[index + 3] < 255) {
330	pixels[index + 0] = (Uint16)pixels[index + 0]*pixels[index + 3]/255;
331	pixels[index + 1] = (Uint16)pixels[index + 1]*pixels[index + 3]/255;
332	pixels[index + 2] = (Uint16)pixels[index + 2]*pixels[index + 3]/255;
333	}
334	}
335	}
336
337	img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(icon->w, icon->h) ] autorelease ];
338	if (img == nil) goto freePool;
339	[ img addRepresentation: imgrep ];
340	[ NSApp setApplicationIconImage:img ];
341
342	freePool:
343	[ pool release ];
344	}
345
346	int QZ_IconifyWindow (_THIS) {
347
348	if ( ! [ qz_window isMiniaturized ] ) {
349	[ qz_window miniaturize:nil ];
350	if ( ! [ qz_window isMiniaturized ] ) {
351	SDL_SetError ("window iconification failed");
352	return 0;
353	}
354	return 1;
355	}
356	else {
357	SDL_SetError ("window already iconified");
358	return 0;
359	}
360	}
361
362	/*
363	int QZ_GetWMInfo (_THIS, SDL_SysWMinfo *info) {
364	info->nsWindowPtr = qz_window;
365	return 0;
366	}*/
367
368	void QZ_ChangeGrabState (_THIS, int action) {
369
370	/*
371	Figure out what the next state should be based on the action.
372	Ignore actions that can't change the current state.
373	*/
374	if ( grab_state == QZ_UNGRABBED ) {
375	if ( action == QZ_ENABLE_GRAB ) {
376	if ( cursor_should_be_visible )
377	grab_state = QZ_VISIBLE_GRAB;
378	else
379	grab_state = QZ_INVISIBLE_GRAB;
380	}
381	}
382	else if ( grab_state == QZ_VISIBLE_GRAB ) {
383	if ( action == QZ_DISABLE_GRAB )
384	grab_state = QZ_UNGRABBED;
385	else if ( action == QZ_HIDECURSOR )
386	grab_state = QZ_INVISIBLE_GRAB;
387	}
388	else {
389	assert( grab_state == QZ_INVISIBLE_GRAB );
390
391	if ( action == QZ_DISABLE_GRAB )
392	grab_state = QZ_UNGRABBED;
393	else if ( action == QZ_SHOWCURSOR )
394	grab_state = QZ_VISIBLE_GRAB;
395	}
396
397	/* now apply the new state */
398	if (grab_state == QZ_UNGRABBED) {
399
400	CGAssociateMouseAndMouseCursorPosition (1);
401	}
402	else if (grab_state == QZ_VISIBLE_GRAB) {
403
404	CGAssociateMouseAndMouseCursorPosition (1);
405	}
406	else {
407	assert( grab_state == QZ_INVISIBLE_GRAB );
408
409	QZ_PrivateWarpCursor (this, SDL_VideoSurface->w / 2, SDL_VideoSurface->h / 2);
410	CGAssociateMouseAndMouseCursorPosition (0);
411	}
412	}
413
414	SDL_GrabMode QZ_GrabInput (_THIS, SDL_GrabMode grab_mode) {
415
416	int doGrab = grab_mode & SDL_GRAB_ON;
417	/int fullscreen = grab_mode & SDL_GRAB_FULLSCREEN;/
418
419	if ( this->screen == NULL ) {
420	SDL_SetError ("QZ_GrabInput: screen is NULL");
421	return SDL_GRAB_OFF;
422	}
423
424	if ( ! video_set ) {
425	/SDL_SetError ("QZ_GrabInput: video is not set, grab will take effect on mode switch"); /
426	current_grab_mode = grab_mode;
427	return grab_mode; /* Will be set later on mode switch */
428	}
429
430	if ( grab_mode != SDL_GRAB_QUERY ) {
431	if ( doGrab )
432	QZ_ChangeGrabState (this, QZ_ENABLE_GRAB);
433	else
434	QZ_ChangeGrabState (this, QZ_DISABLE_GRAB);
435
436	current_grab_mode = doGrab ? SDL_GRAB_ON : SDL_GRAB_OFF;
437	}
438
439	return current_grab_mode;
440	}