src/video/quartz/SDL_QuartzWM.m
author Ryan C. Gordon
Sun, 01 Jan 2012 20:45:31 -0500
branchSDL-1.2
changeset 6150 5f0b3693ab60
parent 6137 4720145f848b
child 6224 6f013dd0add1
permissions -rw-r--r--
Throw around some QZ_UpdateCursor() calls to fix wrongly-shown system cursor.

Fixes Bugzilla #1339.
     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     CGEventSourceRef evsrc = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState);
   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     CGEventSourceSetLocalEventsSuppressionInterval(evsrc, 0.0);
   242     CGWarpMouseCursorPosition (cgp);
   243     CFRelease(evsrc);
   244     SDL_PrivateAppActive (QZ_IsMouseInWindow (this), SDL_APPMOUSEFOCUS);
   245 }
   246 
   247 void QZ_WarpWMCursor (_THIS, Uint16 x, Uint16 y) {
   248 
   249     /* Only allow warping when in foreground */
   250     if ( ! [ NSApp isActive ] )
   251         return;
   252             
   253     /* Do the actual warp */
   254     if (grab_state != QZ_INVISIBLE_GRAB) QZ_PrivateWarpCursor (this, x, y);
   255 
   256     /* Generate the mouse moved event */
   257     SDL_PrivateMouseMotion (0, 0, x, y);
   258 }
   259 
   260 void QZ_MoveWMCursor     (_THIS, int x, int y) { }
   261 void QZ_CheckMouseMode   (_THIS) { }
   262 
   263 void QZ_SetCaption    (_THIS, const char *title, const char *icon) {
   264 
   265     if ( qz_window != nil ) {
   266         NSString *string;
   267         if ( title != NULL ) {
   268             string = [ [ NSString alloc ] initWithUTF8String:title ];
   269             [ qz_window setTitle:string ];
   270             [ string release ];
   271         }
   272         if ( icon != NULL ) {
   273             string = [ [ NSString alloc ] initWithUTF8String:icon ];
   274             [ qz_window setMiniwindowTitle:string ];
   275             [ string release ];
   276         }
   277     }
   278 }
   279 
   280 void QZ_SetIcon       (_THIS, SDL_Surface *icon, Uint8 *mask)
   281 {
   282     NSBitmapImageRep *imgrep;
   283     NSImage *img;
   284     SDL_Surface *mergedSurface;
   285     NSAutoreleasePool *pool;
   286     Uint8 *pixels;
   287     SDL_bool iconSrcAlpha;
   288     Uint8 iconAlphaValue;
   289     int i, j, maskPitch, index;
   290     
   291     pool = [ [ NSAutoreleasePool alloc ] init ];
   292     
   293     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 ];
   294     if (imgrep == nil) goto freePool;
   295     pixels = [ imgrep bitmapData ];
   296     SDL_memset(pixels, 0, 4*icon->w*icon->h); /* make the background, which will survive in colorkeyed areas, completely transparent */
   297     
   298 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
   299 #define BYTEORDER_DEPENDENT_RGBA_MASKS 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
   300 #else
   301 #define BYTEORDER_DEPENDENT_RGBA_MASKS 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
   302 #endif
   303     mergedSurface = SDL_CreateRGBSurfaceFrom(pixels, icon->w, icon->h, 32, 4*icon->w, BYTEORDER_DEPENDENT_RGBA_MASKS);
   304     if (mergedSurface == NULL) goto freePool;
   305     
   306     /* blit, with temporarily cleared SRCALPHA flag because we want to copy, not alpha-blend */
   307     iconSrcAlpha = ((icon->flags & SDL_SRCALPHA) != 0);
   308     iconAlphaValue = icon->format->alpha;
   309     SDL_SetAlpha(icon, 0, 255);
   310     SDL_BlitSurface(icon, NULL, mergedSurface, NULL);
   311     if (iconSrcAlpha) SDL_SetAlpha(icon, SDL_SRCALPHA, iconAlphaValue);
   312     
   313     SDL_FreeSurface(mergedSurface);
   314     
   315     /* apply mask, source alpha, and premultiply color values by alpha */
   316     maskPitch = (icon->w+7)/8;
   317     for (i = 0; i < icon->h; i++) {
   318         for (j = 0; j < icon->w; j++) {
   319             index = i*4*icon->w + j*4;
   320             if (!(mask[i*maskPitch + j/8] & (128 >> j%8))) {
   321                 pixels[index + 3] = 0;
   322             }
   323             else {
   324                 if (iconSrcAlpha) {
   325                     if (icon->format->Amask == 0) pixels[index + 3] = icon->format->alpha;
   326                 }
   327                 else {
   328                     pixels[index + 3] = 255;
   329                 }
   330             }
   331             if (pixels[index + 3] < 255) {
   332                 pixels[index + 0] = (Uint16)pixels[index + 0]*pixels[index + 3]/255;
   333                 pixels[index + 1] = (Uint16)pixels[index + 1]*pixels[index + 3]/255;
   334                 pixels[index + 2] = (Uint16)pixels[index + 2]*pixels[index + 3]/255;
   335             }
   336         }
   337     }
   338     
   339     img = [ [ [ NSImage alloc ] initWithSize: NSMakeSize(icon->w, icon->h) ] autorelease ];
   340     if (img == nil) goto freePool;
   341     [ img addRepresentation: imgrep ];
   342     [ NSApp setApplicationIconImage:img ];
   343     
   344 freePool:
   345     [ pool release ];
   346 }
   347 
   348 int  QZ_IconifyWindow (_THIS) { 
   349 
   350     if ( ! [ qz_window isMiniaturized ] ) {
   351         [ qz_window miniaturize:nil ];
   352         if ( ! [ qz_window isMiniaturized ] ) {
   353             SDL_SetError ("window iconification failed");
   354             return 0;
   355         }
   356         return 1;
   357     }
   358     else {
   359         SDL_SetError ("window already iconified");
   360         return 0;
   361     }
   362 }
   363 
   364 /*
   365 int  QZ_GetWMInfo  (_THIS, SDL_SysWMinfo *info) { 
   366     info->nsWindowPtr = qz_window;
   367     return 0; 
   368 }*/
   369 
   370 void QZ_ChangeGrabState (_THIS, int action) {
   371 
   372     /* 
   373         Figure out what the next state should be based on the action.
   374         Ignore actions that can't change the current state.
   375     */
   376     if ( grab_state == QZ_UNGRABBED ) {
   377         if ( action == QZ_ENABLE_GRAB ) {
   378             if ( cursor_should_be_visible )
   379                 grab_state = QZ_VISIBLE_GRAB;
   380             else
   381                 grab_state = QZ_INVISIBLE_GRAB;
   382         }
   383     }
   384     else if ( grab_state == QZ_VISIBLE_GRAB ) {
   385         if ( action == QZ_DISABLE_GRAB )
   386             grab_state = QZ_UNGRABBED;
   387         else if ( action == QZ_HIDECURSOR )
   388             grab_state = QZ_INVISIBLE_GRAB;
   389     }
   390     else {
   391         assert( grab_state == QZ_INVISIBLE_GRAB );
   392         
   393         if ( action == QZ_DISABLE_GRAB )
   394             grab_state = QZ_UNGRABBED;
   395         else if ( action == QZ_SHOWCURSOR )
   396             grab_state = QZ_VISIBLE_GRAB;
   397     }
   398     
   399     /* now apply the new state */
   400     if (grab_state == QZ_UNGRABBED) {
   401     
   402         CGAssociateMouseAndMouseCursorPosition (1);
   403     }
   404     else if (grab_state == QZ_VISIBLE_GRAB) {
   405     
   406         CGAssociateMouseAndMouseCursorPosition (1);
   407     }
   408     else {
   409         assert( grab_state == QZ_INVISIBLE_GRAB );
   410 
   411         QZ_PrivateWarpCursor (this, SDL_VideoSurface->w / 2, SDL_VideoSurface->h / 2);
   412         CGAssociateMouseAndMouseCursorPosition (0);
   413     }
   414 }
   415 
   416 SDL_GrabMode QZ_GrabInput (_THIS, SDL_GrabMode grab_mode) {
   417 
   418     int doGrab = grab_mode & SDL_GRAB_ON;
   419     /*int fullscreen = grab_mode & SDL_GRAB_FULLSCREEN;*/
   420 
   421     if ( this->screen == NULL ) {
   422         SDL_SetError ("QZ_GrabInput: screen is NULL");
   423         return SDL_GRAB_OFF;
   424     }
   425         
   426     if ( ! video_set ) {
   427         /*SDL_SetError ("QZ_GrabInput: video is not set, grab will take effect on mode switch"); */
   428         current_grab_mode = grab_mode;
   429         return grab_mode;       /* Will be set later on mode switch */
   430     }
   431 
   432     if ( grab_mode != SDL_GRAB_QUERY ) {
   433         if ( doGrab )
   434             QZ_ChangeGrabState (this, QZ_ENABLE_GRAB);
   435         else
   436             QZ_ChangeGrabState (this, QZ_DISABLE_GRAB);
   437         
   438         current_grab_mode = doGrab ? SDL_GRAB_ON : SDL_GRAB_OFF;
   439         QZ_UpdateCursor(this);
   440     }
   441 
   442     return current_grab_mode;
   443 }