]> git.saurik.com Git - wxWidgets.git/blob - src/mac/xpm/create.c
wxMSW update for CW, wxMac updated
[wxWidgets.git] / src / mac / xpm / create.c
1 /*
2 * Copyright (C) 1989-95 GROUPE BULL
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to
6 * deal in the Software without restriction, including without limitation the
7 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8 * sell copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 *
21 * Except as contained in this notice, the name of GROUPE BULL shall not be
22 * used in advertising or otherwise to promote the sale, use or other dealings
23 * in this Software without prior written authorization from GROUPE BULL.
24 */
25
26 /*****************************************************************************\
27 * create.c: *
28 * *
29 * XPM library *
30 * Create an X image and possibly its related shape mask *
31 * from the given XpmImage. *
32 * *
33 * Developed by Arnaud Le Hors *
34 \*****************************************************************************/
35
36 /*
37 * The code related to FOR_MSW has been added by
38 * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
39 */
40
41 /*
42 * The code related to AMIGA has been added by
43 * Lorens Younes (d93-hyo@nada.kth.se) 4/96
44 */
45
46 #include "xpmi.h"
47 #include <ctype.h>
48
49 LFUNC(xpmVisualType, int, (Visual *visual));
50
51 LFUNC(AllocColor, int, (Display *display, Colormap colormap,
52 char *colorname, XColor *xcolor, void *closure));
53 LFUNC(FreeColors, int, (Display *display, Colormap colormap,
54 Pixel *pixels, int n, void *closure));
55
56 LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,
57 char *colorname, unsigned int color_index,
58 Pixel *image_pixel, Pixel *mask_pixel,
59 unsigned int *mask_pixel_index,
60 Pixel *alloc_pixels, unsigned int *nalloc_pixels,
61 Pixel *used_pixels, unsigned int *nused_pixels,
62 XpmAttributes *attributes, XColor *cols, int ncols,
63 XpmAllocColorFunc allocColor, void *closure));
64
65 LFUNC(CreateXImage, int, (Display *display, Visual *visual,
66 unsigned int depth, int format, unsigned int width,
67 unsigned int height, XImage **image_return));
68
69 LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,
70 XpmColor *colors, unsigned int ncolors,
71 Pixel *image_pixels, Pixel *mask_pixels,
72 unsigned int *mask_pixel_index,
73 Pixel *alloc_pixels, unsigned int *nalloc_pixels,
74 Pixel *used_pixels, unsigned int *nused_pixels));
75
76 LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width,
77 unsigned int height, unsigned int ncolors,
78 unsigned int cpp, XpmColor *colorTable,
79 xpmHashTable *hashtable,
80 XImage *image, Pixel *image_pixels,
81 XImage *mask, Pixel *mask_pixels));
82
83 LFUNC(PlatformPutImagePixels, void, (Display *dc, XImage *image,
84 unsigned int width, unsigned int height,
85 unsigned int *pixelindex, Pixel *pixels));
86
87
88 #ifdef NEED_STRCASECMP
89 FUNC(xpmstrcasecmp, int, (char *s1, char *s2));
90
91 /*
92 * in case strcasecmp is not provided by the system here is one
93 * which does the trick
94 */
95 int
96 xpmstrcasecmp(s1, s2)
97 register char *s1, *s2;
98 {
99 register int c1, c2;
100
101 while (*s1 && *s2) {
102 c1 = tolower(*s1);
103 c2 = tolower(*s2);
104 if (c1 != c2)
105 return (c1 - c2);
106 s1++;
107 s2++;
108 }
109 return (int) (*s1 - *s2);
110 }
111
112 #endif
113
114 /*
115 * return the default color key related to the given visual
116 */
117 static int
118 xpmVisualType(visual)
119 Visual *visual;
120 {
121 return (XPM_COLOR);
122 }
123
124
125 typedef struct {
126 int cols_index;
127 long closeness;
128 } CloseColor;
129
130 static int
131 closeness_cmp(a, b)
132 Const void *a, *b;
133 {
134 CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;
135
136 /* cast to int as qsort requires */
137 return (int) (x->closeness - y->closeness);
138 }
139
140
141 /* default AllocColor function:
142 * call XParseColor if colorname is given, return negative value if failure
143 * call XAllocColor and return 0 if failure, positive otherwise
144 */
145 static int
146 AllocColor(display, colormap, colorname, xcolor, closure)
147 Display *display;
148 Colormap colormap;
149 char *colorname;
150 XColor *xcolor;
151 void *closure; /* not used */
152 {
153 int status;
154 if (colorname)
155 if (!XParseColor(display, colormap, colorname, xcolor))
156 return -1;
157 status = XAllocColor(display, colormap, xcolor);
158 return status != 0 ? 1 : 0;
159 }
160
161 /*
162 * set the color pixel related to the given colorname,
163 * return 0 if success, 1 otherwise.
164 */
165
166 static int
167 SetColor(display, colormap, visual, colorname, color_index,
168 image_pixel, mask_pixel, mask_pixel_index,
169 alloc_pixels, nalloc_pixels, used_pixels, nused_pixels,
170 attributes, cols, ncols, allocColor, closure)
171 Display *display;
172 Colormap colormap;
173 Visual *visual;
174 char *colorname;
175 unsigned int color_index;
176 Pixel *image_pixel, *mask_pixel;
177 unsigned int *mask_pixel_index;
178 Pixel *alloc_pixels;
179 unsigned int *nalloc_pixels;
180 Pixel *used_pixels;
181 unsigned int *nused_pixels;
182 XpmAttributes *attributes;
183 XColor *cols;
184 int ncols;
185 XpmAllocColorFunc allocColor;
186 void *closure;
187 {
188 XColor xcolor;
189 int status;
190
191 if (xpmstrcasecmp(colorname, TRANSPARENT_COLOR))
192 {
193 status = (*allocColor)(display, colormap, colorname, &xcolor, closure);
194 if (status < 0) /* parse color failed */
195 return (1);
196
197 if (status == 0) {
198 return (1);
199 } else
200 alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel;
201 *image_pixel = xcolor.pixel;
202
203 SET_ZERO_PIXEL( *mask_pixel );
204
205 used_pixels[(*nused_pixels)++] = xcolor.pixel;
206 }
207 else
208 {
209 // this is a special for mac - we have to get white as background for transparency
210 #ifdef macintosh
211 SET_WHITE_PIXEL( *image_pixel) ;
212 #else
213 SET_ZERO_PIXEL( *image_pixel);
214 #endif
215 SET_WHITE_PIXEL( *mask_pixel) ;
216
217 /* store the color table index */
218 *mask_pixel_index = color_index;
219 }
220 return (0);
221 }
222
223
224 static int
225 CreateColors(display, attributes, colors, ncolors, image_pixels, mask_pixels,
226 mask_pixel_index, alloc_pixels, nalloc_pixels,
227 used_pixels, nused_pixels)
228 Display *display;
229 XpmAttributes *attributes;
230 XpmColor *colors;
231 unsigned int ncolors;
232 Pixel *image_pixels;
233 Pixel *mask_pixels;
234 unsigned int *mask_pixel_index;
235 Pixel *alloc_pixels;
236 unsigned int *nalloc_pixels;
237 Pixel *used_pixels;
238 unsigned int *nused_pixels;
239 {
240 /* variables stored in the XpmAttributes structure */
241 Visual *visual;
242 Colormap colormap;
243 XpmColorSymbol *colorsymbols;
244 unsigned int numsymbols;
245 XpmAllocColorFunc allocColor;
246 void *closure;
247
248 char *colorname;
249 unsigned int color, key;
250 Bool pixel_defined;
251 XpmColorSymbol *symbol;
252 char **defaults;
253 int ErrorStatus = XpmSuccess;
254 char *s;
255 int default_index;
256
257 XColor *cols = NULL;
258 unsigned int ncols = 0;
259
260 /*
261 * retrieve information from the XpmAttributes
262 */
263 if (attributes && attributes->valuemask & XpmColorSymbols) {
264 colorsymbols = attributes->colorsymbols;
265 numsymbols = attributes->numsymbols;
266 } else
267 numsymbols = 0;
268
269 if (attributes && attributes->valuemask & XpmVisual)
270 visual = attributes->visual;
271 else
272 visual = XDefaultVisual(display, XDefaultScreen(display));
273
274 if (attributes && (attributes->valuemask & XpmColormap))
275 colormap = attributes->colormap;
276 else
277 colormap = XDefaultColormap(display, XDefaultScreen(display));
278
279 if (attributes && (attributes->valuemask & XpmColorKey))
280 key = attributes->color_key;
281 else
282 key = xpmVisualType(visual);
283
284 if (attributes && (attributes->valuemask & XpmAllocColor))
285 allocColor = attributes->alloc_color;
286 else
287 allocColor = AllocColor;
288 if (attributes && (attributes->valuemask & XpmColorClosure))
289 closure = attributes->color_closure;
290 else
291 closure = NULL;
292
293 switch (key) {
294 case XPM_MONO:
295 default_index = 2;
296 break;
297 case XPM_GRAY4:
298 default_index = 3;
299 break;
300 case XPM_GRAY:
301 default_index = 4;
302 break;
303 case XPM_COLOR:
304 default:
305 default_index = 5;
306 break;
307 }
308
309 for (color = 0; color < ncolors; color++, colors++,
310 image_pixels++, mask_pixels++) {
311 colorname = NULL;
312 pixel_defined = False;
313 defaults = (char **) colors;
314
315 /*
316 * look for a defined symbol
317 */
318 if (numsymbols) {
319
320 unsigned int n;
321
322 s = defaults[1];
323 for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) {
324 if (symbol->name && s && !strcmp(symbol->name, s))
325 /* override name */
326 break;
327 if (!symbol->name && symbol->value) { /* override value */
328 int def_index = default_index;
329
330 while (defaults[def_index] == NULL) /* find defined
331 * colorname */
332 --def_index;
333 if (def_index < 2) {/* nothing towards mono, so try
334 * towards color */
335 def_index = default_index + 1;
336 while (def_index <= 5 && defaults[def_index] == NULL)
337 ++def_index;
338 }
339 if (def_index >= 2 && defaults[def_index] != NULL &&
340 !xpmstrcasecmp(symbol->value, defaults[def_index]))
341 break;
342 }
343 }
344 if (n != numsymbols) {
345 if (symbol->name && symbol->value)
346 colorname = symbol->value;
347 else
348 pixel_defined = True;
349 }
350 }
351 if (!pixel_defined) { /* pixel not given as symbol value */
352
353 unsigned int k;
354
355 if (colorname) { /* colorname given as symbol value */
356 if (!SetColor(display, colormap, visual, colorname, color,
357 image_pixels, mask_pixels, mask_pixel_index,
358 alloc_pixels, nalloc_pixels, used_pixels,
359 nused_pixels, attributes, cols, ncols,
360 allocColor, closure))
361 pixel_defined = True;
362 else
363 ErrorStatus = XpmColorError;
364 }
365 k = key;
366 while (!pixel_defined && k > 1) {
367 if (defaults[k]) {
368 if (!SetColor(display, colormap, visual, defaults[k],
369 color, image_pixels, mask_pixels,
370 mask_pixel_index, alloc_pixels,
371 nalloc_pixels, used_pixels, nused_pixels,
372 attributes, cols, ncols,
373 allocColor, closure)) {
374 pixel_defined = True;
375 break;
376 } else
377 ErrorStatus = XpmColorError;
378 }
379 k--;
380 }
381 k = key + 1;
382 while (!pixel_defined && k < NKEYS + 1) {
383 if (defaults[k]) {
384 if (!SetColor(display, colormap, visual, defaults[k],
385 color, image_pixels, mask_pixels,
386 mask_pixel_index, alloc_pixels,
387 nalloc_pixels, used_pixels, nused_pixels,
388 attributes, cols, ncols,
389 allocColor, closure)) {
390 pixel_defined = True;
391 break;
392 } else
393 ErrorStatus = XpmColorError;
394 }
395 k++;
396 }
397 if (!pixel_defined) {
398 if (cols)
399 XpmFree(cols);
400 return (XpmColorFailed);
401 }
402 } else {
403 /* simply use the given pixel */
404 *image_pixels = symbol->pixel;
405 /* the following makes the mask to be built even if none
406 is given a particular pixel */
407 if (symbol->value
408 && !xpmstrcasecmp(symbol->value, TRANSPARENT_COLOR))
409 {
410 SET_ZERO_PIXEL( *mask_pixels ) ;
411 *mask_pixel_index = color;
412 }
413 else
414 {
415 #ifdef macintosh
416 SET_WHITE_PIXEL( *mask_pixels ) ; // is this correct CS ????
417 #else
418 *mask_pixels = 1; // is this correct CS ????
419 #endif
420 }
421 used_pixels[(*nused_pixels)++] = *image_pixels;
422 }
423 }
424 if (cols)
425 XpmFree(cols);
426 return (ErrorStatus);
427 }
428
429
430 /* default FreeColors function, simply call XFreeColors */
431 static int
432 FreeColors(display, colormap, pixels, n, closure)
433 Display *display;
434 Colormap colormap;
435 Pixel *pixels;
436 int n;
437 void *closure; /* not used */
438 {
439 return XFreeColors(display, colormap, pixels, n, 0);
440 }
441
442
443 /* function call in case of error */
444 #undef RETURN
445 #define RETURN(status) \
446 { \
447 ErrorStatus = status; \
448 goto error; \
449 }
450
451 int
452 XpmCreateImageFromXpmImage(display, image,
453 image_return, shapeimage_return, attributes)
454 Display *display;
455 XpmImage *image;
456 XImage **image_return;
457 XImage **shapeimage_return;
458 XpmAttributes *attributes;
459 {
460 /* variables stored in the XpmAttributes structure */
461 Visual *visual;
462 Colormap colormap;
463 unsigned int depth;
464 int bitmap_format;
465 XpmFreeColorsFunc freeColors;
466 void *closure;
467
468 /* variables to return */
469 XImage *ximage = NULL;
470 XImage *shapeimage = NULL;
471 unsigned int mask_pixel_index = XpmUndefPixel;
472 int ErrorStatus;
473
474 /* calculation variables */
475 Pixel *image_pixels = NULL;
476 Pixel *mask_pixels = NULL;
477 Pixel *alloc_pixels = NULL;
478 Pixel *used_pixels = NULL;
479 unsigned int nalloc_pixels = 0;
480 unsigned int nused_pixels = 0;
481
482 /* initialize return values */
483 if (image_return)
484 *image_return = NULL;
485 if (shapeimage_return)
486 *shapeimage_return = NULL;
487
488 /* retrieve information from the XpmAttributes */
489 if (attributes && (attributes->valuemask & XpmVisual))
490 visual = attributes->visual;
491 else
492 visual = XDefaultVisual(display, XDefaultScreen(display));
493
494 if (attributes && (attributes->valuemask & XpmColormap))
495 colormap = attributes->colormap;
496 else
497 colormap = XDefaultColormap(display, XDefaultScreen(display));
498
499 if (attributes && (attributes->valuemask & XpmDepth))
500 depth = attributes->depth;
501 else
502 depth = XDefaultDepth(display, XDefaultScreen(display));
503
504 if (attributes && (attributes->valuemask & XpmBitmapFormat))
505 bitmap_format = attributes->bitmap_format;
506 else
507 bitmap_format = ZPixmap;
508
509 if (attributes && (attributes->valuemask & XpmFreeColors))
510 freeColors = attributes->free_colors;
511 else
512 freeColors = FreeColors;
513 if (attributes && (attributes->valuemask & XpmColorClosure))
514 closure = attributes->color_closure;
515 else
516 closure = NULL;
517
518 ErrorStatus = XpmSuccess;
519
520 /* malloc pixels index tables */
521 image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
522 if (!image_pixels)
523 return (XpmNoMemory);
524
525 mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
526 if (!mask_pixels)
527 RETURN(XpmNoMemory);
528
529 /* maximum of allocated pixels will be the number of colors */
530 alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
531 if (!alloc_pixels)
532 RETURN(XpmNoMemory);
533
534 /* maximum of allocated pixels will be the number of colors */
535 used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
536 if (!used_pixels)
537 RETURN(XpmNoMemory);
538
539 /* get pixel colors, store them in index tables */
540 ErrorStatus = CreateColors(display, attributes, image->colorTable,
541 image->ncolors, image_pixels, mask_pixels,
542 &mask_pixel_index, alloc_pixels, &nalloc_pixels,
543 used_pixels, &nused_pixels);
544
545 if (ErrorStatus != XpmSuccess
546 && (ErrorStatus < 0 || (attributes
547 && (attributes->valuemask & XpmExactColors)
548 && attributes->exactColors)))
549 RETURN(ErrorStatus);
550
551 /* create the ximage */
552 if (image_return) {
553 ErrorStatus = CreateXImage(display, visual, depth,
554 (depth == 1 ? bitmap_format : ZPixmap),
555 image->width, image->height, &ximage);
556 if (ErrorStatus != XpmSuccess)
557 RETURN(ErrorStatus);
558
559 PlatformPutImagePixels(display, ximage, image->width, image->height,
560 image->data, image_pixels);
561
562 }
563 /* create the shape mask image */
564 if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
565 ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
566 image->width, image->height, &shapeimage);
567 if (ErrorStatus != XpmSuccess)
568 RETURN(ErrorStatus);
569
570 PlatformPutImagePixels(display, shapeimage, image->width, image->height,
571 image->data, mask_pixels);
572
573 }
574 XpmFree(image_pixels);
575 XpmFree(mask_pixels);
576
577 /* if requested return used pixels in the XpmAttributes structure */
578 if (attributes && (attributes->valuemask & XpmReturnPixels ||
579 /* 3.2 backward compatibility code */
580 attributes->valuemask & XpmReturnInfos)) {
581 /* end 3.2 bc */
582 attributes->pixels = used_pixels;
583 attributes->npixels = nused_pixels;
584 attributes->mask_pixel = mask_pixel_index;
585 } else
586 XpmFree(used_pixels);
587
588 /* if requested return alloc'ed pixels in the XpmAttributes structure */
589 if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
590 attributes->alloc_pixels = alloc_pixels;
591 attributes->nalloc_pixels = nalloc_pixels;
592 } else
593 XpmFree(alloc_pixels);
594
595 /* return created images */
596 if (image_return)
597 *image_return = ximage;
598 if (shapeimage_return)
599 *shapeimage_return = shapeimage;
600
601 return (ErrorStatus);
602
603 /* exit point in case of error, free only locally allocated variables */
604 error:
605 if (ximage)
606 XDestroyImage(ximage);
607 if (shapeimage)
608 XDestroyImage(shapeimage);
609 if (image_pixels)
610 XpmFree(image_pixels);
611 if (mask_pixels)
612 XpmFree(mask_pixels);
613 if (nalloc_pixels)
614 (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
615 if (alloc_pixels)
616 XpmFree(alloc_pixels);
617 if (used_pixels)
618 XpmFree(used_pixels);
619
620 return (ErrorStatus);
621 }
622
623
624 /*
625 * Create an XImage with its data
626 */
627 static int
628 CreateXImage(display, visual, depth, format, width, height, image_return)
629 Display *display;
630 Visual *visual;
631 unsigned int depth;
632 int format;
633 unsigned int width;
634 unsigned int height;
635 XImage **image_return;
636 {
637 int bitmap_pad;
638
639 /* first get bitmap_pad */
640 if (depth > 16)
641 bitmap_pad = 32;
642 else if (depth > 8)
643 bitmap_pad = 16;
644 else
645 bitmap_pad = 8;
646
647 /* then create the XImage with data = NULL and bytes_per_line = 0 */
648 *image_return = XCreateImage(display, visual, depth, format, 0, 0,
649 width, height, bitmap_pad, 0);
650 if (!*image_return)
651 return (XpmNoMemory);
652
653 /* XCreateImage has done it all */
654
655 return (XpmSuccess);
656 }
657
658 static void
659 PlatformPutImagePixels(dc, image, width, height, pixelindex, pixels)
660 Display *dc;
661 XImage *image;
662 unsigned int width;
663 unsigned int height;
664 unsigned int *pixelindex;
665 Pixel *pixels;
666 {
667
668 #ifdef FOR_MSW
669 unsigned int *data = pixelindex;
670 unsigned int x, y;
671 HBITMAP obm;
672
673 obm = SelectObject(*dc, image->bitmap);
674 for (y = 0; y < height; y++) {
675 for (x = 0; x < width; x++) {
676 SetPixel(*dc, x, y, pixels[*(data++)]); // data is [x+y*width]
677 }
678 }
679 SelectObject(*dc, obm);
680 #elif macintosh
681 GrafPtr origPort ;
682 GDHandle origDevice ;
683
684 unsigned int *data = pixelindex;
685 unsigned int x, y;
686
687 GetGWorld( &origPort , &origDevice ) ;
688 SetGWorld( image->gworldptr , NULL ) ;
689
690 for (y = 0; y < height; y++)
691 {
692 for (x = 0; x < width; x++)
693 {
694 SetCPixel( x, y, &pixels[*(data++)]); // data is [x+y*width]
695 }
696 }
697 SetGWorld( origPort , origDevice ) ;
698 #endif
699 }
700
701 /*
702 * This function parses an Xpm file or data and directly create an XImage
703 */
704 int
705 xpmParseDataAndCreate(display, data, image_return, shapeimage_return,
706 image, info, attributes)
707 Display *display;
708 xpmData *data;
709 XImage **image_return;
710 XImage **shapeimage_return;
711 XpmImage *image;
712 XpmInfo *info;
713 XpmAttributes *attributes;
714 {
715 /* variables stored in the XpmAttributes structure */
716 Visual *visual;
717 Colormap colormap;
718 unsigned int depth;
719 int bitmap_format;
720 XpmFreeColorsFunc freeColors;
721 void *closure;
722
723 /* variables to return */
724 XImage *ximage = NULL;
725 XImage *shapeimage = NULL;
726 unsigned int mask_pixel_index = XpmUndefPixel;
727
728 /* calculation variables */
729 Pixel *image_pixels = NULL;
730 Pixel *mask_pixels = NULL;
731 Pixel *alloc_pixels = NULL;
732 Pixel *used_pixels = NULL;
733 unsigned int nalloc_pixels = 0;
734 unsigned int nused_pixels = 0;
735 unsigned int width, height, ncolors, cpp;
736 unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
737 XpmColor *colorTable = NULL;
738 char *hints_cmt = NULL;
739 char *colors_cmt = NULL;
740 char *pixels_cmt = NULL;
741
742 unsigned int cmts;
743 int ErrorStatus;
744 xpmHashTable hashtable;
745
746
747 /* initialize return values */
748 if (image_return)
749 *image_return = NULL;
750 if (shapeimage_return)
751 *shapeimage_return = NULL;
752
753
754 /* retrieve information from the XpmAttributes */
755 if (attributes && (attributes->valuemask & XpmVisual))
756 visual = attributes->visual;
757 else
758 visual = XDefaultVisual(display, XDefaultScreen(display));
759
760 if (attributes && (attributes->valuemask & XpmColormap))
761 colormap = attributes->colormap;
762 else
763 colormap = XDefaultColormap(display, XDefaultScreen(display));
764
765 if (attributes && (attributes->valuemask & XpmDepth))
766 depth = attributes->depth;
767 else
768 depth = XDefaultDepth(display, XDefaultScreen(display));
769
770 if (attributes && (attributes->valuemask & XpmBitmapFormat))
771 bitmap_format = attributes->bitmap_format;
772 else
773 bitmap_format = ZPixmap;
774
775 if (attributes && (attributes->valuemask & XpmFreeColors))
776 freeColors = attributes->free_colors;
777 else
778 freeColors = FreeColors;
779 if (attributes && (attributes->valuemask & XpmColorClosure))
780 closure = attributes->color_closure;
781 else
782 closure = NULL;
783
784 cmts = info && (info->valuemask & XpmReturnComments);
785
786 /*
787 * parse the header
788 */
789 ErrorStatus = xpmParseHeader(data);
790 if (ErrorStatus != XpmSuccess)
791 return (ErrorStatus);
792
793 /*
794 * read values
795 */
796 ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,
797 &x_hotspot, &y_hotspot, &hotspot,
798 &extensions);
799 if (ErrorStatus != XpmSuccess)
800 return (ErrorStatus);
801
802 /*
803 * store the hints comment line
804 */
805 if (cmts)
806 xpmGetCmt(data, &hints_cmt);
807
808 /*
809 * init the hastable
810 */
811 if (USE_HASHTABLE) {
812 ErrorStatus = xpmHashTableInit(&hashtable);
813 if (ErrorStatus != XpmSuccess)
814 return (ErrorStatus);
815 }
816
817 /*
818 * read colors
819 */
820 ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);
821 if (ErrorStatus != XpmSuccess)
822 RETURN(ErrorStatus);
823
824 /*
825 * store the colors comment line
826 */
827 if (cmts)
828 xpmGetCmt(data, &colors_cmt);
829
830 /* malloc pixels index tables */
831 image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
832 if (!image_pixels)
833 RETURN(XpmNoMemory);
834
835 mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
836 if (!mask_pixels)
837 RETURN(XpmNoMemory);
838
839 /* maximum of allocated pixels will be the number of colors */
840 alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
841 if (!alloc_pixels)
842 RETURN(XpmNoMemory);
843
844 /* maximum of allocated pixels will be the number of colors */
845 used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
846 if (!used_pixels)
847 RETURN(XpmNoMemory);
848
849 /* get pixel colors, store them in index tables */
850 ErrorStatus = CreateColors(display, attributes, colorTable, ncolors,
851 image_pixels, mask_pixels, &mask_pixel_index,
852 alloc_pixels, &nalloc_pixels, used_pixels,
853 &nused_pixels);
854
855 if (ErrorStatus != XpmSuccess
856 && (ErrorStatus < 0 || (attributes
857 && (attributes->valuemask & XpmExactColors)
858 && attributes->exactColors)))
859 RETURN(ErrorStatus);
860
861 /* now create the ximage */
862 if (image_return) {
863 ErrorStatus = CreateXImage(display, visual, depth,
864 (depth == 1 ? bitmap_format : ZPixmap),
865 width, height, &ximage);
866 if (ErrorStatus != XpmSuccess)
867 RETURN(ErrorStatus);
868
869 }
870
871 /* create the shape mask image */
872 if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
873 ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
874 width, height, &shapeimage);
875 if (ErrorStatus != XpmSuccess)
876 RETURN(ErrorStatus);
877
878 }
879
880 /*
881 * read pixels and put them in the XImage
882 */
883 ErrorStatus = ParseAndPutPixels(
884 display,
885 data, width, height, ncolors, cpp,
886 colorTable, &hashtable,
887 ximage, image_pixels,
888 shapeimage, mask_pixels);
889 XpmFree(image_pixels);
890 image_pixels = NULL;
891 XpmFree(mask_pixels);
892 mask_pixels = NULL;
893
894 /*
895 * free the hastable
896 */
897 if (ErrorStatus != XpmSuccess)
898 RETURN(ErrorStatus)
899 else if (USE_HASHTABLE)
900 xpmHashTableFree(&hashtable);
901
902 /*
903 * store the pixels comment line
904 */
905 if (cmts)
906 xpmGetCmt(data, &pixels_cmt);
907
908 /*
909 * parse extensions
910 */
911 if (info && (info->valuemask & XpmReturnExtensions))
912 if (extensions) {
913 ErrorStatus = xpmParseExtensions(data, &info->extensions,
914 &info->nextensions);
915 if (ErrorStatus != XpmSuccess)
916 RETURN(ErrorStatus);
917 } else {
918 info->extensions = NULL;
919 info->nextensions = 0;
920 }
921
922 /*
923 * store found informations in the XpmImage structure
924 */
925 image->width = width;
926 image->height = height;
927 image->cpp = cpp;
928 image->ncolors = ncolors;
929 image->colorTable = colorTable;
930 image->data = NULL;
931
932 if (info) {
933 if (cmts) {
934 info->hints_cmt = hints_cmt;
935 info->colors_cmt = colors_cmt;
936 info->pixels_cmt = pixels_cmt;
937 }
938 if (hotspot) {
939 info->x_hotspot = x_hotspot;
940 info->y_hotspot = y_hotspot;
941 info->valuemask |= XpmHotspot;
942 }
943 }
944 /* if requested return used pixels in the XpmAttributes structure */
945 if (attributes && (attributes->valuemask & XpmReturnPixels ||
946 /* 3.2 backward compatibility code */
947 attributes->valuemask & XpmReturnInfos)) {
948 /* end 3.2 bc */
949 attributes->pixels = used_pixels;
950 attributes->npixels = nused_pixels;
951 attributes->mask_pixel = mask_pixel_index;
952 } else
953 XpmFree(used_pixels);
954
955 /* if requested return alloc'ed pixels in the XpmAttributes structure */
956 if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
957 attributes->alloc_pixels = alloc_pixels;
958 attributes->nalloc_pixels = nalloc_pixels;
959 } else
960 XpmFree(alloc_pixels);
961
962 /* return created images */
963 if (image_return)
964 *image_return = ximage;
965 if (shapeimage_return)
966 *shapeimage_return = shapeimage;
967
968 return (XpmSuccess);
969
970 /* exit point in case of error, free only locally allocated variables */
971 error:
972 if (USE_HASHTABLE)
973 xpmHashTableFree(&hashtable);
974 if (colorTable)
975 xpmFreeColorTable(colorTable, ncolors);
976 if (hints_cmt)
977 XpmFree(hints_cmt);
978 if (colors_cmt)
979 XpmFree(colors_cmt);
980 if (pixels_cmt)
981 XpmFree(pixels_cmt);
982 if (ximage)
983 XDestroyImage(ximage);
984 if (shapeimage)
985 XDestroyImage(shapeimage);
986 if (image_pixels)
987 XpmFree(image_pixels);
988 if (mask_pixels)
989 XpmFree(mask_pixels);
990 if (nalloc_pixels)
991 (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
992 if (alloc_pixels)
993 XpmFree(alloc_pixels);
994 if (used_pixels)
995 XpmFree(used_pixels);
996
997 return (ErrorStatus);
998 }
999
1000 static int
1001 ParseAndPutPixels(
1002 dc,
1003 data, width, height, ncolors, cpp, colorTable, hashtable,
1004 image, image_pixels, shapeimage, shape_pixels)
1005 Display *dc;
1006 xpmData *data;
1007 unsigned int width;
1008 unsigned int height;
1009 unsigned int ncolors;
1010 unsigned int cpp;
1011 XpmColor *colorTable;
1012 xpmHashTable *hashtable;
1013 XImage *image;
1014 Pixel *image_pixels;
1015 XImage *shapeimage;
1016 Pixel *shape_pixels;
1017 {
1018 unsigned int a, x, y;
1019
1020 switch (cpp) {
1021
1022 case (1): /* Optimize for single character
1023 * colors */
1024 {
1025 unsigned short colidx[256];
1026 #ifdef FOR_MSW
1027
1028 HDC shapedc;
1029 HBITMAP obm, sobm;
1030
1031 if ( shapeimage ) {
1032 shapedc = CreateCompatibleDC(*dc);
1033 sobm = SelectObject(shapedc, shapeimage->bitmap);
1034 } else {
1035 shapedc = NULL;
1036 }
1037 obm = SelectObject(*dc, image->bitmap);
1038
1039 #elif macintosh
1040 GrafPtr origPort ;
1041 GDHandle origDevice ;
1042
1043 GetGWorld( &origPort , &origDevice ) ;
1044 // ignore shapedc
1045 SetGWorld( image->gworldptr , NULL ) ;
1046
1047 #endif
1048
1049 bzero((char *)colidx, 256 * sizeof(short));
1050 for (a = 0; a < ncolors; a++)
1051 colidx[(unsigned char)colorTable[a].string[0]] = a + 1;
1052
1053 for (y = 0; y < height; y++)
1054 {
1055 xpmNextString(data);
1056 for (x = 0; x < width; x++)
1057 {
1058 int c = xpmGetC(data);
1059
1060 if (c > 0 && c < 256 && colidx[c] != 0)
1061 {
1062 #if FOR_MSW
1063 SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]);
1064 if (shapedc)
1065 {
1066 SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);
1067 }
1068 #elif macintosh
1069 SetCPixel( x, y, &image_pixels[colidx[c] - 1]);
1070 /*
1071 if (shapedc)
1072 {
1073 SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);
1074 }
1075 */
1076 #endif
1077 }
1078 else
1079 return (XpmFileInvalid);
1080 }
1081 }
1082 #if FOR_MSW
1083 if ( shapedc )
1084 {
1085 SelectObject(shapedc, sobm);
1086 DeleteDC(shapedc);
1087 }
1088 SelectObject(*dc, obm);
1089 #elif macintosh
1090 SetGWorld( origPort , origDevice ) ;
1091 #endif
1092 }
1093 break;
1094
1095 case (2): /* Optimize for double character
1096 * colors */
1097 {
1098
1099 /* free all allocated pointers at all exits */
1100 #define FREE_CIDX {int f; for (f = 0; f < 256; f++) \
1101 if (cidx[f]) XpmFree(cidx[f]);}
1102
1103 /* array of pointers malloced by need */
1104 unsigned short *cidx[256];
1105 int char1;
1106 #ifdef macintosh
1107 GrafPtr origPort ;
1108 GDHandle origDevice ;
1109 GetGWorld( &origPort , &origDevice ) ;
1110 SetGWorld( image->gworldptr , NULL ) ;
1111 #endif
1112 bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */
1113 for (a = 0; a < ncolors; a++) {
1114 char1 = colorTable[a].string[0];
1115 if (cidx[char1] == NULL) { /* get new memory */
1116 cidx[char1] = (unsigned short *)
1117 XpmCalloc(256, sizeof(unsigned short));
1118 if (cidx[char1] == NULL) { /* new block failed */
1119 #ifdef macintosh
1120 SetGWorld( origPort , origDevice ) ;
1121 #endif
1122 FREE_CIDX;
1123 return (XpmNoMemory);
1124 }
1125 }
1126 cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;
1127 }
1128
1129 for (y = 0; y < height; y++) {
1130 xpmNextString(data);
1131 for (x = 0; x < width; x++)
1132 {
1133 int cc1 = xpmGetC(data);
1134 if (cc1 > 0 && cc1 < 256) {
1135 int cc2 = xpmGetC(data);
1136 if (cc2 > 0 && cc2 < 256 &&
1137 cidx[cc1] && cidx[cc1][cc2] != 0) {
1138
1139 #ifdef FOR_MSW
1140 SelectObject(*dc, image->bitmap);
1141 SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]);
1142 if (shapeimage)
1143 {
1144 SelectObject(*dc, shapeimage->bitmap);
1145 SetPixel(*dc, x, y,
1146 shape_pixels[cidx[cc1][cc2] - 1]);
1147 }
1148 #elif macintosh
1149 SetCPixel( x, y, &image_pixels[cidx[cc1][cc2] - 1]);
1150 #endif
1151 } else
1152 {
1153 #ifdef macintosh
1154 SetGWorld( origPort , origDevice ) ;
1155 #endif
1156 FREE_CIDX;
1157 return (XpmFileInvalid);
1158 }
1159 } else {
1160 #ifdef macintosh
1161 SetGWorld( origPort , origDevice ) ;
1162 #endif
1163 FREE_CIDX;
1164 return (XpmFileInvalid);
1165 }
1166 }
1167 }
1168 #ifdef macintosh
1169 SetGWorld( origPort , origDevice ) ;
1170 #endif
1171 FREE_CIDX;
1172 }
1173 break;
1174
1175 default: /* Non-optimized case of long color
1176 * names */
1177 {
1178 char *s;
1179 char buf[BUFSIZ];
1180 #ifdef macintosh
1181 GrafPtr origPort ;
1182 GDHandle origDevice ;
1183 GetGWorld( &origPort , &origDevice ) ;
1184 SetGWorld( image->gworldptr , NULL ) ;
1185 #endif
1186
1187 buf[cpp] = '\0';
1188 if (USE_HASHTABLE) {
1189 xpmHashAtom *slot;
1190
1191 for (y = 0; y < height; y++) {
1192 xpmNextString(data);
1193 for (x = 0; x < width; x++) {
1194 for (a = 0, s = buf; a < cpp; a++, s++)
1195 *s = xpmGetC(data);
1196 slot = xpmHashSlot(hashtable, buf);
1197 if (!*slot) /* no color matches */
1198 {
1199 #ifdef macintosh
1200 SetGWorld( origPort , origDevice ) ;
1201 #endif
1202 return (XpmFileInvalid);
1203 }
1204
1205 #if FOR_MSW
1206 SelectObject(*dc, image->bitmap);
1207 SetPixel(*dc, x, y,
1208 image_pixels[HashColorIndex(slot)]);
1209 if (shapeimage)
1210 {
1211 SelectObject(*dc, shapeimage->bitmap);
1212 SetPixel(*dc, x, y,
1213 shape_pixels[HashColorIndex(slot)]);
1214 }
1215 #elif macintosh
1216 SetCPixel( x, y, &image_pixels[HashColorIndex(slot)]);
1217 #endif
1218 }
1219 }
1220 } else {
1221 for (y = 0; y < height; y++) {
1222 xpmNextString(data);
1223 for (x = 0; x < width; x++) {
1224 for (a = 0, s = buf; a < cpp; a++, s++)
1225 *s = xpmGetC(data);
1226 for (a = 0; a < ncolors; a++)
1227 if (!strcmp(colorTable[a].string, buf))
1228 break;
1229 if (a == ncolors) /* no color matches */
1230 {
1231 #ifdef macintosh
1232 SetGWorld( origPort , origDevice ) ;
1233 #endif
1234 return (XpmFileInvalid);
1235 }
1236
1237 #if FOR_MSW
1238 SelectObject(*dc, image->bitmap);
1239 SetPixel(*dc, x, y, image_pixels[a]);
1240 if (shapeimage) {
1241 SelectObject(*dc, shapeimage->bitmap);
1242 SetPixel(*dc, x, y, shape_pixels[a]);
1243 }
1244 #elif macintosh
1245 SetCPixel( x, y, &image_pixels[a]); // data is [x+y*width]
1246 #endif
1247 }
1248 }
1249 }
1250 #ifdef macintosh
1251 SetGWorld( origPort , origDevice ) ;
1252 #endif
1253
1254 }
1255 break;
1256 }
1257 return (XpmSuccess);
1258 }