src/nsimage.m

   1 /* Image support for the NeXT/Open/GNUstep and MacOSX window system.
   2    Copyright (C) 1989, 1992, 1993, 1994, 2005, 2006, 2008, 2009
   3      Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /*
  21 Originally by Carl Edman
  22 Updated by Christian Limpach (chris@nice.ch)
  23 OpenStep/Rhapsody port by Scott Bender (sbender@harmony-ds.com)
  24 MacOSX/Aqua port by Christophe de Dinechin (descubes@earthlink.net)
  25 GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
  26 */
  27
  28 /* This should be the first include, as it may set up #defines affecting
  29    interpretation of even the system includes. */
  30 #include "config.h"
  31
  32 #include "lisp.h"
  33 #include "dispextern.h"
  34 #include "nsterm.h"
  35 #include "frame.h"
  36
  37 extern Lisp_Object QCfile, QCdata;
  38
  39 /* call tracing */
  40 #if 0
  41 int image_trace_num = 0;
  42 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",         \
  43                                 __FILE__, __LINE__, ++image_trace_num)
  44 #else
  45 #define NSTRACE(x)
  46 #endif
  47
  48
  49 /* ==========================================================================
  50
  51    C interface.  This allows easy calling from C files.  We could just
  52    compile everything as Objective-C, but that might mean slower
  53    compilation and possible difficulties on some platforms..
  54
  55    ========================================================================== */
  56
  57 void *
  58 ns_image_from_XBM (unsigned char *bits, int width, int height)
  59 {
  60   NSTRACE (ns_image_from_XBM);
  61   return [[EmacsImage alloc] initFromXBM: bits
  62                                    width: width height: height
  63                                     flip: YES];
  64 }
  65
  66 void *
  67 ns_image_for_XPM (int width, int height, int depth)
  68 {
  69   NSTRACE (ns_image_for_XPM);
  70   return [[EmacsImage alloc] initForXPMWithDepth: depth
  71                                            width: width height: height];
  72 }
  73
  74 void *
  75 ns_image_from_file (Lisp_Object file)
  76 {
  77   NSTRACE (ns_image_from_bitmap_file);
  78   return [EmacsImage allocInitFromFile: file];
  79 }
  80
  81 int
  82 ns_load_image (struct frame *f, struct image *img,
  83                Lisp_Object spec_file, Lisp_Object spec_data)
  84 {
  85   NSTRACE (ns_load_image);
  86
  87   EmacsImage *eImg;
  88   NSSize size;
  89
  90   if (NILP (spec_data))
  91     {
  92       eImg = [EmacsImage allocInitFromFile: spec_file];
  93     }
  94   else
  95     {
  96       NSData *data = [NSData dataWithBytes: SDATA (spec_data)
  97                                     length: SBYTES (spec_data)];
  98       eImg = [[EmacsImage alloc] initWithData: data];
  99       [eImg setPixmapData];
 100     }
 101
 102   if (eImg == nil)
 103     {
 104       add_to_log ("Unable to load image %s", img->spec, Qnil);
 105       return 0;
 106     }
 107
 108   size = [eImg size];
 109   img->width = size.width;
 110   img->height = size.height;
 111
 112   /* 4) set img->pixmap = emacsimage */
 113   img->pixmap = eImg;
 114   return 1;
 115 }
 116
 117
 118 int
 119 ns_image_width (void *img)
 120 {
 121   return [(id)img size].width;
 122 }
 123
 124 int
 125 ns_image_height (void *img)
 126 {
 127   return [(id)img size].height;
 128 }
 129
 130 unsigned long
 131 ns_get_pixel (void *img, int x, int y)
 132 {
 133   return [(EmacsImage *)img getPixelAtX: x Y: y];
 134 }
 135
 136 void
 137 ns_put_pixel (void *img, int x, int y, unsigned long argb)
 138 {
 139   unsigned char alpha = (argb >> 24) & 0xFF;
 140   if (alpha == 0)
 141     alpha = 0xFF;
 142   [(EmacsImage *)img setPixelAtX: x Y: y toRed: (argb >> 16) & 0xFF
 143    green: (argb >> 8) & 0xFF blue: (argb & 0xFF) alpha: alpha];
 144 }
 145
 146 void
 147 ns_set_alpha (void *img, int x, int y, unsigned char a)
 148 {
 149   [(EmacsImage *)img setAlphaAtX: x Y: y to: a];
 150 }
 151
 152
 153 /* ==========================================================================
 154
 155    Class supporting bitmaps and images of various sorts.
 156
 157    ========================================================================== */
 158
 159 @implementation EmacsImage
 160
 161 static EmacsImage *ImageList = nil;
 162
 163 + allocInitFromFile: (Lisp_Object)file
 164 {
 165   EmacsImage *image = ImageList;
 166   NSImageRep *imgRep;
 167   Lisp_Object found;
 168
 169   /* look for an existing image of the same name */
 170   while (image != nil &&
 171          [[image name] compare: [NSString stringWithUTF8String: SDATA (file)]]
 172              != NSOrderedSame)
 173     image = [image imageListNext];
 174
 175   if (image != nil)
 176     {
 177       [image reference];
 178       return image;
 179     }
 180
 181   /* Search bitmap-file-path for the file, if appropriate.  */
 182   found = x_find_image_file (file);
 183   if (!STRINGP (found))
 184     return nil;
 185
 186   image = [[EmacsImage alloc] initByReferencingFile:
 187                      [NSString stringWithUTF8String: SDATA (found)]];
 188
 189   imgRep = [image bestRepresentationForDevice: nil];
 190   if (imgRep == nil)
 191     {
 192       [image release];
 193       return nil;
 194     }
 195
 196   /* The next two lines cause the DPI of the image to be ignored.
 197      This seems to be the behavior users expect. */
 198   [image setScalesWhenResized: YES];
 199   [image setSize: NSMakeSize([imgRep pixelsWide], [imgRep pixelsHigh])];
 200
 201   [image setName: [NSString stringWithUTF8String: SDATA (file)]];
 202   [image reference];
 203   ImageList = [image imageListSetNext: ImageList];
 204
 205   return image;
 206 }
 207
 208
 209 - reference
 210 {
 211   refCount++;
 212   return self;
 213 }
 214
 215
 216 - imageListSetNext: (id)arg
 217 {
 218   imageListNext = arg;
 219   return self;
 220 }
 221
 222
 223 - imageListNext
 224 {
 225   return imageListNext;
 226 }
 227
 228
 229 - (void)dealloc
 230 {
 231   id list = ImageList;
 232
 233   if (refCount > 1)
 234     {
 235       refCount--;
 236       return;
 237     }
 238
 239   [stippleMask release];
 240
 241   if (list == self)
 242     ImageList = imageListNext;
 243   else
 244     {
 245       while (list != nil && [list imageListNext] != self)
 246         list = [list imageListNext];
 247       [list imageListSetNext: imageListNext];
 248     }
 249
 250   [super dealloc];
 251 }
 252
 253
 254 - initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
 255          flip: (BOOL)flip
 256 {
 257   return [self initFromSkipXBM: bits width: w height: h flip: flip length: 0];
 258 }
 259
 260
 261 - initFromSkipXBM: (unsigned char *)bits width: (int)w height: (int)h
 262              flip: (BOOL)flip length: (int)length;
 263 {
 264   int bpr = (w + 7) / 8;
 265   unsigned char *planes[5];
 266
 267   [self initWithSize: NSMakeSize (w, h)];
 268
 269   bmRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
 270                                     pixelsWide: w pixelsHigh: h
 271                                     bitsPerSample: 8 samplesPerPixel: 4
 272                                     hasAlpha: YES isPlanar: YES
 273                                     colorSpaceName: NSCalibratedRGBColorSpace
 274                                     bytesPerRow: w bitsPerPixel: 0];
 275
 276   [bmRep getBitmapDataPlanes: planes];
 277   {
 278     /* pull bits out to set the (bytewise) alpha mask */
 279     int i, j, k;
 280     unsigned char *s = bits;
 281     unsigned char *alpha = planes[3];
 282     unsigned char swt[16] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13,
 283                              3, 11, 7, 15};
 284     unsigned char c, bitPat;
 285
 286     for (j = 0; j < h; j++)
 287       for (i = 0; i < bpr; i++)
 288         {
 289           if (length)
 290             {
 291               unsigned char s1, s2;
 292               while (*s++ != 'x' && s < bits + length);
 293               if (s >= bits + length)
 294                 {
 295                   [bmRep release];
 296                   return nil;
 297                 }
 298 #define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)
 299               s1 = *s++;
 300               s2 = *s++;
 301               c = hexchar (s1) * 0x10 + hexchar (s2);
 302             }
 303           else
 304             c = *s++;
 305
 306           bitPat = flip ? swt[c >> 4] | (swt[c & 0xf] << 4) : c ^ 255;
 307           for (k =0; k<8; k++)
 308             {
 309               *alpha++ = (bitPat & 0x80) ? 0xff : 0;
 310               bitPat <<= 1;
 311             }
 312         }
 313   }
 314
 315   [self addRepresentation: bmRep];
 316
 317   bzero (planes[0], w*h);
 318   bzero (planes[1], w*h);
 319   bzero (planes[2], w*h);
 320   [self setXBMColor: [NSColor blackColor]];
 321   return self;
 322 }
 323
 324
 325 /* Set color for a bitmap image (see initFromSkipXBM).  Note that the alpha
 326    is used as a mask, so we just memset the entire array. */
 327 - setXBMColor: (NSColor *)color
 328 {
 329   NSSize s = [self size];
 330   int len = (int) s.width * s.height;
 331   unsigned char *planes[5];
 332   float r, g, b, a;
 333   NSColor *rgbColor;
 334
 335   if (bmRep == nil || color == nil)
 336     return;
 337
 338   if ([color colorSpaceName] != NSCalibratedRGBColorSpace)
 339     rgbColor = [color colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
 340   else
 341     rgbColor = color;
 342
 343   [rgbColor getRed: &r green: &g blue: &b alpha: &a];
 344
 345   [bmRep getBitmapDataPlanes: planes];
 346
 347   /* we used to just do this, but Cocoa seems to have a bug when rendering
 348      an alpha-masked image onto a dark background where it bloats the mask */
 349    /* memset (planes[0..2], r, g, b*0xff, len); */
 350   {
 351     int i, len = s.width*s.height;
 352     int rr = r * 0xff, gg = g * 0xff, bb = b * 0xff;
 353     for (i =0; i<len; i++)
 354       if (planes[3][i] != 0)
 355         {
 356           planes[0][i] = rr;
 357           planes[1][i] = gg;
 358           planes[2][i] = bb;
 359         }
 360   }
 361 }
 362
 363
 364 - initForXPMWithDepth: (int)depth width: (int)width height: (int)height
 365 {
 366   NSSize s = {width, height};
 367   int i;
 368
 369   [self initWithSize: s];
 370
 371   bmRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
 372                                   pixelsWide: width pixelsHigh: height
 373                                   /* keep things simple for now */
 374                                   bitsPerSample: 8 samplesPerPixel: 4 /*RGB+A*/
 375                                   hasAlpha: YES isPlanar: YES
 376                                   colorSpaceName: NSCalibratedRGBColorSpace
 377                                   bytesPerRow: width bitsPerPixel: 0];
 378
 379   [bmRep getBitmapDataPlanes: pixmapData];
 380   for (i =0; i<4; i++)
 381     bzero (pixmapData[i], width*height);
 382   [self addRepresentation: bmRep];
 383   return self;
 384 }
 385
 386
 387 /* attempt to pull out pixmap data from a BitmapImageRep; returns NO if fails */
 388 - (void) setPixmapData
 389 {
 390   NSEnumerator *reps;
 391   NSImageRep *rep;
 392
 393   reps = [[self representations] objectEnumerator];
 394   while (rep = (NSImageRep *) [reps nextObject])
 395     {
 396       if ([rep respondsToSelector: @selector (getBitmapDataPlanes:)])
 397         {
 398           bmRep = (NSBitmapImageRep *) rep;
 399           onTiger = [bmRep respondsToSelector: @selector (colorAtX:y:)];
 400
 401           if ([bmRep numberOfPlanes] >= 3)
 402               [bmRep getBitmapDataPlanes: pixmapData];
 403
 404           /* The next two lines cause the DPI of the image to be ignored.
 405              This seems to be the behavior users expect. */
 406           [self setScalesWhenResized: YES];
 407           [self setSize: NSMakeSize([bmRep pixelsWide], [bmRep pixelsHigh])];
 408
 409           break;
 410         }
 411     }
 412 }
 413
 414
 415 /* note; this and next work only for image created with initForXPMWithDepth,
 416          initFromSkipXBM, or where setPixmapData was called successfully */
 417 /* return ARGB */
 418 - (unsigned long) getPixelAtX: (int)x Y: (int)y
 419 {
 420   if (bmRep == nil)
 421     return 0;
 422
 423   /* this method is faster but won't work for bitmaps */
 424   if (pixmapData[0] != NULL)
 425     {
 426       int loc = x + y * [self size].width;
 427       return (pixmapData[3][loc] << 24) /* alpha */
 428        | (pixmapData[0][loc] << 16) | (pixmapData[1][loc] << 8)
 429        | (pixmapData[2][loc]);
 430     }
 431   else if (onTiger)
 432     {
 433       NSColor *color = [bmRep colorAtX: x y: y];
 434       float r, g, b, a;
 435       [color getRed: &r green: &g blue: &b alpha: &a];
 436       return ((int)(a * 255.0) << 24)
 437         | ((int)(r * 255.0) << 16) | ((int)(g * 255.0) << 8)
 438         | ((int)(b * 255.0));
 439
 440     }
 441   return 0;
 442 }
 443
 444 - (void) setPixelAtX: (int)x Y: (int)y toRed: (unsigned char)r
 445                green: (unsigned char)g blue: (unsigned char)b
 446                alpha:(unsigned char)a;
 447 {
 448   if (bmRep == nil)
 449     return;
 450
 451   if (pixmapData[0] != NULL)
 452     {
 453       int loc = x + y * [self size].width;
 454       pixmapData[0][loc] = r;
 455       pixmapData[1][loc] = g;
 456       pixmapData[2][loc] = b;
 457       pixmapData[3][loc] = a;
 458     }
 459   else if (onTiger)
 460     {
 461       [bmRep setColor:
 462                [NSColor colorWithCalibratedRed: (r/255.0) green: (g/255.0)
 463                                           blue: (b/255.0) alpha: (a/255.0)]
 464                   atX: x y: y];
 465     }
 466 }
 467
 468 - (void) setAlphaAtX: (int) x Y: (int) y to: (unsigned char) a
 469 {
 470   if (bmRep == nil)
 471     return;
 472
 473   if (pixmapData[0] != NULL)
 474     {
 475       int loc = x + y * [self size].width;
 476
 477       pixmapData[3][loc] = a;
 478     }
 479   else if (onTiger)
 480     {
 481       NSColor *color = [bmRep colorAtX: x y: y];
 482       color = [color colorWithAlphaComponent: (a / 255.0)];
 483       [bmRep setColor: color atX: x y: y];
 484     }
 485 }
 486
 487 /* returns a pattern color, which is cached here */
 488 - (NSColor *)stippleMask
 489 {
 490   if (stippleMask == nil)
 491       stippleMask = [[NSColor colorWithPatternImage: self] retain];
 492   return stippleMask;
 493 }
 494
 495 @end
 496
 497 // arch-tag: 6b310280-6892-4e5e-8f34-41c4d384874f