Pileus Git - ~andy/gtk/blob - gdk/quartz/gdkcursor-quartz.c

   1 /* gdkcursor-quartz.c
   2  *
   3  * Copyright (C) 2005-2007 Imendio AB
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser 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  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include "gdkdisplay.h"
  24 #include "gdkcursor.h"
  25 #include "gdkprivate-quartz.h"
  26
  27 #include "xcursors.h"
  28
  29 static GdkCursor *cached_xcursors[G_N_ELEMENTS (xcursors)];
  30
  31 static GdkCursor *
  32 gdk_quartz_cursor_new_from_nscursor (NSCursor      *nscursor,
  33                                      GdkCursorType  cursor_type)
  34 {
  35   GdkCursorPrivate *private;
  36   GdkCursor *cursor;
  37
  38   private = g_new (GdkCursorPrivate, 1);
  39   private->nscursor = nscursor;
  40
  41   cursor = (GdkCursor *)private;
  42   cursor->type = cursor_type;
  43   cursor->ref_count = 1;
  44
  45   return cursor;
  46 }
  47
  48 static gboolean
  49 get_bit (const guchar *data,
  50          gint          width,
  51          gint          height,
  52          gint          x,
  53          gint          y)
  54 {
  55   gint bytes_per_line;
  56   const guchar *src;
  57
  58   if (x < 0 || y < 0 || x >= width || y >= height)
  59     return FALSE;
  60
  61   bytes_per_line = (width + 7) / 8;
  62
  63   src = &data[y * bytes_per_line];
  64   return ((src[x / 8] >> x % 8) & 1);
  65 }
  66
  67 static GdkCursor *
  68 create_builtin_cursor (GdkCursorType cursor_type)
  69 {
  70   GdkCursor *cursor;
  71   NSBitmapImageRep *bitmap_rep;
  72   gint mask_width, mask_height;
  73   gint src_width, src_height;
  74   gint dst_stride;
  75   const guchar *mask_start, *src_start;
  76   gint dx, dy;
  77   gint x, y;
  78   NSPoint hotspot;
  79   NSImage *image;
  80   NSCursor *nscursor;
  81
  82   if (cursor_type >= G_N_ELEMENTS (xcursors))
  83     return NULL;
  84
  85   cursor = cached_xcursors[cursor_type];
  86   if (cursor)
  87     return cursor;
  88
  89   GDK_QUARTZ_ALLOC_POOL;
  90
  91   src_width = xcursors[cursor_type].width;
  92   src_height = xcursors[cursor_type].height;
  93   mask_width = xcursors[cursor_type+1].width;
  94   mask_height = xcursors[cursor_type+1].height;
  95
  96   bitmap_rep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
  97                 pixelsWide:mask_width pixelsHigh:mask_height
  98                 bitsPerSample:8 samplesPerPixel:4
  99                 hasAlpha:YES isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace
 100                 bytesPerRow:0 bitsPerPixel:0];
 101
 102   dst_stride = [bitmap_rep bytesPerRow];
 103
 104   src_start = xcursors[cursor_type].bits;
 105   mask_start = xcursors[cursor_type+1].bits;
 106
 107   dx = xcursors[cursor_type+1].hotx - xcursors[cursor_type].hotx;
 108   dy = xcursors[cursor_type+1].hoty - xcursors[cursor_type].hoty;
 109
 110   for (y = 0; y < mask_height; y++)
 111     {
 112       guchar *dst = [bitmap_rep bitmapData] + y * dst_stride;
 113
 114       for (x = 0; x < mask_width; x++)
 115         {
 116           if (get_bit (mask_start, mask_width, mask_height, x, y))
 117             {
 118               if (get_bit (src_start, src_width, src_height, x - dx, y - dy))
 119                 {
 120                   *dst++ = 0;
 121                   *dst++ = 0;
 122                   *dst++ = 0;
 123                 }
 124               else
 125                 {
 126                   *dst++ = 0xff;
 127                   *dst++ = 0xff;
 128                   *dst++ = 0xff;
 129                 }
 130
 131               *dst++ = 0xff;
 132             }
 133           else
 134             {
 135               *dst++ = 0;
 136               *dst++ = 0;
 137               *dst++ = 0;
 138               *dst++ = 0;
 139             }
 140         }
 141     }
 142
 143   image = [[NSImage alloc] init];
 144   [image addRepresentation:bitmap_rep];
 145   [bitmap_rep release];
 146
 147   hotspot = NSMakePoint (xcursors[cursor_type+1].hotx,
 148                          xcursors[cursor_type+1].hoty);
 149
 150   nscursor = [[NSCursor alloc] initWithImage:image hotSpot:hotspot];
 151   [image release];
 152
 153   cursor = gdk_quartz_cursor_new_from_nscursor (nscursor, GDK_CURSOR_IS_PIXMAP);
 154
 155   cached_xcursors[cursor_type] = gdk_cursor_ref (cursor);
 156
 157   GDK_QUARTZ_RELEASE_POOL;
 158
 159   return cursor;
 160 }
 161
 162 GdkCursor*
 163 gdk_cursor_new_for_display (GdkDisplay    *display,
 164                             GdkCursorType  cursor_type)
 165 {
 166   NSCursor *nscursor;
 167
 168   g_return_val_if_fail (display == gdk_display_get_default (), NULL);
 169
 170   switch (cursor_type)
 171     {
 172     case GDK_XTERM:
 173       nscursor = [NSCursor IBeamCursor];
 174       break;
 175     case GDK_SB_H_DOUBLE_ARROW:
 176       nscursor = [NSCursor resizeLeftRightCursor];
 177       break;
 178     case GDK_SB_V_DOUBLE_ARROW:
 179       nscursor = [NSCursor resizeUpDownCursor];
 180       break;
 181     case GDK_SB_UP_ARROW:
 182     case GDK_BASED_ARROW_UP:
 183     case GDK_BOTTOM_TEE:
 184     case GDK_TOP_SIDE:
 185       nscursor = [NSCursor resizeUpCursor];
 186       break;
 187     case GDK_SB_DOWN_ARROW:
 188     case GDK_BASED_ARROW_DOWN:
 189     case GDK_TOP_TEE:
 190     case GDK_BOTTOM_SIDE:
 191       nscursor = [NSCursor resizeDownCursor];
 192       break;
 193     case GDK_SB_LEFT_ARROW:
 194     case GDK_RIGHT_TEE:
 195     case GDK_LEFT_SIDE:
 196       nscursor = [NSCursor resizeLeftCursor];
 197       break;
 198     case GDK_SB_RIGHT_ARROW:
 199     case GDK_LEFT_TEE:
 200     case GDK_RIGHT_SIDE:
 201       nscursor = [NSCursor resizeRightCursor];
 202       break;
 203     case GDK_TCROSS:
 204     case GDK_CROSS:
 205     case GDK_CROSSHAIR:
 206     case GDK_DIAMOND_CROSS:
 207       nscursor = [NSCursor crosshairCursor];
 208       break;
 209     case GDK_HAND1:
 210     case GDK_HAND2:
 211       nscursor = [NSCursor pointingHandCursor];
 212       break;
 213     default:
 214       return gdk_cursor_ref (create_builtin_cursor (cursor_type));
 215     }
 216
 217   [nscursor retain];
 218   return gdk_quartz_cursor_new_from_nscursor (nscursor, cursor_type);
 219 }
 220
 221 GdkCursor*
 222 gdk_cursor_new_from_pixmap (GdkPixmap      *source,
 223                             GdkPixmap      *mask,
 224                             const GdkColor *fg,
 225                             const GdkColor *bg,
 226                             gint            x,
 227                             gint            y)
 228 {
 229   NSBitmapImageRep *bitmap_rep;
 230   NSImage *image;
 231   NSCursor *nscursor;
 232   GdkCursor *cursor;
 233   gint width, height;
 234   gint tmp_x, tmp_y;
 235   guchar *dst_data, *mask_data, *src_data;
 236   guchar *mask_start, *src_start;
 237   int dst_stride;
 238
 239   g_return_val_if_fail (GDK_IS_PIXMAP (source), NULL);
 240   g_return_val_if_fail (GDK_IS_PIXMAP (mask), NULL);
 241   g_return_val_if_fail (fg != NULL, NULL);
 242   g_return_val_if_fail (bg != NULL, NULL);
 243
 244   GDK_QUARTZ_ALLOC_POOL;
 245
 246   gdk_drawable_get_size (source, &width, &height);
 247
 248   bitmap_rep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
 249                 pixelsWide:width pixelsHigh:height
 250                 bitsPerSample:8 samplesPerPixel:4
 251                 hasAlpha:YES isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace
 252                 bytesPerRow:0 bitsPerPixel:0];
 253
 254   dst_stride = [bitmap_rep bytesPerRow];
 255   mask_start = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (mask)->impl)->data;
 256   src_start = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (source)->impl)->data;
 257
 258   for (tmp_y = 0; tmp_y < height; tmp_y++)
 259     {
 260       dst_data = [bitmap_rep bitmapData] + tmp_y * dst_stride;
 261       mask_data = mask_start + tmp_y * width;
 262       src_data = src_start + tmp_y * width;
 263
 264       for (tmp_x = 0; tmp_x < width; tmp_x++)
 265         {
 266           if (*mask_data++)
 267             {
 268               const GdkColor *color;
 269
 270               if (*src_data++)
 271                 color = fg;
 272               else
 273                 color = bg;
 274
 275               *dst_data++ = (color->red >> 8) & 0xff;
 276               *dst_data++ = (color->green >> 8) & 0xff;
 277               *dst_data++ = (color->blue >> 8) & 0xff;
 278               *dst_data++ = 0xff;
 279
 280             }
 281           else
 282             {
 283               *dst_data++ = 0x00;
 284               *dst_data++ = 0x00;
 285               *dst_data++ = 0x00;
 286               *dst_data++ = 0x00;
 287
 288               src_data++;
 289             }
 290         }
 291     }
 292   image = [[NSImage alloc] init];
 293   [image addRepresentation:bitmap_rep];
 294   [bitmap_rep release];
 295
 296   nscursor = [[NSCursor alloc] initWithImage:image hotSpot:NSMakePoint(x, y)];
 297   [image release];
 298
 299   cursor = gdk_quartz_cursor_new_from_nscursor (nscursor, GDK_CURSOR_IS_PIXMAP);
 300
 301   GDK_QUARTZ_RELEASE_POOL;
 302
 303   return cursor;
 304 }
 305
 306 static NSImage *
 307 _gdk_quartz_pixbuf_to_ns_image (GdkPixbuf *pixbuf)
 308 {
 309   NSBitmapImageRep  *bitmap_rep;
 310   NSImage           *image;
 311   gboolean           has_alpha;
 312
 313   has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
 314
 315   /* Create a bitmap image rep */
 316   bitmap_rep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
 317                                          pixelsWide:gdk_pixbuf_get_width (pixbuf)
 318                                          pixelsHigh:gdk_pixbuf_get_height (pixbuf)
 319                                          bitsPerSample:8 samplesPerPixel:has_alpha ? 4 : 3
 320                                          hasAlpha:has_alpha isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace
 321                                          bytesPerRow:0 bitsPerPixel:0];
 322
 323   {
 324     /* Add pixel data to bitmap rep */
 325     guchar *src, *dst;
 326     int src_stride, dst_stride;
 327     int x, y;
 328
 329     src_stride = gdk_pixbuf_get_rowstride (pixbuf);
 330     dst_stride = [bitmap_rep bytesPerRow];
 331
 332     for (y = 0; y < gdk_pixbuf_get_height (pixbuf); y++)
 333       {
 334         src = gdk_pixbuf_get_pixels (pixbuf) + y * src_stride;
 335         dst = [bitmap_rep bitmapData] + y * dst_stride;
 336
 337         for (x = 0; x < gdk_pixbuf_get_width (pixbuf); x++)
 338           {
 339             if (has_alpha)
 340               {
 341                 guchar red, green, blue, alpha;
 342
 343                 red = *src++;
 344                 green = *src++;
 345                 blue = *src++;
 346                 alpha = *src++;
 347
 348                 *dst++ = (red * alpha) / 255;
 349                 *dst++ = (green * alpha) / 255;
 350                 *dst++ = (blue * alpha) / 255;
 351                 *dst++ = alpha;
 352               }
 353             else
 354              {
 355                *dst++ = *src++;
 356                *dst++ = *src++;
 357                *dst++ = *src++;
 358              }
 359           }
 360       }
 361   }
 362
 363   image = [[NSImage alloc] init];
 364   [image addRepresentation:bitmap_rep];
 365   [bitmap_rep release];
 366   [image autorelease];
 367
 368   return image;
 369 }
 370
 371 GdkCursor *
 372 gdk_cursor_new_from_pixbuf (GdkDisplay *display,
 373                             GdkPixbuf  *pixbuf,
 374                             gint        x,
 375                             gint        y)
 376 {
 377   NSImage *image;
 378   NSCursor *nscursor;
 379   GdkCursor *cursor;
 380   gboolean has_alpha;
 381
 382   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 383   g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
 384   g_return_val_if_fail (0 <= x && x < gdk_pixbuf_get_width (pixbuf), NULL);
 385   g_return_val_if_fail (0 <= y && y < gdk_pixbuf_get_height (pixbuf), NULL);
 386
 387   GDK_QUARTZ_ALLOC_POOL;
 388
 389   has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
 390
 391   image = _gdk_quartz_pixbuf_to_ns_image (pixbuf);
 392   nscursor = [[NSCursor alloc] initWithImage:image hotSpot:NSMakePoint(x, y)];
 393
 394   cursor = gdk_quartz_cursor_new_from_nscursor (nscursor, GDK_CURSOR_IS_PIXMAP);
 395
 396   GDK_QUARTZ_RELEASE_POOL;
 397
 398   return cursor;
 399 }
 400
 401 GdkCursor*
 402 gdk_cursor_new_from_name (GdkDisplay  *display,
 403                           const gchar *name)
 404 {
 405   /* FIXME: Implement */
 406   return NULL;
 407 }
 408
 409 void
 410 _gdk_cursor_destroy (GdkCursor *cursor)
 411 {
 412   GdkCursorPrivate *private;
 413
 414   g_return_if_fail (cursor != NULL);
 415   g_return_if_fail (cursor->ref_count == 0);
 416
 417   private = (GdkCursorPrivate *)cursor;
 418   [private->nscursor release];
 419
 420   g_free (private);
 421 }
 422
 423 gboolean
 424 gdk_display_supports_cursor_alpha (GdkDisplay *display)
 425 {
 426   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 427
 428   return TRUE;
 429 }
 430
 431 gboolean
 432 gdk_display_supports_cursor_color (GdkDisplay *display)
 433 {
 434   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 435
 436   return TRUE;
 437 }
 438
 439 guint
 440 gdk_display_get_default_cursor_size (GdkDisplay *display)
 441 {
 442   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
 443
 444   /* Mac OS X doesn't have the notion of a default size */
 445   return 32;
 446 }
 447
 448 void
 449 gdk_display_get_maximal_cursor_size (GdkDisplay *display,
 450                                      guint       *width,
 451                                      guint       *height)
 452 {
 453   g_return_if_fail (GDK_IS_DISPLAY (display));
 454
 455   /* Cursor sizes in Mac OS X can be arbitrarily large */
 456   *width = 65536;
 457   *height = 65536;
 458 }
 459
 460 GdkDisplay *
 461 gdk_cursor_get_display (GdkCursor *cursor)
 462 {
 463   g_return_val_if_fail (cursor != NULL, NULL);
 464
 465   return gdk_display_get_default ();
 466 }
 467
 468 GdkPixbuf *
 469 gdk_cursor_get_image (GdkCursor *cursor)
 470 {
 471   /* FIXME: Implement */
 472   return NULL;
 473 }
 474
 475 NSImage *
 476 gdk_quartz_pixbuf_to_ns_image_libgtk_only (GdkPixbuf *pixbuf)
 477 {
 478   return _gdk_quartz_pixbuf_to_ns_image (pixbuf);
 479 }