]> git.saurik.com Git - wxWidgets.git/blob - src/xpm/create.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use base 10 by default in wxString::To[U]Long
[wxWidgets.git] / src / 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 #ifndef FOR_MSW
57 LFUNC(SetCloseColor, int, (Display *display, Colormap colormap,
58 Visual *visual, XColor *col,
59 Pixel *image_pixel, Pixel *mask_pixel,
60 Pixel *alloc_pixels, unsigned int *nalloc_pixels,
61 XpmAttributes *attributes, XColor *cols, int ncols,
62 XpmAllocColorFunc allocColor, void *closure));
63 #else
64 /* let the window system take care of close colors */
65 #endif
66
67 LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,
68 char *colorname, unsigned int color_index,
69 Pixel *image_pixel, Pixel *mask_pixel,
70 unsigned int *mask_pixel_index,
71 Pixel *alloc_pixels, unsigned int *nalloc_pixels,
72 Pixel *used_pixels, unsigned int *nused_pixels,
73 XpmAttributes *attributes, XColor *cols, int ncols,
74 XpmAllocColorFunc allocColor, void *closure));
75
76 LFUNC(CreateXImage, int, (Display *display, Visual *visual,
77 unsigned int depth, int format, unsigned int width,
78 unsigned int height, XImage **image_return));
79
80 LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,
81 XpmColor *colors, unsigned int ncolors,
82 Pixel *image_pixels, Pixel *mask_pixels,
83 unsigned int *mask_pixel_index,
84 Pixel *alloc_pixels, unsigned int *nalloc_pixels,
85 Pixel *used_pixels, unsigned int *nused_pixels));
86
87 #ifndef FOR_MSW
88 LFUNC(ParseAndPutPixels, int, (xpmData *data, unsigned int width,
89 unsigned int height, unsigned int ncolors,
90 unsigned int cpp, XpmColor *colorTable,
91 xpmHashTable *hashtable,
92 XImage *image, Pixel *image_pixels,
93 XImage *mask, Pixel *mask_pixels));
94 #else /* FOR_MSW */
95 LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width,
96 unsigned int height, unsigned int ncolors,
97 unsigned int cpp, XpmColor *colorTable,
98 xpmHashTable *hashtable,
99 XImage *image, Pixel *image_pixels,
100 XImage *mask, Pixel *mask_pixels));
101 #endif
102
103 #ifndef FOR_MSW
104 # ifndef AMIGA
105 /* XImage pixel routines */
106 LFUNC(PutImagePixels, void, (XImage *image, unsigned int width,
107 unsigned int height, unsigned int *pixelindex,
108 Pixel *pixels));
109
110 LFUNC(PutImagePixels32, void, (XImage *image, unsigned int width,
111 unsigned int height, unsigned int *pixelindex,
112 Pixel *pixels));
113
114 LFUNC(PutImagePixels16, void, (XImage *image, unsigned int width,
115 unsigned int height, unsigned int *pixelindex,
116 Pixel *pixels));
117
118 LFUNC(PutImagePixels8, void, (XImage *image, unsigned int width,
119 unsigned int height, unsigned int *pixelindex,
120 Pixel *pixels));
121
122 LFUNC(PutImagePixels1, void, (XImage *image, unsigned int width,
123 unsigned int height, unsigned int *pixelindex,
124 Pixel *pixels));
125
126 LFUNC(PutPixel1, int, (XImage *ximage, int x, int y, unsigned long pixel));
127 LFUNC(PutPixel, int, (XImage *ximage, int x, int y, unsigned long pixel));
128 LFUNC(PutPixel32, int, (XImage *ximage, int x, int y, unsigned long pixel));
129 LFUNC(PutPixel32MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
130 LFUNC(PutPixel32LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
131 LFUNC(PutPixel16MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
132 LFUNC(PutPixel16LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
133 LFUNC(PutPixel8, int, (XImage *ximage, int x, int y, unsigned long pixel));
134 LFUNC(PutPixel1MSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
135 LFUNC(PutPixel1LSB, int, (XImage *ximage, int x, int y, unsigned long pixel));
136
137 # else /* AMIGA */
138 LFUNC(APutImagePixels, void, (XImage *ximage, unsigned int width,
139 unsigned int height, unsigned int *pixelindex,
140 Pixel *pixels));
141 # endif/* AMIGA */
142 #else /* FOR_MSW */
143 /* FOR_MSW pixel routine */
144 LFUNC(MSWPutImagePixels, void, (Display *dc, XImage *image,
145 unsigned int width, unsigned int height,
146 unsigned int *pixelindex, Pixel *pixels));
147 #endif /* FOR_MSW */
148
149 #ifdef NEED_STRCASECMP
150 FUNC(xpmstrcasecmp, int, (char *s1, char *s2));
151
152 /*
153 * in case strcasecmp is not provided by the system here is one
154 * which does the trick
155 */
156 #ifdef __OS2__
157 /* Visual Age cannot deal with old, non-ansi, code */
158 int xpmstrcasecmp(register char* s1, register char* s2)
159 #else
160 int
161 xpmstrcasecmp(s1, s2)
162 register char *s1, *s2;
163 #endif
164 {
165 register int c1, c2;
166
167 while (*s1 && *s2) {
168 c1 = tolower(*s1);
169 c2 = tolower(*s2);
170 if (c1 != c2)
171 return (c1 - c2);
172 s1++;
173 s2++;
174 }
175 return (int) (*s1 - *s2);
176 }
177
178 #endif
179
180 /*
181 * return the default color key related to the given visual
182 */
183 #ifdef __OS2__
184 /* Visual Age cannot deal with old, non-ansi, code */
185 static int xpmVisualType(Visual* visual)
186 #else
187 static int
188 xpmVisualType(visual)
189 Visual *visual;
190 #endif
191 {
192 #ifndef FOR_MSW
193 # ifndef AMIGA
194 switch (visual->class) {
195 case StaticGray:
196 case GrayScale:
197 switch (visual->map_entries) {
198 case 2:
199 return (XPM_MONO);
200 case 4:
201 return (XPM_GRAY4);
202 default:
203 return (XPM_GRAY);
204 }
205 default:
206 return (XPM_COLOR);
207 }
208 # else
209 /* set the key explicitly in the XpmAttributes to override this */
210 return (XPM_COLOR);
211 # endif
212 #else
213 /* there should be a similar switch for MSW */
214 return (XPM_COLOR);
215 #endif
216 }
217
218
219 typedef struct {
220 int cols_index;
221 long closeness;
222 } CloseColor;
223
224 #ifndef FOR_MSW
225 static int closeness_cmp(Const void* a, Const void* b)
226 {
227 CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b;
228
229 /* cast to int as qsort requires */
230 return (int) (x->closeness - y->closeness);
231 }
232 #endif
233
234
235 /* default AllocColor function:
236 * call XParseColor if colorname is given, return negative value if failure
237 * call XAllocColor and return 0 if failure, positive otherwise
238 */
239 #ifdef __OS2__
240 /* Visual Age cannot deal with old, non-ansi, code */
241 static int
242 AllocColor(
243 Display* display
244 , Colormap colormap
245 , char* colorname
246 , XColor* xcolor
247 , void* closure
248 )
249 #else
250 static int
251 AllocColor(display, colormap, colorname, xcolor, closure)
252 Display *display;
253 Colormap colormap;
254 char *colorname;
255 XColor *xcolor;
256 void *closure; /* not used */
257 #endif
258 {
259 int status;
260 if (colorname)
261 #ifdef __OS2__
262 if (!XParseColor(display, &colormap, colorname, xcolor))
263 return -1;
264 status = XAllocColor(display, &colormap, xcolor);
265 #else
266 if (!XParseColor(display, colormap, colorname, xcolor))
267 return -1;
268 status = XAllocColor(display, colormap, xcolor);
269 #endif
270 return status != 0 ? 1 : 0;
271 }
272
273
274 #ifndef FOR_MSW
275 /*
276 * set a close color in case the exact one can't be set
277 * return 0 if success, 1 otherwise.
278 */
279
280 static int
281 SetCloseColor(display, colormap, visual, col, image_pixel, mask_pixel,
282 alloc_pixels, nalloc_pixels, attributes, cols, ncols,
283 allocColor, closure)
284 Display *display;
285 Colormap colormap;
286 Visual *visual;
287 XColor *col;
288 Pixel *image_pixel, *mask_pixel;
289 Pixel *alloc_pixels;
290 unsigned int *nalloc_pixels;
291 XpmAttributes *attributes;
292 XColor *cols;
293 int ncols;
294 XpmAllocColorFunc allocColor;
295 void *closure;
296 {
297
298 /*
299 * Allocation failed, so try close colors. To get here the visual must
300 * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor?
301 * What about sharing systems like QDSS?). Beware: we have to treat
302 * DirectColor differently.
303 */
304
305
306 long int red_closeness, green_closeness, blue_closeness;
307 int n;
308 Bool alloc_color;
309
310 if (attributes && (attributes->valuemask & XpmCloseness))
311 red_closeness = green_closeness = blue_closeness =
312 attributes->closeness;
313 else {
314 red_closeness = attributes->red_closeness;
315 green_closeness = attributes->green_closeness;
316 blue_closeness = attributes->blue_closeness;
317 }
318 if (attributes && (attributes->valuemask & XpmAllocCloseColors))
319 alloc_color = attributes->alloc_close_colors;
320 else
321 alloc_color = True;
322
323 /*
324 * We sort the colormap by closeness and try to allocate the color
325 * closest to the target. If the allocation of this close color fails,
326 * which almost never happens, then one of two scenarios is possible.
327 * Either the colormap must have changed (since the last close color
328 * allocation or possibly while we were sorting the colormap), or the
329 * color is allocated as Read/Write by some other client. (Note: X
330 * _should_ allow clients to check if a particular color is Read/Write,
331 * but it doesn't! :-( ). We cannot determine which of these scenarios
332 * occurred, so we try the next closest color, and so on, until no more
333 * colors are within closeness of the target. If we knew that the
334 * colormap had changed, we could skip this sequence.
335 *
336 * If _none_ of the colors within closeness of the target can be allocated,
337 * then we can finally be pretty sure that the colormap has actually
338 * changed. In this case we try to allocate the original color (again),
339 * then try the closecolor stuff (again)...
340 *
341 * In theory it would be possible for an infinite loop to occur if another
342 * process kept changing the colormap every time we sorted it, so we set
343 * a maximum on the number of iterations. After this many tries, we use
344 * XGrabServer() to ensure that the colormap remains unchanged.
345 *
346 * This approach gives particularly bad worst case performance - as many as
347 * <MaximumIterations> colormap reads and sorts may be needed, and as
348 * many as <MaximumIterations> * <ColormapSize> attempted allocations
349 * may fail. On an 8-bit system, this means as many as 3 colormap reads,
350 * 3 sorts and 768 failed allocations per execution of this code!
351 * Luckily, my experiments show that in general use in a typical 8-bit
352 * color environment only about 1 in every 10000 allocations fails to
353 * succeed in the fastest possible time. So virtually every time what
354 * actually happens is a single sort followed by a successful allocate.
355 * The very first allocation also costs a colormap read, but no further
356 * reads are usually necessary.
357 */
358
359 #define ITERATIONS 2 /* more than one is almost never
360 * necessary */
361
362 for (n = 0; n <= ITERATIONS; ++n) {
363 CloseColor *closenesses =
364 (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor));
365 int i, c;
366
367 for (i = 0; i < ncols; ++i) { /* build & sort closenesses table */
368 #define COLOR_FACTOR 3
369 #define BRIGHTNESS_FACTOR 1
370
371 closenesses[i].cols_index = i;
372 closenesses[i].closeness =
373 COLOR_FACTOR * (abs((long) col->red - (long) cols[i].red)
374 + abs((long) col->green - (long) cols[i].green)
375 + abs((long) col->blue - (long) cols[i].blue))
376 + BRIGHTNESS_FACTOR * abs(((long) col->red +
377 (long) col->green +
378 (long) col->blue)
379 - ((long) cols[i].red +
380 (long) cols[i].green +
381 (long) cols[i].blue));
382 }
383 qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp);
384
385 i = 0;
386 c = closenesses[i].cols_index;
387 while ((long) cols[c].red >= (long) col->red - red_closeness &&
388 (long) cols[c].red <= (long) col->red + red_closeness &&
389 (long) cols[c].green >= (long) col->green - green_closeness &&
390 (long) cols[c].green <= (long) col->green + green_closeness &&
391 (long) cols[c].blue >= (long) col->blue - blue_closeness &&
392 (long) cols[c].blue <= (long) col->blue + blue_closeness) {
393 if (alloc_color) {
394 if ((*allocColor)(display, colormap, NULL, &cols[c], closure)){
395 if (n == ITERATIONS)
396 XUngrabServer(display);
397 XpmFree(closenesses);
398 *image_pixel = cols[c].pixel;
399 *mask_pixel = 1;
400 alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel;
401 return (0);
402 } else {
403 ++i;
404 if (i == ncols)
405 break;
406 c = closenesses[i].cols_index;
407 }
408 } else {
409 if (n == ITERATIONS)
410 XUngrabServer(display);
411 XpmFree(closenesses);
412 *image_pixel = cols[c].pixel;
413 *mask_pixel = 1;
414 return (0);
415 }
416 }
417
418 /* Couldn't allocate _any_ of the close colors! */
419
420 if (n == ITERATIONS)
421 XUngrabServer(display);
422 XpmFree(closenesses);
423
424 if (i == 0 || i == ncols) /* no color close enough or cannot */
425 return (1); /* alloc any color (full of r/w's) */
426
427 if ((*allocColor)(display, colormap, NULL, col, closure)) {
428 *image_pixel = col->pixel;
429 *mask_pixel = 1;
430 alloc_pixels[(*nalloc_pixels)++] = col->pixel;
431 return (0);
432 } else { /* colormap has probably changed, so
433 * re-read... */
434 if (n == ITERATIONS - 1)
435 XGrabServer(display);
436
437 #if 0
438 if (visual->class == DirectColor) {
439 /* TODO */
440 } else
441 #endif
442 XQueryColors(display, colormap, cols, ncols);
443 }
444 }
445 return (1);
446 }
447
448 #define USE_CLOSECOLOR attributes && \
449 (((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \
450 || ((attributes->valuemask & XpmRGBCloseness) && \
451 (attributes->red_closeness != 0 \
452 || attributes->green_closeness != 0 \
453 || attributes->blue_closeness != 0)))
454
455 #else
456 /* FOR_MSW part */
457 /* nothing to do here, the window system does it */
458 #endif
459
460 /*
461 * set the color pixel related to the given colorname,
462 * return 0 if success, 1 otherwise.
463 */
464
465 #ifdef __OS2__
466 /* Visual Age cannot deal with old, non-ansi, code */
467 static int
468 SetColor(
469 Display* display
470 , Colormap colormap
471 , Visual* visual
472 , char* colorname
473 , unsigned int color_index
474 , Pixel* image_pixel
475 , Pixel* mask_pixel
476 , unsigned int* mask_pixel_index
477 , Pixel* alloc_pixels
478 , unsigned int* nalloc_pixels
479 , Pixel* used_pixels
480 , unsigned int* nused_pixels
481 , XpmAttributes* attributes
482 , XColor* cols
483 , int ncols
484 , XpmAllocColorFunc allocColor
485 , void* closure
486 )
487 #else
488 static int
489 SetColor(display, colormap, visual, colorname, color_index,
490 image_pixel, mask_pixel, mask_pixel_index,
491 alloc_pixels, nalloc_pixels, used_pixels, nused_pixels,
492 attributes, cols, ncols, allocColor, closure)
493 Display *display;
494 Colormap colormap;
495 Visual *visual;
496 char *colorname;
497 unsigned int color_index;
498 Pixel *image_pixel, *mask_pixel;
499 unsigned int *mask_pixel_index;
500 Pixel *alloc_pixels;
501 unsigned int *nalloc_pixels;
502 Pixel *used_pixels;
503 unsigned int *nused_pixels;
504 XpmAttributes *attributes;
505 XColor *cols;
506 int ncols;
507 XpmAllocColorFunc allocColor;
508 void *closure;
509 #endif
510 {
511 XColor xcolor;
512 int status;
513
514 if (xpmstrcasecmp(colorname, TRANSPARENT_COLOR)) {
515 status = (*allocColor)(display, colormap, colorname, &xcolor, closure);
516 if (status < 0) /* parse color failed */
517 return (1);
518
519 if (status == 0) {
520 #ifndef FOR_MSW
521 if (USE_CLOSECOLOR)
522 return (SetCloseColor(display, colormap, visual, &xcolor,
523 image_pixel, mask_pixel,
524 alloc_pixels, nalloc_pixels,
525 attributes, cols, ncols,
526 allocColor, closure));
527 else
528 #endif /* ndef FOR_MSW */
529 return (1);
530 } else
531 alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel;
532 *image_pixel = xcolor.pixel;
533 #ifndef FOR_MSW
534 *mask_pixel = 1;
535 #else
536 #ifdef __OS2__
537 *mask_pixel = OS2RGB(0,0,0);
538 #else
539 *mask_pixel = RGB(0,0,0);
540 #endif
541 #endif
542 used_pixels[(*nused_pixels)++] = xcolor.pixel;
543 } else {
544 *image_pixel = 0;
545 #ifndef FOR_MSW
546 *mask_pixel = 0;
547 #else
548 #ifdef __OS2__
549 *mask_pixel = OS2RGB(255,255,255);
550 #else
551 *mask_pixel = RGB(255,255,255);
552 #endif
553 #endif
554 /* store the color table index */
555 *mask_pixel_index = color_index;
556 }
557 return (0);
558 }
559
560 #ifdef __OS2__
561 /* Visual Age cannot deal with old, non-ansi, code */
562 static int
563 CreateColors(
564 Display* display
565 , XpmAttributes* attributes
566 , XpmColor* colors
567 , unsigned int ncolors
568 , Pixel* image_pixels
569 , Pixel* mask_pixels
570 , unsigned int* mask_pixel_index
571 , Pixel* alloc_pixels
572 , unsigned int* nalloc_pixels
573 , Pixel* used_pixels
574 , unsigned int* nused_pixels
575 )
576 #else
577 static int
578 CreateColors(display, attributes, colors, ncolors, image_pixels, mask_pixels,
579 mask_pixel_index, alloc_pixels, nalloc_pixels,
580 used_pixels, nused_pixels)
581 Display *display;
582 XpmAttributes *attributes;
583 XpmColor *colors;
584 unsigned int ncolors;
585 Pixel *image_pixels;
586 Pixel *mask_pixels;
587 unsigned int *mask_pixel_index;
588 Pixel *alloc_pixels;
589 unsigned int *nalloc_pixels;
590 Pixel *used_pixels;
591 unsigned int *nused_pixels;
592 #endif
593 {
594 /* variables stored in the XpmAttributes structure */
595 Visual *visual;
596 Colormap colormap;
597 XpmColorSymbol *colorsymbols;
598 unsigned int numsymbols;
599 XpmAllocColorFunc allocColor;
600 void *closure;
601
602 char *colorname;
603 unsigned int color, key;
604 Bool pixel_defined;
605 XpmColorSymbol *symbol;
606 char **defaults;
607 int ErrorStatus = XpmSuccess;
608 char *s;
609 int default_index;
610
611 XColor *cols = NULL;
612 unsigned int ncols = 0;
613
614 /*
615 * retrieve information from the XpmAttributes
616 */
617 if (attributes && attributes->valuemask & XpmColorSymbols) {
618 colorsymbols = attributes->colorsymbols;
619 numsymbols = attributes->numsymbols;
620 } else
621 numsymbols = 0;
622
623 if (attributes && attributes->valuemask & XpmVisual)
624 visual = attributes->visual;
625 else
626 visual = XDefaultVisual(display, XDefaultScreen(display));
627
628 if (attributes && (attributes->valuemask & XpmColormap))
629 colormap = attributes->colormap;
630 else
631 colormap = XDefaultColormap(display, XDefaultScreen(display));
632
633 if (attributes && (attributes->valuemask & XpmColorKey))
634 key = attributes->color_key;
635 else
636 key = xpmVisualType(visual);
637
638 if (attributes && (attributes->valuemask & XpmAllocColor))
639 allocColor = attributes->alloc_color;
640 else
641 allocColor = AllocColor;
642 if (attributes && (attributes->valuemask & XpmColorClosure))
643 closure = attributes->color_closure;
644 else
645 closure = NULL;
646
647 #ifndef FOR_MSW
648 if (USE_CLOSECOLOR) {
649 /* originally from SetCloseColor */
650 #if 0
651 if (visual->class == DirectColor) {
652
653 /*
654 * TODO: Implement close colors for DirectColor visuals. This is
655 * difficult situation. Chances are that we will never get here,
656 * because any machine that supports DirectColor will probably
657 * also support TrueColor (and probably PseudoColor). Also,
658 * DirectColor colormaps can be very large, so looking for close
659 * colors may be too slow.
660 */
661 } else {
662 #endif
663 int i;
664
665 #ifndef AMIGA
666 ncols = visual->map_entries;
667 #else
668 ncols = colormap->Count;
669 #endif
670 cols = (XColor *) XpmCalloc(ncols, sizeof(XColor));
671 for (i = 0; i < ncols; ++i)
672 cols[i].pixel = i;
673 XQueryColors(display, colormap, cols, ncols);
674 #if 0
675 }
676 #endif
677 }
678 #endif /* ndef FOR_MSW */
679
680 switch (key) {
681 case XPM_MONO:
682 default_index = 2;
683 break;
684 case XPM_GRAY4:
685 default_index = 3;
686 break;
687 case XPM_GRAY:
688 default_index = 4;
689 break;
690 case XPM_COLOR:
691 default:
692 default_index = 5;
693 break;
694 }
695
696 for (color = 0; color < ncolors; color++, colors++,
697 image_pixels++, mask_pixels++) {
698 colorname = NULL;
699 pixel_defined = False;
700 defaults = (char **) colors;
701
702 /*
703 * look for a defined symbol
704 */
705 if (numsymbols) {
706
707 unsigned int n;
708
709 s = defaults[1];
710 for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) {
711 if (symbol->name && s && !strcmp(symbol->name, s))
712 /* override name */
713 break;
714 if (!symbol->name && symbol->value) { /* override value */
715 int def_index = default_index;
716
717 while (defaults[def_index] == NULL) /* find defined
718 * colorname */
719 --def_index;
720 if (def_index < 2) {/* nothing towards mono, so try
721 * towards color */
722 def_index = default_index + 1;
723 while (def_index <= 5 && defaults[def_index] == NULL)
724 ++def_index;
725 }
726 if (def_index >= 2 && defaults[def_index] != NULL &&
727 !xpmstrcasecmp(symbol->value, defaults[def_index]))
728 break;
729 }
730 }
731 if (n != numsymbols) {
732 if (symbol->name && symbol->value)
733 colorname = symbol->value;
734 else
735 pixel_defined = True;
736 }
737 }
738 if (!pixel_defined) { /* pixel not given as symbol value */
739
740 unsigned int k;
741
742 if (colorname) { /* colorname given as symbol value */
743 if (!SetColor(display, colormap, visual, colorname, color,
744 image_pixels, mask_pixels, mask_pixel_index,
745 alloc_pixels, nalloc_pixels, used_pixels,
746 nused_pixels, attributes, cols, ncols,
747 allocColor, closure))
748 pixel_defined = True;
749 else
750 ErrorStatus = XpmColorError;
751 }
752 k = key;
753 while (!pixel_defined && k > 1) {
754 if (defaults[k]) {
755 if (!SetColor(display, colormap, visual, defaults[k],
756 color, image_pixels, mask_pixels,
757 mask_pixel_index, alloc_pixels,
758 nalloc_pixels, used_pixels, nused_pixels,
759 attributes, cols, ncols,
760 allocColor, closure)) {
761 pixel_defined = True;
762 break;
763 } else
764 ErrorStatus = XpmColorError;
765 }
766 k--;
767 }
768 k = key + 1;
769 while (!pixel_defined && k < NKEYS + 1) {
770 if (defaults[k]) {
771 if (!SetColor(display, colormap, visual, defaults[k],
772 color, image_pixels, mask_pixels,
773 mask_pixel_index, alloc_pixels,
774 nalloc_pixels, used_pixels, nused_pixels,
775 attributes, cols, ncols,
776 allocColor, closure)) {
777 pixel_defined = True;
778 break;
779 } else
780 ErrorStatus = XpmColorError;
781 }
782 k++;
783 }
784 if (!pixel_defined) {
785 if (cols)
786 XpmFree(cols);
787 return (XpmColorFailed);
788 }
789 } else {
790 /* simply use the given pixel */
791 *image_pixels = symbol->pixel;
792 /* the following makes the mask to be built even if none
793 is given a particular pixel */
794 if (symbol->value
795 && !xpmstrcasecmp(symbol->value, TRANSPARENT_COLOR)) {
796 *mask_pixels = 0;
797 *mask_pixel_index = color;
798 } else
799 *mask_pixels = 1;
800 used_pixels[(*nused_pixels)++] = *image_pixels;
801 }
802 }
803 if (cols)
804 XpmFree(cols);
805 return (ErrorStatus);
806 }
807
808
809 /* default FreeColors function, simply call XFreeColors */
810 #ifdef __OS2__
811 /* Visual Age cannot deal with old, non-ansi, code */
812 static int
813 FreeColors(
814 Display* display
815 , Colormap colormap
816 , Pixel* pixels
817 , int n
818 , void* closure
819 )
820 #else
821 static int
822 FreeColors(display, colormap, pixels, n, closure)
823 Display *display;
824 Colormap colormap;
825 Pixel *pixels;
826 int n;
827 void *closure; /* not used */
828 #endif
829 {
830 return XFreeColors(display, colormap, pixels, n, 0);
831 }
832
833
834 /* function call in case of error */
835 #undef RETURN
836 #define RETURN(status) \
837 { \
838 ErrorStatus = status; \
839 goto error; \
840 }
841
842 #ifdef __OS2__
843 /* Visual Age cannot deal with old, non-ansi, code */
844 int XpmCreateImageFromXpmImage(
845 Display* display
846 , XpmImage* image
847 , XImage** image_return
848 , XImage** shapeimage_return
849 , XpmAttributes* attributes
850 )
851 #else
852 int
853 XpmCreateImageFromXpmImage(display, image,
854 image_return, shapeimage_return, attributes)
855 Display *display;
856 XpmImage *image;
857 XImage **image_return;
858 XImage **shapeimage_return;
859 XpmAttributes *attributes;
860 #endif
861 {
862 #ifdef __OS2__
863 HAB hab = WinQueryAnchorBlock(HWND_DESKTOP);
864 HPS hps;
865 SIZEL sizl = {0, 0};
866 #endif
867 /* variables stored in the XpmAttributes structure */
868 Visual *visual;
869 Colormap colormap;
870 unsigned int depth;
871 int bitmap_format;
872 XpmFreeColorsFunc freeColors;
873 void *closure;
874
875 /* variables to return */
876 XImage *ximage = NULL;
877 XImage *shapeimage = NULL;
878 unsigned int mask_pixel_index = XpmUndefPixel;
879 int ErrorStatus;
880
881 /* calculation variables */
882 Pixel *image_pixels = NULL;
883 Pixel *mask_pixels = NULL;
884 Pixel *alloc_pixels = NULL;
885 Pixel *used_pixels = NULL;
886 unsigned int nalloc_pixels = 0;
887 unsigned int nused_pixels = 0;
888
889 /* initialize return values */
890 if (image_return)
891 *image_return = NULL;
892 if (shapeimage_return)
893 *shapeimage_return = NULL;
894
895 /* retrieve information from the XpmAttributes */
896 if (attributes && (attributes->valuemask & XpmVisual))
897 visual = attributes->visual;
898 else
899 visual = XDefaultVisual(display, XDefaultScreen(display));
900
901 if (attributes && (attributes->valuemask & XpmColormap))
902 colormap = attributes->colormap;
903 else
904 colormap = XDefaultColormap(display, XDefaultScreen(display));
905
906 if (attributes && (attributes->valuemask & XpmDepth))
907 depth = attributes->depth;
908 else
909 depth = XDefaultDepth(display, XDefaultScreen(display));
910
911 if (attributes && (attributes->valuemask & XpmBitmapFormat))
912 bitmap_format = attributes->bitmap_format;
913 else
914 bitmap_format = ZPixmap;
915
916 if (attributes && (attributes->valuemask & XpmFreeColors))
917 freeColors = attributes->free_colors;
918 else
919 freeColors = FreeColors;
920 if (attributes && (attributes->valuemask & XpmColorClosure))
921 closure = attributes->color_closure;
922 else
923 closure = NULL;
924
925 ErrorStatus = XpmSuccess;
926
927 /* malloc pixels index tables */
928 image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
929 if (!image_pixels)
930 return (XpmNoMemory);
931
932 mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
933 if (!mask_pixels)
934 RETURN(XpmNoMemory);
935
936 /* maximum of allocated pixels will be the number of colors */
937 alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
938 if (!alloc_pixels)
939 RETURN(XpmNoMemory);
940
941 /* maximum of allocated pixels will be the number of colors */
942 used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors);
943 if (!used_pixels)
944 RETURN(XpmNoMemory);
945
946 /* get pixel colors, store them in index tables */
947 ErrorStatus = CreateColors(display, attributes, image->colorTable,
948 image->ncolors, image_pixels, mask_pixels,
949 &mask_pixel_index, alloc_pixels, &nalloc_pixels,
950 used_pixels, &nused_pixels);
951
952 if (ErrorStatus != XpmSuccess
953 && (ErrorStatus < 0 || (attributes
954 && (attributes->valuemask & XpmExactColors)
955 && attributes->exactColors)))
956 RETURN(ErrorStatus);
957
958 /* create the ximage */
959 if (image_return) {
960 ErrorStatus = CreateXImage(display, visual, depth,
961 (depth == 1 ? bitmap_format : ZPixmap),
962 image->width, image->height, &ximage);
963 if (ErrorStatus != XpmSuccess)
964 RETURN(ErrorStatus);
965
966 #ifndef FOR_MSW
967 # ifndef AMIGA
968
969 /*
970 * set the ximage data using optimized functions for ZPixmap
971 */
972
973 if (ximage->bits_per_pixel == 8)
974 PutImagePixels8(ximage, image->width, image->height,
975 image->data, image_pixels);
976 else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
977 (ximage->byte_order == ximage->bitmap_bit_order))
978 PutImagePixels1(ximage, image->width, image->height,
979 image->data, image_pixels);
980 else if (ximage->bits_per_pixel == 16)
981 PutImagePixels16(ximage, image->width, image->height,
982 image->data, image_pixels);
983 else if (ximage->bits_per_pixel == 32)
984 PutImagePixels32(ximage, image->width, image->height,
985 image->data, image_pixels);
986 else
987 PutImagePixels(ximage, image->width, image->height,
988 image->data, image_pixels);
989 # else /* AMIGA */
990 APutImagePixels(ximage, image->width, image->height,
991 image->data, image_pixels);
992 # endif
993 #else /* FOR_MSW */
994 MSWPutImagePixels(display, ximage, image->width, image->height,
995 image->data, image_pixels);
996 #endif
997 }
998 /* create the shape mask image */
999 if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
1000 ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
1001 image->width, image->height, &shapeimage);
1002 if (ErrorStatus != XpmSuccess)
1003 RETURN(ErrorStatus);
1004
1005 #ifndef FOR_MSW
1006 # ifndef AMIGA
1007 PutImagePixels1(shapeimage, image->width, image->height,
1008 image->data, mask_pixels);
1009 # else /* AMIGA */
1010 APutImagePixels(shapeimage, image->width, image->height,
1011 image->data, mask_pixels);
1012 # endif
1013 #else /* FOR_MSW */
1014 MSWPutImagePixels(display, shapeimage, image->width, image->height,
1015 image->data, mask_pixels);
1016 #endif
1017
1018 }
1019 XpmFree(image_pixels);
1020 XpmFree(mask_pixels);
1021
1022 /* if requested return used pixels in the XpmAttributes structure */
1023 if (attributes && (attributes->valuemask & XpmReturnPixels ||
1024 /* 3.2 backward compatibility code */
1025 attributes->valuemask & XpmReturnInfos)) {
1026 /* end 3.2 bc */
1027 attributes->pixels = used_pixels;
1028 attributes->npixels = nused_pixels;
1029 attributes->mask_pixel = mask_pixel_index;
1030 } else
1031 XpmFree(used_pixels);
1032
1033 /* if requested return alloc'ed pixels in the XpmAttributes structure */
1034 if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
1035 attributes->alloc_pixels = alloc_pixels;
1036 attributes->nalloc_pixels = nalloc_pixels;
1037 } else
1038 XpmFree(alloc_pixels);
1039
1040 /* return created images */
1041 if (image_return)
1042 *image_return = ximage;
1043 if (shapeimage_return)
1044 *shapeimage_return = shapeimage;
1045
1046 return (ErrorStatus);
1047
1048 /* exit point in case of error, free only locally allocated variables */
1049 error:
1050 if (ximage)
1051 XDestroyImage(ximage);
1052 if (shapeimage)
1053 XDestroyImage(shapeimage);
1054 if (image_pixels)
1055 XpmFree(image_pixels);
1056 if (mask_pixels)
1057 XpmFree(mask_pixels);
1058 if (nalloc_pixels)
1059 (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
1060 if (alloc_pixels)
1061 XpmFree(alloc_pixels);
1062 if (used_pixels)
1063 XpmFree(used_pixels);
1064
1065 return (ErrorStatus);
1066 }
1067
1068
1069 /*
1070 * Create an XImage with its data
1071 */
1072 #ifdef __OS2__
1073 /* Visual Age cannot deal with old, non-ansi, code */
1074 static int CreateXImage(
1075 Display* display
1076 , Visual* visual
1077 , unsigned int depth
1078 , int format
1079 , unsigned int width
1080 , unsigned int height
1081 , XImage** image_return
1082 )
1083 #else
1084 static int
1085 CreateXImage(display, visual, depth, format, width, height, image_return)
1086 Display *display;
1087 Visual *visual;
1088 unsigned int depth;
1089 int format;
1090 unsigned int width;
1091 unsigned int height;
1092 XImage **image_return;
1093 #endif
1094 {
1095 int bitmap_pad;
1096
1097 /* first get bitmap_pad */
1098 if (depth > 16)
1099 bitmap_pad = 32;
1100 else if (depth > 8)
1101 bitmap_pad = 16;
1102 else
1103 bitmap_pad = 8;
1104
1105 /* then create the XImage with data = NULL and bytes_per_line = 0 */
1106 *image_return = XCreateImage(display, visual, depth, format, 0, 0,
1107 width, height, bitmap_pad, 0);
1108 if (!*image_return)
1109 return (XpmNoMemory);
1110
1111 #if !defined(FOR_MSW) && !defined(AMIGA)
1112 /* now that bytes_per_line must have been set properly alloc data */
1113 (*image_return)->data =
1114 (char *) XpmMalloc((*image_return)->bytes_per_line * height);
1115
1116 if (!(*image_return)->data) {
1117 XDestroyImage(*image_return);
1118 *image_return = NULL;
1119 return (XpmNoMemory);
1120 }
1121 #else
1122 /* under FOR_MSW and AMIGA XCreateImage has done it all */
1123 #endif
1124 return (XpmSuccess);
1125 }
1126
1127 #ifndef FOR_MSW
1128 # ifndef AMIGA
1129 /*
1130 * The functions below are written from X11R5 MIT's code (XImUtil.c)
1131 *
1132 * The idea is to have faster functions than the standard XPutPixel function
1133 * to build the image data. Indeed we can speed up things by suppressing tests
1134 * performed for each pixel. We do the same tests but at the image level.
1135 * We also assume that we use only ZPixmap images with null offsets.
1136 */
1137
1138 LFUNC(_putbits, void, (register char *src, int dstoffset,
1139 register int numbits, register char *dst));
1140
1141 LFUNC(_XReverse_Bytes, int, (register unsigned char *bpt, register int nb));
1142
1143 static unsigned char Const _reverse_byte[0x100] = {
1144 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
1145 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
1146 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
1147 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
1148 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
1149 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
1150 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
1151 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
1152 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
1153 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
1154 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
1155 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
1156 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
1157 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
1158 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
1159 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
1160 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
1161 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
1162 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
1163 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
1164 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
1165 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
1166 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
1167 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
1168 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
1169 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
1170 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
1171 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
1172 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
1173 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
1174 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
1175 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
1176 };
1177
1178 #ifdef __OS2__
1179 /* Visual Age cannot deal with old, non-ansi, code */
1180 static int
1181 _XReverse_Bytes(register unsigned char* bpt, register int nb)
1182 #else
1183 static int
1184 _XReverse_Bytes(bpt, nb)
1185 register unsigned char *bpt;
1186 register int nb;
1187 #endif
1188 {
1189 do {
1190 *bpt = _reverse_byte[*bpt];
1191 bpt++;
1192 } while (--nb > 0);
1193 return 0;
1194 }
1195
1196
1197 #ifdef __OS2__
1198 /* Visual Age cannot deal with old, non-ansi, code */
1199 void xpm_xynormalizeimagebits(register unsigned char* bp, register XImage* img)
1200 #else
1201 void
1202 xpm_xynormalizeimagebits(bp, img)
1203 register unsigned char *bp;
1204 register XImage *img;
1205 #endif
1206 {
1207 register unsigned char c;
1208
1209 if (img->byte_order != img->bitmap_bit_order) {
1210 switch (img->bitmap_unit) {
1211
1212 case 16:
1213 c = *bp;
1214 *bp = *(bp + 1);
1215 *(bp + 1) = c;
1216 break;
1217
1218 case 32:
1219 c = *(bp + 3);
1220 *(bp + 3) = *bp;
1221 *bp = c;
1222 c = *(bp + 2);
1223 *(bp + 2) = *(bp + 1);
1224 *(bp + 1) = c;
1225 break;
1226 }
1227 }
1228 if (img->bitmap_bit_order == MSBFirst)
1229 _XReverse_Bytes(bp, img->bitmap_unit >> 3);
1230 }
1231
1232 #ifdef __OS2__
1233 /* Visual Age cannot deal with old, non-ansi, code */
1234 void xpm_znormalizeimagebits(register unsigned char* bp, register XImage* img)
1235 #else
1236 void
1237 xpm_znormalizeimagebits(bp, img)
1238 register unsigned char *bp;
1239 register XImage *img;
1240 #endif
1241 {
1242 register unsigned char c;
1243
1244 switch (img->bits_per_pixel) {
1245
1246 case 2:
1247 _XReverse_Bytes(bp, 1);
1248 break;
1249
1250 case 4:
1251 *bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
1252 break;
1253
1254 case 16:
1255 c = *bp;
1256 *bp = *(bp + 1);
1257 *(bp + 1) = c;
1258 break;
1259
1260 case 24:
1261 c = *(bp + 2);
1262 *(bp + 2) = *bp;
1263 *bp = c;
1264 break;
1265
1266 case 32:
1267 c = *(bp + 3);
1268 *(bp + 3) = *bp;
1269 *bp = c;
1270 c = *(bp + 2);
1271 *(bp + 2) = *(bp + 1);
1272 *(bp + 1) = c;
1273 break;
1274 }
1275 }
1276
1277 static unsigned char Const _lomask[0x09] = {
1278 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
1279 static unsigned char Const _himask[0x09] = {
1280 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
1281
1282 #ifdef __OS2__
1283 /* Visual Age cannot deal with old, non-ansi, code */
1284 static void _putbits(
1285 register char* src
1286 , int dstoffset
1287 , register int numbits
1288 , register char* dst
1289 )
1290 #else
1291 static void
1292 _putbits(src, dstoffset, numbits, dst)
1293 register char *src; /* address of source bit string */
1294 int dstoffset; /* bit offset into destination;
1295 * range is 0-31 */
1296 register int numbits; /* number of bits to copy to
1297 * destination */
1298 register char *dst; /* address of destination bit string */
1299 #endif
1300 {
1301 register unsigned char chlo, chhi;
1302 int hibits;
1303
1304 dst = dst + (dstoffset >> 3);
1305 dstoffset = dstoffset & 7;
1306 hibits = 8 - dstoffset;
1307 chlo = *dst & _lomask[dstoffset];
1308 for (;;) {
1309 chhi = (*src << dstoffset) & _himask[dstoffset];
1310 if (numbits <= hibits) {
1311 chhi = chhi & _lomask[dstoffset + numbits];
1312 *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
1313 break;
1314 }
1315 *dst = chhi | chlo;
1316 dst++;
1317 numbits = numbits - hibits;
1318 chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
1319 src++;
1320 if (numbits <= dstoffset) {
1321 chlo = chlo & _lomask[numbits];
1322 *dst = (*dst & _himask[numbits]) | chlo;
1323 break;
1324 }
1325 numbits = numbits - dstoffset;
1326 }
1327 }
1328
1329 /*
1330 * Default method to write pixels into a Z image data structure.
1331 * The algorithm used is:
1332 *
1333 * copy the destination bitmap_unit or Zpixel to temp
1334 * normalize temp if needed
1335 * copy the pixel bits into the temp
1336 * renormalize temp if needed
1337 * copy the temp back into the destination image data
1338 */
1339
1340 #ifdef __OS2__
1341 /* Visual Age cannot deal with old, non-ansi, code */
1342 static void PutImagePixels(
1343 , XImage* image
1344 , unsigned int width
1345 , unsigned int height
1346 , unsigned int* pixelindex
1347 , Pixel* pixels
1348 )
1349 #else
1350 static void
1351 PutImagePixels(image, width, height, pixelindex, pixels)
1352 XImage *image;
1353 unsigned int width;
1354 unsigned int height;
1355 unsigned int *pixelindex;
1356 Pixel *pixels;
1357 #endif
1358 {
1359 register char *src;
1360 register char *dst;
1361 register unsigned int *iptr;
1362 register int x, y, i;
1363 register char *data;
1364 Pixel pixel, px;
1365 int nbytes, depth, ibu, ibpp;
1366
1367 data = image->data;
1368 iptr = pixelindex;
1369 depth = image->depth;
1370 if (depth == 1) {
1371 ibu = image->bitmap_unit;
1372 for (y = 0; y < height; y++)
1373 for (x = 0; x < width; x++, iptr++) {
1374 pixel = pixels[*iptr];
1375 for (i = 0, px = pixel; i < sizeof(unsigned long);
1376 i++, px >>= 8)
1377 ((unsigned char *) &pixel)[i] = px;
1378 src = &data[XYINDEX(x, y, image)];
1379 dst = (char *) &px;
1380 px = 0;
1381 nbytes = ibu >> 3;
1382 for (i = nbytes; --i >= 0;)
1383 *dst++ = *src++;
1384 XYNORMALIZE(&px, image);
1385 _putbits((char *) &pixel, (x % ibu), 1, (char *) &px);
1386 XYNORMALIZE(&px, image);
1387 src = (char *) &px;
1388 dst = &data[XYINDEX(x, y, image)];
1389 for (i = nbytes; --i >= 0;)
1390 *dst++ = *src++;
1391 }
1392 } else {
1393 ibpp = image->bits_per_pixel;
1394 for (y = 0; y < height; y++)
1395 for (x = 0; x < width; x++, iptr++) {
1396 pixel = pixels[*iptr];
1397 if (depth == 4)
1398 pixel &= 0xf;
1399 for (i = 0, px = pixel; i < sizeof(unsigned long); i++,
1400 px >>= 8)
1401 ((unsigned char *) &pixel)[i] = px;
1402 src = &data[ZINDEX(x, y, image)];
1403 dst = (char *) &px;
1404 px = 0;
1405 nbytes = (ibpp + 7) >> 3;
1406 for (i = nbytes; --i >= 0;)
1407 *dst++ = *src++;
1408 ZNORMALIZE(&px, image);
1409 _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
1410 ZNORMALIZE(&px, image);
1411 src = (char *) &px;
1412 dst = &data[ZINDEX(x, y, image)];
1413 for (i = nbytes; --i >= 0;)
1414 *dst++ = *src++;
1415 }
1416 }
1417 }
1418
1419 /*
1420 * write pixels into a 32-bits Z image data structure
1421 */
1422
1423 #if !defined(WORD64) && !defined(LONG64)
1424 /* this item is static but deterministic so let it slide; doesn't
1425 * hurt re-entrancy of this library. Note if it is actually const then would
1426 * be OK under rules of ANSI-C but probably not C++ which may not
1427 * want to allocate space for it.
1428 */
1429 static unsigned long byteorderpixel = MSBFirst << 24;
1430
1431 #endif
1432
1433 /*
1434 WITHOUT_SPEEDUPS is a flag to be turned on if you wish to use the original
1435 3.2e code - by default you get the speeded-up version.
1436 */
1437
1438 #ifdef __OS2__
1439 /* Visual Age cannot deal with old, non-ansi, code */
1440 static void
1441 PutImagePixels32(
1442 , XImage* image
1443 , unsigned int width
1444 , unsigned int height
1445 , unsigned int* pixelindex
1446 , Pixel* pixels
1447 )
1448 #else
1449 static void
1450 PutImagePixels32(image, width, height, pixelindex, pixels)
1451 XImage *image;
1452 unsigned int width;
1453 unsigned int height;
1454 unsigned int *pixelindex;
1455 Pixel *pixels;
1456 #endif
1457 {
1458 unsigned char *data;
1459 unsigned int *iptr;
1460 int y;
1461 Pixel pixel;
1462
1463 #ifdef WITHOUT_SPEEDUPS
1464
1465 int x;
1466 unsigned char *addr;
1467
1468 data = (unsigned char *) image->data;
1469 iptr = pixelindex;
1470 #if !defined(WORD64) && !defined(LONG64)
1471 if (*((char *) &byteorderpixel) == image->byte_order) {
1472 for (y = 0; y < height; y++)
1473 for (x = 0; x < width; x++, iptr++) {
1474 addr = &data[ZINDEX32(x, y, image)];
1475 *((unsigned long *) addr) = pixels[*iptr];
1476 }
1477 } else
1478 #endif
1479 if (image->byte_order == MSBFirst)
1480 for (y = 0; y < height; y++)
1481 for (x = 0; x < width; x++, iptr++) {
1482 addr = &data[ZINDEX32(x, y, image)];
1483 pixel = pixels[*iptr];
1484 addr[0] = pixel >> 24;
1485 addr[1] = pixel >> 16;
1486 addr[2] = pixel >> 8;
1487 addr[3] = pixel;
1488 }
1489 else
1490 for (y = 0; y < height; y++)
1491 for (x = 0; x < width; x++, iptr++) {
1492 addr = &data[ZINDEX32(x, y, image)];
1493 pixel = pixels[*iptr];
1494 addr[0] = pixel;
1495 addr[1] = pixel >> 8;
1496 addr[2] = pixel >> 16;
1497 addr[3] = pixel >> 24;
1498 }
1499
1500 #else /* WITHOUT_SPEEDUPS */
1501
1502 int bpl = image->bytes_per_line;
1503 unsigned char *data_ptr, *max_data;
1504
1505 data = (unsigned char *) image->data;
1506 iptr = pixelindex;
1507 #if !defined(WORD64) && !defined(LONG64)
1508 if (*((char *) &byteorderpixel) == image->byte_order) {
1509 for (y = 0; y < height; y++) {
1510 data_ptr = data;
1511 max_data = data_ptr + (width << 2);
1512
1513 while (data_ptr < max_data) {
1514 *((unsigned long *) data_ptr) = pixels[*(iptr++)];
1515 data_ptr += (1 << 2);
1516 }
1517 data += bpl;
1518 }
1519 } else
1520 #endif
1521 if (image->byte_order == MSBFirst)
1522 for (y = 0; y < height; y++) {
1523 data_ptr = data;
1524 max_data = data_ptr + (width << 2);
1525
1526 while (data_ptr < max_data) {
1527 pixel = pixels[*(iptr++)];
1528
1529 *data_ptr++ = pixel >> 24;
1530 *data_ptr++ = pixel >> 16;
1531 *data_ptr++ = pixel >> 8;
1532 *data_ptr++ = pixel;
1533
1534 }
1535 data += bpl;
1536 }
1537 else
1538 for (y = 0; y < height; y++) {
1539 data_ptr = data;
1540 max_data = data_ptr + (width << 2);
1541
1542 while (data_ptr < max_data) {
1543 pixel = pixels[*(iptr++)];
1544
1545 *data_ptr++ = pixel;
1546 *data_ptr++ = pixel >> 8;
1547 *data_ptr++ = pixel >> 16;
1548 *data_ptr++ = pixel >> 24;
1549 }
1550 data += bpl;
1551 }
1552
1553 #endif /* WITHOUT_SPEEDUPS */
1554 }
1555
1556 /*
1557 * write pixels into a 16-bits Z image data structure
1558 */
1559
1560 #ifdef __OS2__
1561 /* Visual Age cannot deal with old, non-ansi, code */
1562 static void PutImagePixels16(
1563 , XImage* image
1564 , unsigned int width
1565 , unsigned int height
1566 , unsigned int* pixelindex
1567 , Pixel* pixels
1568 )
1569 #else
1570 static void
1571 PutImagePixels16(image, width, height, pixelindex, pixels)
1572 XImage *image;
1573 unsigned int width;
1574 unsigned int height;
1575 unsigned int *pixelindex;
1576 Pixel *pixels;
1577 #endif
1578 {
1579 unsigned char *data;
1580 unsigned int *iptr;
1581 int y;
1582
1583 #ifdef WITHOUT_SPEEDUPS
1584
1585 int x;
1586 unsigned char *addr;
1587
1588 data = (unsigned char *) image->data;
1589 iptr = pixelindex;
1590 if (image->byte_order == MSBFirst)
1591 for (y = 0; y < height; y++)
1592 for (x = 0; x < width; x++, iptr++) {
1593 addr = &data[ZINDEX16(x, y, image)];
1594 addr[0] = pixels[*iptr] >> 8;
1595 addr[1] = pixels[*iptr];
1596 }
1597 else
1598 for (y = 0; y < height; y++)
1599 for (x = 0; x < width; x++, iptr++) {
1600 addr = &data[ZINDEX16(x, y, image)];
1601 addr[0] = pixels[*iptr];
1602 addr[1] = pixels[*iptr] >> 8;
1603 }
1604
1605 #else /* WITHOUT_SPEEDUPS */
1606
1607 Pixel pixel;
1608
1609 int bpl = image->bytes_per_line;
1610 unsigned char *data_ptr, *max_data;
1611
1612 data = (unsigned char *) image->data;
1613 iptr = pixelindex;
1614 if (image->byte_order == MSBFirst)
1615 for (y = 0; y < height; y++) {
1616 data_ptr = data;
1617 max_data = data_ptr + (width << 1);
1618
1619 while (data_ptr < max_data) {
1620 pixel = pixels[*(iptr++)];
1621
1622 data_ptr[0] = pixel >> 8;
1623 data_ptr[1] = pixel;
1624
1625 data_ptr += (1 << 1);
1626 }
1627 data += bpl;
1628 }
1629 else
1630 for (y = 0; y < height; y++) {
1631 data_ptr = data;
1632 max_data = data_ptr + (width << 1);
1633
1634 while (data_ptr < max_data) {
1635 pixel = pixels[*(iptr++)];
1636
1637 data_ptr[0] = pixel;
1638 data_ptr[1] = pixel >> 8;
1639
1640 data_ptr += (1 << 1);
1641 }
1642 data += bpl;
1643 }
1644
1645 #endif /* WITHOUT_SPEEDUPS */
1646 }
1647
1648 /*
1649 * write pixels into a 8-bits Z image data structure
1650 */
1651
1652 #ifdef __OS2__
1653 /* Visual Age cannot deal with old, non-ansi, code */
1654 static void PutImagePixels8(
1655 , XImage* image
1656 , unsigned int width
1657 , unsigned int height
1658 , unsigned int* pixelindex
1659 , Pixel* pixels
1660 )
1661 #else
1662 static void
1663 PutImagePixels8(image, width, height, pixelindex, pixels)
1664 XImage *image;
1665 unsigned int width;
1666 unsigned int height;
1667 unsigned int *pixelindex;
1668 Pixel *pixels;
1669 #endif
1670 {
1671 char *data;
1672 unsigned int *iptr;
1673 int y;
1674
1675 #ifdef WITHOUT_SPEEDUPS
1676
1677 int x;
1678
1679 data = image->data;
1680 iptr = pixelindex;
1681 for (y = 0; y < height; y++)
1682 for (x = 0; x < width; x++, iptr++)
1683 data[ZINDEX8(x, y, image)] = pixels[*iptr];
1684
1685 #else /* WITHOUT_SPEEDUPS */
1686
1687 int bpl = image->bytes_per_line;
1688 char *data_ptr, *max_data;
1689
1690 data = image->data;
1691 iptr = pixelindex;
1692
1693 for (y = 0; y < height; y++) {
1694 data_ptr = data;
1695 max_data = data_ptr + width;
1696
1697 while (data_ptr < max_data)
1698 *(data_ptr++) = pixels[*(iptr++)];
1699
1700 data += bpl;
1701 }
1702
1703 #endif /* WITHOUT_SPEEDUPS */
1704 }
1705
1706 /*
1707 * write pixels into a 1-bit depth image data structure and **offset null**
1708 */
1709
1710 #ifdef __OS2__
1711 /* Visual Age cannot deal with old, non-ansi, code */
1712 static void PutImagePixels1(
1713 , XImage* image
1714 , unsigned int width
1715 , unsigned int height
1716 , unsigned int* pixelindex
1717 , Pixel* pixels
1718 )
1719 #else
1720 static void
1721 PutImagePixels1(image, width, height, pixelindex, pixels)
1722 XImage *image;
1723 unsigned int width;
1724 unsigned int height;
1725 unsigned int *pixelindex;
1726 Pixel *pixels;
1727 #endif
1728 {
1729 if (image->byte_order != image->bitmap_bit_order)
1730 PutImagePixels(image, width, height, pixelindex, pixels);
1731 else {
1732 unsigned int *iptr;
1733 int y;
1734 char *data;
1735
1736 #ifdef WITHOUT_SPEEDUPS
1737
1738 int x;
1739
1740 data = image->data;
1741 iptr = pixelindex;
1742 if (image->bitmap_bit_order == MSBFirst)
1743 for (y = 0; y < height; y++)
1744 for (x = 0; x < width; x++, iptr++) {
1745 if (pixels[*iptr] & 1)
1746 data[ZINDEX1(x, y, image)] |= 0x80 >> (x & 7);
1747 else
1748 data[ZINDEX1(x, y, image)] &= ~(0x80 >> (x & 7));
1749 }
1750 else
1751 for (y = 0; y < height; y++)
1752 for (x = 0; x < width; x++, iptr++) {
1753 if (pixels[*iptr] & 1)
1754 data[ZINDEX1(x, y, image)] |= 1 << (x & 7);
1755 else
1756 data[ZINDEX1(x, y, image)] &= ~(1 << (x & 7));
1757 }
1758
1759 #else /* WITHOUT_SPEEDUPS */
1760
1761 char value;
1762 char *data_ptr, *max_data;
1763 int bpl = image->bytes_per_line;
1764 int diff, count;
1765
1766 data = image->data;
1767 iptr = pixelindex;
1768
1769 diff = width & 7;
1770 width >>= 3;
1771
1772 if (image->bitmap_bit_order == MSBFirst)
1773 for (y = 0; y < height; y++) {
1774 data_ptr = data;
1775 max_data = data_ptr + width;
1776 while (data_ptr < max_data) {
1777 value = 0;
1778
1779 value = (value << 1) | (pixels[*(iptr++)] & 1);
1780 value = (value << 1) | (pixels[*(iptr++)] & 1);
1781 value = (value << 1) | (pixels[*(iptr++)] & 1);
1782 value = (value << 1) | (pixels[*(iptr++)] & 1);
1783 value = (value << 1) | (pixels[*(iptr++)] & 1);
1784 value = (value << 1) | (pixels[*(iptr++)] & 1);
1785 value = (value << 1) | (pixels[*(iptr++)] & 1);
1786 value = (value << 1) | (pixels[*(iptr++)] & 1);
1787
1788 *(data_ptr++) = value;
1789 }
1790 if (diff) {
1791 value = 0;
1792 for (count = 0; count < diff; count++) {
1793 if (pixels[*(iptr++)] & 1)
1794 value |= (0x80 >> count);
1795 }
1796 *(data_ptr) = value;
1797 }
1798 data += bpl;
1799 }
1800 else
1801 for (y = 0; y < height; y++) {
1802 data_ptr = data;
1803 max_data = data_ptr + width;
1804 while (data_ptr < max_data) {
1805 value = 0;
1806 iptr += 8;
1807
1808 value = (value << 1) | (pixels[*(--iptr)] & 1);
1809 value = (value << 1) | (pixels[*(--iptr)] & 1);
1810 value = (value << 1) | (pixels[*(--iptr)] & 1);
1811 value = (value << 1) | (pixels[*(--iptr)] & 1);
1812 value = (value << 1) | (pixels[*(--iptr)] & 1);
1813 value = (value << 1) | (pixels[*(--iptr)] & 1);
1814 value = (value << 1) | (pixels[*(--iptr)] & 1);
1815 value = (value << 1) | (pixels[*(--iptr)] & 1);
1816
1817 iptr += 8;
1818 *(data_ptr++) = value;
1819 }
1820 if (diff) {
1821 value = 0;
1822 for (count = 0; count < diff; count++) {
1823 if (pixels[*(iptr++)] & 1)
1824 value |= (1 << count);
1825 }
1826 *(data_ptr) = value;
1827 }
1828 data += bpl;
1829 }
1830
1831 #endif /* WITHOUT_SPEEDUPS */
1832 }
1833 }
1834
1835 #ifdef __OS2__
1836 /* Visual Age cannot deal with old, non-ansi, code */
1837 int XpmCreatePixmapFromXpmImage(
1838 , Display* display
1839 , Drawable d
1840 , XpmImage* image
1841 , Pixmap* pixmap_return
1842 , Pixmap* shapemask_return
1843 , XpmAttributes* attributes
1844 #else
1845 int
1846 XpmCreatePixmapFromXpmImage(display, d, image,
1847 pixmap_return, shapemask_return, attributes)
1848 Display *display;
1849 Drawable d;
1850 XpmImage *image;
1851 Pixmap *pixmap_return;
1852 Pixmap *shapemask_return;
1853 XpmAttributes *attributes;
1854 #endif
1855 {
1856 XImage *ximage, *shapeimage;
1857 int ErrorStatus;
1858
1859 /* initialize return values */
1860 if (pixmap_return)
1861 *pixmap_return = 0;
1862 if (shapemask_return)
1863 *shapemask_return = 0;
1864
1865 /* create the ximages */
1866 ErrorStatus = XpmCreateImageFromXpmImage(display, image,
1867 (pixmap_return ? &ximage : NULL),
1868 (shapemask_return ?
1869 &shapeimage : NULL),
1870 attributes);
1871 if (ErrorStatus < 0)
1872 return (ErrorStatus);
1873
1874 /* create the pixmaps and destroy images */
1875 if (pixmap_return && ximage) {
1876 xpmCreatePixmapFromImage(display, d, ximage, pixmap_return);
1877 XDestroyImage(ximage);
1878 }
1879 if (shapemask_return && shapeimage) {
1880 xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return);
1881 XDestroyImage(shapeimage);
1882 }
1883 return (ErrorStatus);
1884 }
1885
1886 # else /* AMIGA */
1887
1888 static void
1889 APutImagePixels (
1890 XImage *image,
1891 unsigned int width,
1892 unsigned int height,
1893 unsigned int *pixelindex,
1894 Pixel *pixels)
1895 {
1896 unsigned int *data = pixelindex;
1897 unsigned int x, y;
1898 unsigned char *array;
1899 XImage *tmp_img;
1900 BOOL success = FALSE;
1901
1902 array = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*array));
1903 if (array != NULL)
1904 {
1905 tmp_img = AllocXImage ((((width+15)>>4)<<4), 1,
1906 image->rp->BitMap->Depth);
1907 if (tmp_img != NULL)
1908 {
1909 for (y = 0; y < height; ++y)
1910 {
1911 for (x = 0; x < width; ++x)
1912 array[x] = pixels[*(data++)];
1913 WritePixelLine8 (image->rp, 0, y, width, array, tmp_img->rp);
1914 }
1915 FreeXImage (tmp_img);
1916 success = TRUE;
1917 }
1918 XpmFree (array);
1919 }
1920
1921 if (!success)
1922 {
1923 for (y = 0; y < height; ++y)
1924 for (x = 0; x < width; ++x)
1925 XPutPixel (image, x, y, pixels[*(data++)]);
1926 }
1927 }
1928
1929 # endif/* AMIGA */
1930 #else /* FOR_MSW part follows */
1931
1932 #ifdef __OS2__
1933 /* Visual Age cannot deal with old, non-ansi, code */
1934 static void MSWPutImagePixels(
1935 Display* dc
1936 , XImage* image
1937 , unsigned int width
1938 , unsigned int height
1939 , unsigned int* pixelindex
1940 , Pixel* pixels
1941 )
1942 #else
1943 static void
1944 MSWPutImagePixels(dc, image, width, height, pixelindex, pixels)
1945 Display *dc;
1946 XImage *image;
1947 unsigned int width;
1948 unsigned int height;
1949 unsigned int *pixelindex;
1950 Pixel *pixels;
1951 #endif
1952 {
1953 unsigned int *data = pixelindex;
1954 unsigned int x, y;
1955 HBITMAP obm;
1956
1957 #ifdef __OS2__
1958 POINTL point;
1959
1960 obm = GpiSetBitmap(*dc, image->bitmap);
1961 #else
1962 obm = SelectObject(*dc, image->bitmap);
1963 #endif
1964
1965 for (y = 0; y < height; y++) {
1966 for (x = 0; x < width; x++) {
1967 #ifdef __OS2__
1968 point.x = x;
1969 point.y = y;
1970 GpiSetColor(*dc, (LONG)pixels[*(data++)]);
1971 GpiSetPel(*dc, &point);
1972 #else
1973
1974 SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */
1975 #endif
1976 }
1977 }
1978 #ifdef __OS2__
1979 GpiSetBitmap(*dc, obm);
1980 #else
1981 SelectObject(*dc, obm);
1982 #endif
1983 }
1984
1985 #endif /* FOR_MSW */
1986
1987
1988
1989 #if !defined(FOR_MSW) && !defined(AMIGA)
1990
1991 static int
1992 PutPixel1(ximage, x, y, pixel)
1993 register XImage *ximage;
1994 int x;
1995 int y;
1996 unsigned long pixel;
1997 {
1998 register char *src;
1999 register char *dst;
2000 register int i;
2001 register char *data;
2002 Pixel px;
2003 int nbytes;
2004
2005 for (i=0, px=pixel; i<sizeof(unsigned long); i++, px>>=8)
2006 ((unsigned char *)&pixel)[i] = px;
2007 src = &ximage->data[XYINDEX(x, y, ximage)];
2008 dst = (char *)&px;
2009 px = 0;
2010 nbytes = ximage->bitmap_unit >> 3;
2011 for (i = nbytes; --i >= 0; ) *dst++ = *src++;
2012 XYNORMALIZE(&px, ximage);
2013 i = ((x + ximage->xoffset) % ximage->bitmap_unit);
2014 _putbits ((char *)&pixel, i, 1, (char *)&px);
2015 XYNORMALIZE(&px, ximage);
2016 src = (char *) &px;
2017 dst = &ximage->data[XYINDEX(x, y, ximage)];
2018 for (i = nbytes; --i >= 0; )
2019 *dst++ = *src++;
2020
2021 return 1;
2022 }
2023
2024 static int
2025 PutPixel(ximage, x, y, pixel)
2026 register XImage *ximage;
2027 int x;
2028 int y;
2029 unsigned long pixel;
2030 {
2031 register char *src;
2032 register char *dst;
2033 register int i;
2034 register char *data;
2035 Pixel px;
2036 int nbytes, ibpp;
2037
2038 ibpp = ximage->bits_per_pixel;
2039 if (ximage->depth == 4)
2040 pixel &= 0xf;
2041 for (i = 0, px = pixel; i < sizeof(unsigned long); i++, px >>= 8)
2042 ((unsigned char *) &pixel)[i] = px;
2043 src = &ximage->data[ZINDEX(x, y, ximage)];
2044 dst = (char *) &px;
2045 px = 0;
2046 nbytes = (ibpp + 7) >> 3;
2047 for (i = nbytes; --i >= 0;)
2048 *dst++ = *src++;
2049 ZNORMALIZE(&px, ximage);
2050 _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px);
2051 ZNORMALIZE(&px, ximage);
2052 src = (char *) &px;
2053 dst = &ximage->data[ZINDEX(x, y, ximage)];
2054 for (i = nbytes; --i >= 0;)
2055 *dst++ = *src++;
2056
2057 return 1;
2058 }
2059
2060 static int
2061 PutPixel32(ximage, x, y, pixel)
2062 register XImage *ximage;
2063 int x;
2064 int y;
2065 unsigned long pixel;
2066 {
2067 unsigned char *addr;
2068
2069 addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
2070 *((unsigned long *)addr) = pixel;
2071 return 1;
2072 }
2073
2074 static int
2075 PutPixel32MSB(ximage, x, y, pixel)
2076 register XImage *ximage;
2077 int x;
2078 int y;
2079 unsigned long pixel;
2080 {
2081 unsigned char *addr;
2082
2083 addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
2084 addr[0] = pixel >> 24;
2085 addr[1] = pixel >> 16;
2086 addr[2] = pixel >> 8;
2087 addr[3] = pixel;
2088 return 1;
2089 }
2090
2091 static int
2092 PutPixel32LSB(ximage, x, y, pixel)
2093 register XImage *ximage;
2094 int x;
2095 int y;
2096 unsigned long pixel;
2097 {
2098 unsigned char *addr;
2099
2100 addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)];
2101 addr[3] = pixel >> 24;
2102 addr[2] = pixel >> 16;
2103 addr[1] = pixel >> 8;
2104 addr[0] = pixel;
2105 return 1;
2106 }
2107
2108 static int
2109 PutPixel16MSB(ximage, x, y, pixel)
2110 register XImage *ximage;
2111 int x;
2112 int y;
2113 unsigned long pixel;
2114 {
2115 unsigned char *addr;
2116
2117 addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];
2118 addr[0] = pixel >> 8;
2119 addr[1] = pixel;
2120 return 1;
2121 }
2122
2123 static int
2124 PutPixel16LSB(ximage, x, y, pixel)
2125 register XImage *ximage;
2126 int x;
2127 int y;
2128 unsigned long pixel;
2129 {
2130 unsigned char *addr;
2131
2132 addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)];
2133 addr[1] = pixel >> 8;
2134 addr[0] = pixel;
2135 return 1;
2136 }
2137
2138 static int
2139 PutPixel8(ximage, x, y, pixel)
2140 register XImage *ximage;
2141 int x;
2142 int y;
2143 unsigned long pixel;
2144 {
2145 ximage->data[ZINDEX8(x, y, ximage)] = pixel;
2146 return 1;
2147 }
2148
2149 static int
2150 PutPixel1MSB(ximage, x, y, pixel)
2151 register XImage *ximage;
2152 int x;
2153 int y;
2154 unsigned long pixel;
2155 {
2156 if (pixel & 1)
2157 ximage->data[ZINDEX1(x, y, ximage)] |= 0x80 >> (x & 7);
2158 else
2159 ximage->data[ZINDEX1(x, y, ximage)] &= ~(0x80 >> (x & 7));
2160 return 1;
2161 }
2162
2163 static int
2164 PutPixel1LSB(ximage, x, y, pixel)
2165 register XImage *ximage;
2166 int x;
2167 int y;
2168 unsigned long pixel;
2169 {
2170 if (pixel & 1)
2171 ximage->data[ZINDEX1(x, y, ximage)] |= 1 << (x & 7);
2172 else
2173 ximage->data[ZINDEX1(x, y, ximage)] &= ~(1 << (x & 7));
2174 return 1;
2175 }
2176
2177 #endif /* not FOR_MSW && not AMIGA */
2178
2179 /*
2180 * This function parses an Xpm file or data and directly create an XImage
2181 */
2182 #ifdef __OS2__
2183 /* Visual Age cannot deal with old, non-ansi, code */
2184 int xpmParseDataAndCreate(
2185 Display* display
2186 , xpmData* data
2187 , XImage** image_return
2188 , XImage** shapeimage_return
2189 , XpmImage* image
2190 , XpmInfo* info
2191 , XpmAttributes* attributes
2192 )
2193 #else
2194 int
2195 xpmParseDataAndCreate(display, data, image_return, shapeimage_return,
2196 image, info, attributes)
2197 Display *display;
2198 xpmData *data;
2199 XImage **image_return;
2200 XImage **shapeimage_return;
2201 XpmImage *image;
2202 XpmInfo *info;
2203 XpmAttributes *attributes;
2204 #endif
2205 {
2206 /* variables stored in the XpmAttributes structure */
2207 Visual *visual;
2208 Colormap colormap;
2209 unsigned int depth;
2210 int bitmap_format;
2211 XpmFreeColorsFunc freeColors;
2212 void *closure;
2213
2214 /* variables to return */
2215 XImage *ximage = NULL;
2216 XImage *shapeimage = NULL;
2217 unsigned int mask_pixel_index = XpmUndefPixel;
2218
2219 /* calculation variables */
2220 Pixel *image_pixels = NULL;
2221 Pixel *mask_pixels = NULL;
2222 Pixel *alloc_pixels = NULL;
2223 Pixel *used_pixels = NULL;
2224 unsigned int nalloc_pixels = 0;
2225 unsigned int nused_pixels = 0;
2226 unsigned int width, height, ncolors, cpp;
2227 unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0;
2228 XpmColor *colorTable = NULL;
2229 char *hints_cmt = NULL;
2230 char *colors_cmt = NULL;
2231 char *pixels_cmt = NULL;
2232
2233 unsigned int cmts;
2234 int ErrorStatus;
2235 xpmHashTable hashtable;
2236
2237
2238 /* initialize return values */
2239 if (image_return)
2240 *image_return = NULL;
2241 if (shapeimage_return)
2242 *shapeimage_return = NULL;
2243
2244
2245 /* retrieve information from the XpmAttributes */
2246 if (attributes && (attributes->valuemask & XpmVisual))
2247 visual = attributes->visual;
2248 else
2249 visual = XDefaultVisual(display, XDefaultScreen(display));
2250
2251 if (attributes && (attributes->valuemask & XpmColormap))
2252 colormap = attributes->colormap;
2253 else
2254 colormap = XDefaultColormap(display, XDefaultScreen(display));
2255
2256 if (attributes && (attributes->valuemask & XpmDepth))
2257 depth = attributes->depth;
2258 else
2259 depth = XDefaultDepth(display, XDefaultScreen(display));
2260
2261 if (attributes && (attributes->valuemask & XpmBitmapFormat))
2262 bitmap_format = attributes->bitmap_format;
2263 else
2264 bitmap_format = ZPixmap;
2265
2266 if (attributes && (attributes->valuemask & XpmFreeColors))
2267 freeColors = attributes->free_colors;
2268 else
2269 freeColors = FreeColors;
2270 if (attributes && (attributes->valuemask & XpmColorClosure))
2271 closure = attributes->color_closure;
2272 else
2273 closure = NULL;
2274
2275 cmts = info && (info->valuemask & XpmReturnComments);
2276
2277 /*
2278 * parse the header
2279 */
2280 ErrorStatus = xpmParseHeader(data);
2281 if (ErrorStatus != XpmSuccess)
2282 return (ErrorStatus);
2283
2284 /*
2285 * read values
2286 */
2287 ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,
2288 &x_hotspot, &y_hotspot, &hotspot,
2289 &extensions);
2290 if (ErrorStatus != XpmSuccess)
2291 return (ErrorStatus);
2292
2293 /*
2294 * store the hints comment line
2295 */
2296 if (cmts)
2297 xpmGetCmt(data, &hints_cmt);
2298
2299 /*
2300 * init the hastable
2301 */
2302 if (USE_HASHTABLE) {
2303 ErrorStatus = xpmHashTableInit(&hashtable);
2304 if (ErrorStatus != XpmSuccess)
2305 return (ErrorStatus);
2306 }
2307
2308 /*
2309 * read colors
2310 */
2311 ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable);
2312 if (ErrorStatus != XpmSuccess)
2313 RETURN(ErrorStatus);
2314
2315 /*
2316 * store the colors comment line
2317 */
2318 if (cmts)
2319 xpmGetCmt(data, &colors_cmt);
2320
2321 /* malloc pixels index tables */
2322 image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
2323 if (!image_pixels)
2324 RETURN(XpmNoMemory);
2325
2326 mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
2327 if (!mask_pixels)
2328 RETURN(XpmNoMemory);
2329
2330 /* maximum of allocated pixels will be the number of colors */
2331 alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
2332 if (!alloc_pixels)
2333 RETURN(XpmNoMemory);
2334
2335 /* maximum of allocated pixels will be the number of colors */
2336 used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors);
2337 if (!used_pixels)
2338 RETURN(XpmNoMemory);
2339
2340 /* get pixel colors, store them in index tables */
2341 ErrorStatus = CreateColors(display, attributes, colorTable, ncolors,
2342 image_pixels, mask_pixels, &mask_pixel_index,
2343 alloc_pixels, &nalloc_pixels, used_pixels,
2344 &nused_pixels);
2345
2346 if (ErrorStatus != XpmSuccess
2347 && (ErrorStatus < 0 || (attributes
2348 && (attributes->valuemask & XpmExactColors)
2349 && attributes->exactColors)))
2350 RETURN(ErrorStatus);
2351
2352 /* now create the ximage */
2353 if (image_return) {
2354 ErrorStatus = CreateXImage(display, visual, depth,
2355 (depth == 1 ? bitmap_format : ZPixmap),
2356 width, height, &ximage);
2357 if (ErrorStatus != XpmSuccess)
2358 RETURN(ErrorStatus);
2359
2360 #if !defined(FOR_MSW) && !defined(AMIGA)
2361
2362 /*
2363 * set the XImage pointer function, to be used with XPutPixel,
2364 * to an internal optimized function
2365 */
2366
2367 if (ximage->bits_per_pixel == 8)
2368 ximage->f.put_pixel = PutPixel8;
2369 else if (((ximage->bits_per_pixel | ximage->depth) == 1) &&
2370 (ximage->byte_order == ximage->bitmap_bit_order))
2371 if (ximage->bitmap_bit_order == MSBFirst)
2372 ximage->f.put_pixel = PutPixel1MSB;
2373 else
2374 ximage->f.put_pixel = PutPixel1LSB;
2375 else if (ximage->bits_per_pixel == 16)
2376 if (ximage->bitmap_bit_order == MSBFirst)
2377 ximage->f.put_pixel = PutPixel16MSB;
2378 else
2379 ximage->f.put_pixel = PutPixel16LSB;
2380 else if (ximage->bits_per_pixel == 32)
2381 #if !defined(WORD64) && !defined(LONG64)
2382 if (*((char *)&byteorderpixel) == ximage->byte_order)
2383 ximage->f.put_pixel = PutPixel32;
2384 else
2385 #endif
2386 if (ximage->bitmap_bit_order == MSBFirst)
2387 ximage->f.put_pixel = PutPixel32MSB;
2388 else
2389 ximage->f.put_pixel = PutPixel32LSB;
2390 else if ((ximage->bits_per_pixel | ximage->depth) == 1)
2391 ximage->f.put_pixel = PutPixel1;
2392 else
2393 ximage->f.put_pixel = PutPixel;
2394 #endif /* not FOR_MSW && not AMIGA */
2395 }
2396
2397 /* create the shape mask image */
2398 if (mask_pixel_index != XpmUndefPixel && shapeimage_return) {
2399 ErrorStatus = CreateXImage(display, visual, 1, bitmap_format,
2400 width, height, &shapeimage);
2401 if (ErrorStatus != XpmSuccess)
2402 RETURN(ErrorStatus);
2403
2404 #if !defined(FOR_MSW) && !defined(AMIGA)
2405 if (shapeimage->bitmap_bit_order == MSBFirst)
2406 shapeimage->f.put_pixel = PutPixel1MSB;
2407 else
2408 shapeimage->f.put_pixel = PutPixel1LSB;
2409 #endif
2410 }
2411
2412 /*
2413 * read pixels and put them in the XImage
2414 */
2415 ErrorStatus = ParseAndPutPixels(
2416 #ifdef FOR_MSW
2417 display,
2418 #endif
2419 data, width, height, ncolors, cpp,
2420 colorTable, &hashtable,
2421 ximage, image_pixels,
2422 shapeimage, mask_pixels);
2423 XpmFree(image_pixels);
2424 image_pixels = NULL;
2425 XpmFree(mask_pixels);
2426 mask_pixels = NULL;
2427
2428 /*
2429 * free the hastable
2430 */
2431 if (ErrorStatus != XpmSuccess)
2432 RETURN(ErrorStatus)
2433 else if (USE_HASHTABLE)
2434 xpmHashTableFree(&hashtable);
2435
2436 /*
2437 * store the pixels comment line
2438 */
2439 if (cmts)
2440 xpmGetCmt(data, &pixels_cmt);
2441
2442 /*
2443 * parse extensions
2444 */
2445 if (info && (info->valuemask & XpmReturnExtensions))
2446 if (extensions) {
2447 ErrorStatus = xpmParseExtensions(data, &info->extensions,
2448 &info->nextensions);
2449 if (ErrorStatus != XpmSuccess)
2450 RETURN(ErrorStatus);
2451 } else {
2452 info->extensions = NULL;
2453 info->nextensions = 0;
2454 }
2455
2456 /*
2457 * store found informations in the XpmImage structure
2458 */
2459 image->width = width;
2460 image->height = height;
2461 image->cpp = cpp;
2462 image->ncolors = ncolors;
2463 image->colorTable = colorTable;
2464 image->data = NULL;
2465
2466 if (info) {
2467 if (cmts) {
2468 info->hints_cmt = hints_cmt;
2469 info->colors_cmt = colors_cmt;
2470 info->pixels_cmt = pixels_cmt;
2471 }
2472 if (hotspot) {
2473 info->x_hotspot = x_hotspot;
2474 info->y_hotspot = y_hotspot;
2475 info->valuemask |= XpmHotspot;
2476 }
2477 }
2478 /* if requested return used pixels in the XpmAttributes structure */
2479 if (attributes && (attributes->valuemask & XpmReturnPixels ||
2480 /* 3.2 backward compatibility code */
2481 attributes->valuemask & XpmReturnInfos)) {
2482 /* end 3.2 bc */
2483 attributes->pixels = used_pixels;
2484 attributes->npixels = nused_pixels;
2485 attributes->mask_pixel = mask_pixel_index;
2486 } else
2487 XpmFree(used_pixels);
2488
2489 /* if requested return alloc'ed pixels in the XpmAttributes structure */
2490 if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) {
2491 attributes->alloc_pixels = alloc_pixels;
2492 attributes->nalloc_pixels = nalloc_pixels;
2493 } else
2494 XpmFree(alloc_pixels);
2495
2496 /* return created images */
2497 if (image_return)
2498 *image_return = ximage;
2499 if (shapeimage_return)
2500 *shapeimage_return = shapeimage;
2501
2502 return (XpmSuccess);
2503
2504 /* exit point in case of error, free only locally allocated variables */
2505 error:
2506 if (USE_HASHTABLE)
2507 xpmHashTableFree(&hashtable);
2508 if (colorTable)
2509 xpmFreeColorTable(colorTable, ncolors);
2510 if (hints_cmt)
2511 XpmFree(hints_cmt);
2512 if (colors_cmt)
2513 XpmFree(colors_cmt);
2514 if (pixels_cmt)
2515 XpmFree(pixels_cmt);
2516 if (ximage)
2517 XDestroyImage(ximage);
2518 if (shapeimage)
2519 XDestroyImage(shapeimage);
2520 if (image_pixels)
2521 XpmFree(image_pixels);
2522 if (mask_pixels)
2523 XpmFree(mask_pixels);
2524 if (nalloc_pixels)
2525 (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL);
2526 if (alloc_pixels)
2527 XpmFree(alloc_pixels);
2528 if (used_pixels)
2529 XpmFree(used_pixels);
2530
2531 return (ErrorStatus);
2532 }
2533
2534 #ifdef __OS2__
2535 /* Visual Age cannot deal with old, non-ansi, code */
2536 static int ParseAndPutPixels(
2537 Display* dc
2538 , xpmData* data
2539 , unsigned int width
2540 , unsigned int height
2541 , unsigned int ncolors
2542 , unsigned int cpp
2543 , XpmColor* colorTable
2544 , xpmHashTable* hashtable
2545 , XImage* image
2546 , Pixel* image_pixels
2547 , XImage* shapeimage
2548 , Pixel* shape_pixels
2549 )
2550 #else
2551 static int
2552 ParseAndPutPixels(
2553 #ifdef FOR_MSW
2554 dc,
2555 #endif
2556 data, width, height, ncolors, cpp, colorTable, hashtable,
2557 image, image_pixels, shapeimage, shape_pixels)
2558 #ifdef FOR_MSW
2559 Display *dc;
2560 #endif
2561 xpmData *data;
2562 unsigned int width;
2563 unsigned int height;
2564 unsigned int ncolors;
2565 unsigned int cpp;
2566 XpmColor *colorTable;
2567 xpmHashTable *hashtable;
2568 XImage *image;
2569 Pixel *image_pixels;
2570 XImage *shapeimage;
2571 Pixel *shape_pixels;
2572 #endif
2573 {
2574 unsigned int a, x, y;
2575 #ifdef __OS2__
2576 HAB hab = WinQueryAnchorBlock(HWND_DESKTOP);
2577 DEVOPENSTRUC dop = {NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL};
2578 SIZEL sizl = {0, 0};
2579 POINTL point;
2580 #endif
2581
2582 switch (cpp) {
2583
2584 case (1): /* Optimize for single character
2585 * colors */
2586 {
2587 unsigned short colidx[256];
2588 #ifdef FOR_MSW
2589 HDC shapedc;
2590 HBITMAP obm, sobm;
2591
2592 if ( shapeimage ) {
2593 #ifdef __OS2__
2594 shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
2595 *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS);
2596 sobm = GpiSetBitmap(*dc, shapeimage->bitmap);
2597 #else
2598 shapedc = CreateCompatibleDC(*dc);
2599 sobm = SelectObject(shapedc, shapeimage->bitmap);
2600 #endif
2601 } else {
2602 shapedc = NULL;
2603 }
2604 #ifdef __OS2__
2605 obm = GpiSetBitmap(*dc, image->bitmap);
2606 #else
2607 obm = SelectObject(*dc, image->bitmap);
2608 #endif
2609
2610 #endif
2611
2612
2613 bzero((char *)colidx, 256 * sizeof(short));
2614 for (a = 0; a < ncolors; a++)
2615 colidx[(unsigned char)colorTable[a].string[0]] = a + 1;
2616
2617 for (y = 0; y < height; y++) {
2618 xpmNextString(data);
2619 for (x = 0; x < width; x++) {
2620 int c = xpmGetC(data);
2621
2622 if (c > 0 && c < 256 && colidx[c] != 0) {
2623 #ifndef FOR_MSW
2624 XPutPixel(image, x, y, image_pixels[colidx[c] - 1]);
2625 if (shapeimage)
2626 XPutPixel(shapeimage, x, y,
2627 shape_pixels[colidx[c] - 1]);
2628 #else
2629 #ifdef __OS2__
2630 point.x = x;
2631 point.y = y;
2632 GpiSetColor(*dc, (LONG)image_pixels[colidx[c] - 1]);
2633 GpiSetPel(*dc, &point);
2634 #else
2635 SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]);
2636 #endif
2637 if (shapedc) {
2638 #ifdef __OS2__
2639 point.x = x;
2640 point.y = y;
2641 GpiSetColor(*dc, (LONG)shape_pixels[colidx[c] - 1]);
2642 GpiSetPel(*dc, &point);
2643 #else
2644 SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);
2645 #endif
2646 }
2647 #endif
2648 } else
2649 return (XpmFileInvalid);
2650 }
2651 }
2652 #ifdef FOR_MSW
2653 if ( shapedc ) {
2654 #ifdef __OS2__
2655 GpiSetBitmap(*dc, sobm);
2656 GpiDestroyPS(*dc);
2657 DevCloseDC(shapedc);
2658 #else
2659 SelectObject(shapedc, sobm);
2660 DeleteDC(shapedc);
2661 #endif
2662 }
2663 #ifdef __OS2__
2664 GpiSetBitmap(*dc, obm);
2665 #else
2666 SelectObject(*dc, obm);
2667 #endif
2668 #endif
2669 }
2670 break;
2671
2672 case (2): /* Optimize for double character
2673 * colors */
2674 {
2675 /* free all allocated pointers at all exits */
2676 #define FREE_CIDX {int f; for (f = 0; f < 256; f++) \
2677 if (cidx[f]) XpmFree(cidx[f]);}
2678
2679 /* array of pointers malloced by need */
2680 unsigned short *cidx[256];
2681 int char1;
2682 #ifdef __OS2__
2683 HDC shapedc;
2684 #endif
2685
2686 bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */
2687 for (a = 0; a < ncolors; a++) {
2688 char1 = colorTable[a].string[0];
2689 if (cidx[char1] == NULL) { /* get new memory */
2690 cidx[char1] = (unsigned short *)
2691 XpmCalloc(256, sizeof(unsigned short));
2692 if (cidx[char1] == NULL) { /* new block failed */
2693 FREE_CIDX;
2694 return (XpmNoMemory);
2695 }
2696 }
2697 cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1;
2698 }
2699
2700 for (y = 0; y < height; y++) {
2701 xpmNextString(data);
2702 for (x = 0; x < width; x++) {
2703 int cc1 = xpmGetC(data);
2704 if (cc1 > 0 && cc1 < 256) {
2705 int cc2 = xpmGetC(data);
2706 if (cc2 > 0 && cc2 < 256 &&
2707 cidx[cc1] && cidx[cc1][cc2] != 0) {
2708 #ifndef FOR_MSW
2709 XPutPixel(image, x, y,
2710 image_pixels[cidx[cc1][cc2] - 1]);
2711 if (shapeimage)
2712 XPutPixel(shapeimage, x, y,
2713 shape_pixels[cidx[cc1][cc2] - 1]);
2714 #else
2715 #ifdef __OS2__
2716 shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
2717 *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS);
2718
2719 GpiSetBitmap(*dc, image->bitmap);
2720 point.x = x;
2721 point.y = y;
2722 GpiSetColor(*dc, (LONG)image_pixels[cidx[cc1][cc2] - 1]);
2723 GpiSetPel(*dc, &point);
2724 #else
2725 SelectObject(*dc, image->bitmap);
2726 SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]);
2727 #endif
2728 if (shapeimage) {
2729 #ifdef __OS2__
2730 GpiSetBitmap(*dc, shapeimage->bitmap);
2731 point.x = x;
2732 point.y = y;
2733 GpiSetColor(*dc, (LONG)shape_pixels[cidx[cc1][cc2] - 1]);
2734 GpiSetPel(*dc, &point);
2735 #else
2736 SelectObject(*dc, shapeimage->bitmap);
2737 SetPixel(*dc, x, y,
2738 shape_pixels[cidx[cc1][cc2] - 1]);
2739 #endif
2740 }
2741 #endif
2742 } else {
2743 FREE_CIDX;
2744 return (XpmFileInvalid);
2745 }
2746 } else {
2747 FREE_CIDX;
2748 return (XpmFileInvalid);
2749 }
2750 }
2751 }
2752 FREE_CIDX;
2753 }
2754 break;
2755
2756 default: /* Non-optimized case of long color
2757 * names */
2758 {
2759 char *s;
2760 char buf[BUFSIZ];
2761 #ifdef __OS2__
2762 HDC shapedc;
2763 #endif
2764
2765 buf[cpp] = '\0';
2766 if (USE_HASHTABLE) {
2767 xpmHashAtom *slot;
2768
2769 for (y = 0; y < height; y++) {
2770 xpmNextString(data);
2771 for (x = 0; x < width; x++) {
2772 for (a = 0, s = buf; a < cpp; a++, s++)
2773 *s = xpmGetC(data);
2774 slot = xpmHashSlot(hashtable, buf);
2775 if (!*slot) /* no color matches */
2776 return (XpmFileInvalid);
2777 #ifndef FOR_MSW
2778 XPutPixel(image, x, y,
2779 image_pixels[HashColorIndex(slot)]);
2780 if (shapeimage)
2781 XPutPixel(shapeimage, x, y,
2782 shape_pixels[HashColorIndex(slot)]);
2783 #else
2784 #ifdef __OS2__
2785
2786 shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
2787 *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS);
2788
2789 GpiSetBitmap(*dc, image->bitmap);
2790 point.x = x;
2791 point.y = y;
2792 GpiSetColor(*dc, (LONG)image_pixels[HashColorIndex(slot)]);
2793 GpiSetPel(*dc, &point);
2794 #else
2795 SelectObject(*dc, image->bitmap);
2796 SetPixel(*dc, x, y,
2797 image_pixels[HashColorIndex(slot)]);
2798 #endif
2799 if (shapeimage) {
2800 #ifdef __OS2__
2801 GpiSetBitmap(*dc, shapeimage->bitmap);
2802 point.x = x;
2803 point.y = y;
2804 GpiSetColor(*dc, (LONG)shape_pixels[HashColorIndex(slot)]);
2805 GpiSetPel(*dc, &point);
2806 #else
2807 SelectObject(*dc, shapeimage->bitmap);
2808 SetPixel(*dc, x, y,
2809 shape_pixels[HashColorIndex(slot)]);
2810 #endif
2811 }
2812 #endif
2813 }
2814 }
2815 } else {
2816 for (y = 0; y < height; y++) {
2817 xpmNextString(data);
2818 for (x = 0; x < width; x++) {
2819 for (a = 0, s = buf; a < cpp; a++, s++)
2820 *s = xpmGetC(data);
2821 for (a = 0; a < ncolors; a++)
2822 if (!strcmp(colorTable[a].string, buf))
2823 break;
2824 if (a == ncolors) /* no color matches */
2825 return (XpmFileInvalid);
2826 #ifndef FOR_MSW
2827 XPutPixel(image, x, y, image_pixels[a]);
2828 if (shapeimage)
2829 XPutPixel(shapeimage, x, y, shape_pixels[a]);
2830 #else
2831 #ifdef __OS2__
2832
2833 shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
2834 *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS);
2835
2836 GpiSetBitmap(*dc, image->bitmap);
2837 point.x = x;
2838 point.y = y;
2839 GpiSetColor(*dc, (LONG)image_pixels[a]);
2840 GpiSetPel(*dc, &point);
2841 #else
2842 SelectObject(*dc, image->bitmap);
2843 SetPixel(*dc, x, y, image_pixels[a]);
2844 #endif
2845 if (shapeimage) {
2846 #ifdef __OS2__
2847 GpiSetBitmap(*dc, image->bitmap);
2848 point.x = x;
2849 point.y = y;
2850 GpiSetColor(*dc, (LONG)shape_pixels[a]);
2851 GpiSetPel(*dc, &point);
2852 #else
2853 SelectObject(*dc, shapeimage->bitmap);
2854 SetPixel(*dc, x, y, shape_pixels[a]);
2855 #endif
2856 }
2857 #endif
2858 }
2859 }
2860 }
2861 }
2862 break;
2863 }
2864 return (XpmSuccess);
2865 }
wxWidgets (Impactor)