Fix typos.
[emacs.git] / src / nsimage.m
blob2cb0c3bff76fa0213cd301c4d5141e4d8395d60f
1 /* Image support for the NeXT/Open/GNUstep and MacOSX window system.
2    Copyright (C) 1989, 1992-1994, 2005-2006, 2008-2011
3      Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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.
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.
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/>.  */
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)
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 #include <setjmp.h>
33 #include "lisp.h"
34 #include "dispextern.h"
35 #include "nsterm.h"
36 #include "frame.h"
38 extern Lisp_Object QCfile, QCdata;
40 /* call tracing */
41 #if 0
42 int image_trace_num = 0;
43 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",         \
44                                 __FILE__, __LINE__, ++image_trace_num)
45 #else
46 #define NSTRACE(x)
47 #endif
50 /* ==========================================================================
52    C interface.  This allows easy calling from C files.  We could just
53    compile everything as Objective-C, but that might mean slower
54    compilation and possible difficulties on some platforms..
56    ========================================================================== */
58 void *
59 ns_image_from_XBM (unsigned char *bits, int width, int height)
61   NSTRACE (ns_image_from_XBM);
62   return [[EmacsImage alloc] initFromXBM: bits
63                                    width: width height: height
64                                     flip: YES];
67 void *
68 ns_image_for_XPM (int width, int height, int depth)
70   NSTRACE (ns_image_for_XPM);
71   return [[EmacsImage alloc] initForXPMWithDepth: depth
72                                            width: width height: height];
75 void *
76 ns_image_from_file (Lisp_Object file)
78   NSTRACE (ns_image_from_bitmap_file);
79   return [EmacsImage allocInitFromFile: file];
82 int
83 ns_load_image (struct frame *f, struct image *img,
84                Lisp_Object spec_file, Lisp_Object spec_data)
86   EmacsImage *eImg = nil;
87   NSSize size;
89   NSTRACE (ns_load_image);
91   if (STRINGP (spec_file))
92     {
93       eImg = [EmacsImage allocInitFromFile: spec_file];
94     }
95   else if (STRINGP (spec_data))
96     {
97       NSData *data;
99       data = [NSData dataWithBytes: SDATA (spec_data)
100                             length: SBYTES (spec_data)];
101       eImg = [[EmacsImage alloc] initWithData: data];
102       [eImg setPixmapData];
103     }
105   if (eImg == nil)
106     {
107       add_to_log ("Unable to load image %s", img->spec, Qnil);
108       return 0;
109     }
111   size = [eImg size];
112   img->width = size.width;
113   img->height = size.height;
115   /* 4) set img->pixmap = emacsimage */
116   img->pixmap = eImg;
117   return 1;
122 ns_image_width (void *img)
124   return [(id)img size].width;
128 ns_image_height (void *img)
130   return [(id)img size].height;
133 unsigned long
134 ns_get_pixel (void *img, int x, int y)
136   return [(EmacsImage *)img getPixelAtX: x Y: y];
139 void
140 ns_put_pixel (void *img, int x, int y, unsigned long argb)
142   unsigned char alpha = (argb >> 24) & 0xFF;
143   if (alpha == 0)
144     alpha = 0xFF;
145   [(EmacsImage *)img setPixelAtX: x Y: y toRed: (argb >> 16) & 0xFF
146    green: (argb >> 8) & 0xFF blue: (argb & 0xFF) alpha: alpha];
149 void
150 ns_set_alpha (void *img, int x, int y, unsigned char a)
152   [(EmacsImage *)img setAlphaAtX: x Y: y to: a];
156 /* ==========================================================================
158    Class supporting bitmaps and images of various sorts.
160    ========================================================================== */
162 @implementation EmacsImage
164 static EmacsImage *ImageList = nil;
166 + allocInitFromFile: (Lisp_Object)file
168   EmacsImage *image = ImageList;
169   NSImageRep *imgRep;
170   Lisp_Object found;
172   /* look for an existing image of the same name */
173   while (image != nil &&
174          [[image name] compare: [NSString stringWithUTF8String: SDATA (file)]]
175              != NSOrderedSame)
176     image = [image imageListNext];
178   if (image != nil)
179     {
180       [image reference];
181       return image;
182     }
184   /* Search bitmap-file-path for the file, if appropriate.  */
185   found = x_find_image_file (file);
186   if (!STRINGP (found))
187     return nil;
189   image = [[EmacsImage alloc] initByReferencingFile:
190                      [NSString stringWithUTF8String: SDATA (found)]];
192 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
193   imgRep = [NSBitmapImageRep imageRepWithData:[image TIFFRepresentation]];
194 #else
195   imgRep = [image bestRepresentationForDevice: nil];
196 #endif
197   if (imgRep == nil)
198     {
199       [image release];
200       return nil;
201     }
203   /* The next two lines cause the DPI of the image to be ignored.
204      This seems to be the behavior users expect. */
205   [image setScalesWhenResized: YES];
206   [image setSize: NSMakeSize([imgRep pixelsWide], [imgRep pixelsHigh])];
208   [image setName: [NSString stringWithUTF8String: SDATA (file)]];
209   [image reference];
210   ImageList = [image imageListSetNext: ImageList];
212   return image;
216 - reference
218   refCount++;
219   return self;
223 - imageListSetNext: (id)arg
225   imageListNext = arg;
226   return self;
230 - imageListNext
232   return imageListNext;
236 - (void)dealloc
238   id list = ImageList;
240   if (refCount > 1)
241     {
242       refCount--;
243       return;
244     }
246   [stippleMask release];
248   if (list == self)
249     ImageList = imageListNext;
250   else
251     {
252       while (list != nil && [list imageListNext] != self)
253         list = [list imageListNext];
254       [list imageListSetNext: imageListNext];
255     }
257   [super dealloc];
261 - initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
262          flip: (BOOL)flip
264   return [self initFromSkipXBM: bits width: w height: h flip: flip length: 0];
268 - initFromSkipXBM: (unsigned char *)bits width: (int)w height: (int)h
269              flip: (BOOL)flip length: (int)length;
271   int bpr = (w + 7) / 8;
272   unsigned char *planes[5];
274   [self initWithSize: NSMakeSize (w, h)];
276   bmRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
277                                     pixelsWide: w pixelsHigh: h
278                                     bitsPerSample: 8 samplesPerPixel: 4
279                                     hasAlpha: YES isPlanar: YES
280                                     colorSpaceName: NSCalibratedRGBColorSpace
281                                     bytesPerRow: w bitsPerPixel: 0];
283   [bmRep getBitmapDataPlanes: planes];
284   {
285     /* pull bits out to set the (bytewise) alpha mask */
286     int i, j, k;
287     unsigned char *s = bits;
288     unsigned char *alpha = planes[3];
289     unsigned char swt[16] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13,
290                              3, 11, 7, 15};
291     unsigned char c, bitPat;
293     for (j = 0; j < h; j++)
294       for (i = 0; i < bpr; i++)
295         {
296           if (length)
297             {
298               unsigned char s1, s2;
299               while (*s++ != 'x' && s < bits + length);
300               if (s >= bits + length)
301                 {
302                   [bmRep release];
303                   return nil;
304                 }
305 #define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)
306               s1 = *s++;
307               s2 = *s++;
308               c = hexchar (s1) * 0x10 + hexchar (s2);
309             }
310           else
311             c = *s++;
313           bitPat = flip ? swt[c >> 4] | (swt[c & 0xf] << 4) : c ^ 255;
314           for (k =0; k<8; k++)
315             {
316               *alpha++ = (bitPat & 0x80) ? 0xff : 0;
317               bitPat <<= 1;
318             }
319         }
320   }
322   [self addRepresentation: bmRep];
324   memset (planes[0], 0, w*h);
325   memset (planes[1], 0, w*h);
326   memset (planes[2], 0, w*h);
327   [self setXBMColor: [NSColor blackColor]];
328   return self;
332 /* Set color for a bitmap image (see initFromSkipXBM).  Note that the alpha
333    is used as a mask, so we just memset the entire array. */
334 - setXBMColor: (NSColor *)color
336   NSSize s = [self size];
337   int len = (int) s.width * s.height;
338   unsigned char *planes[5];
339   CGFloat r, g, b, a;
340   NSColor *rgbColor;
342   if (bmRep == nil || color == nil)
343     return self;
345   if ([color colorSpaceName] != NSCalibratedRGBColorSpace)
346     rgbColor = [color colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
347   else
348     rgbColor = color;
350   [rgbColor getRed: &r green: &g blue: &b alpha: &a];
352   [bmRep getBitmapDataPlanes: planes];
354   /* we used to just do this, but Cocoa seems to have a bug when rendering
355      an alpha-masked image onto a dark background where it bloats the mask */
356    /* memset (planes[0..2], r, g, b*0xff, len); */
357   {
358     int i, len = s.width*s.height;
359     int rr = r * 0xff, gg = g * 0xff, bb = b * 0xff;
360     for (i =0; i<len; i++)
361       if (planes[3][i] != 0)
362         {
363           planes[0][i] = rr;
364           planes[1][i] = gg;
365           planes[2][i] = bb;
366         }
367   }
369   return self;
373 - initForXPMWithDepth: (int)depth width: (int)width height: (int)height
375   NSSize s = {width, height};
376   int i;
378   [self initWithSize: s];
380   bmRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes: NULL
381                                   pixelsWide: width pixelsHigh: height
382                                   /* keep things simple for now */
383                                   bitsPerSample: 8 samplesPerPixel: 4 /*RGB+A*/
384                                   hasAlpha: YES isPlanar: YES
385                                   colorSpaceName: NSCalibratedRGBColorSpace
386                                   bytesPerRow: width bitsPerPixel: 0];
388   [bmRep getBitmapDataPlanes: pixmapData];
389   for (i =0; i<4; i++)
390     memset (pixmapData[i], 0, width*height);
391   [self addRepresentation: bmRep];
392   return self;
396 /* attempt to pull out pixmap data from a BitmapImageRep; returns NO if fails */
397 - (void) setPixmapData
399   NSEnumerator *reps;
400   NSImageRep *rep;
402   reps = [[self representations] objectEnumerator];
403   while (rep = (NSImageRep *) [reps nextObject])
404     {
405       if ([rep respondsToSelector: @selector (getBitmapDataPlanes:)])
406         {
407           bmRep = (NSBitmapImageRep *) rep;
408           onTiger = [bmRep respondsToSelector: @selector (colorAtX:y:)];
410           if ([bmRep numberOfPlanes] >= 3)
411               [bmRep getBitmapDataPlanes: pixmapData];
413           /* The next two lines cause the DPI of the image to be ignored.
414              This seems to be the behavior users expect. */
415           [self setScalesWhenResized: YES];
416           [self setSize: NSMakeSize([bmRep pixelsWide], [bmRep pixelsHigh])];
418           break;
419         }
420     }
424 /* note; this and next work only for image created with initForXPMWithDepth,
425          initFromSkipXBM, or where setPixmapData was called successfully */
426 /* return ARGB */
427 - (unsigned long) getPixelAtX: (int)x Y: (int)y
429   if (bmRep == nil)
430     return 0;
432   /* this method is faster but won't work for bitmaps */
433   if (pixmapData[0] != NULL)
434     {
435       int loc = x + y * [self size].width;
436       return (pixmapData[3][loc] << 24) /* alpha */
437        | (pixmapData[0][loc] << 16) | (pixmapData[1][loc] << 8)
438        | (pixmapData[2][loc]);
439     }
440   else if (onTiger)
441     {
442       NSColor *color = [bmRep colorAtX: x y: y];
443       CGFloat r, g, b, a;
444       [color getRed: &r green: &g blue: &b alpha: &a];
445       return ((int)(a * 255.0) << 24)
446         | ((int)(r * 255.0) << 16) | ((int)(g * 255.0) << 8)
447         | ((int)(b * 255.0));
449     }
450   return 0;
453 - (void) setPixelAtX: (int)x Y: (int)y toRed: (unsigned char)r
454                green: (unsigned char)g blue: (unsigned char)b
455                alpha:(unsigned char)a;
457   if (bmRep == nil)
458     return;
460   if (pixmapData[0] != NULL)
461     {
462       int loc = x + y * [self size].width;
463       pixmapData[0][loc] = r;
464       pixmapData[1][loc] = g;
465       pixmapData[2][loc] = b;
466       pixmapData[3][loc] = a;
467     }
468   else if (onTiger)
469     {
470       [bmRep setColor:
471                [NSColor colorWithCalibratedRed: (r/255.0) green: (g/255.0)
472                                           blue: (b/255.0) alpha: (a/255.0)]
473                   atX: x y: y];
474     }
477 - (void) setAlphaAtX: (int) x Y: (int) y to: (unsigned char) a
479   if (bmRep == nil)
480     return;
482   if (pixmapData[0] != NULL)
483     {
484       int loc = x + y * [self size].width;
486       pixmapData[3][loc] = a;
487     }
488   else if (onTiger)
489     {
490       NSColor *color = [bmRep colorAtX: x y: y];
491       color = [color colorWithAlphaComponent: (a / 255.0)];
492       [bmRep setColor: color atX: x y: y];
493     }
496 /* returns a pattern color, which is cached here */
497 - (NSColor *)stippleMask
499   if (stippleMask == nil)
500       stippleMask = [[NSColor colorWithPatternImage: self] retain];
501   return stippleMask;
504 @end