src/video/quartz/SDL_QuartzWM.m
author Ryan C. Gordon
Sat, 03 Aug 2019 16:27:46 -0400
branchSDL-1.2
changeset 12992 0cfa2cc751eb
parent 6224 6f013dd0add1
permissions -rw-r--r--
quartz: Fix cursor transparency.

This patch originally came from:

https://github.com/kanjitalk755/SDL/commit/0296d5e601a5deb5ce2f540a8eafd64dd22dbe69

Fixes Bugzilla #4076.
     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] & mask[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 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 }