src/video/quartz/SDL_QuartzWM.m

   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 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             [ 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, 4*icon->w*icon->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 = i*4*icon->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 }