X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/16a12a3d27d3d3e2557bcde15365245ef2675bb4..51072df23ffcf5bdd4651dbe0ad5143b1e360119:/src/xpm/create.c diff --git a/src/xpm/create.c b/src/xpm/create.c index 1b1e592182..a667eb8f75 100644 --- a/src/xpm/create.c +++ b/src/xpm/create.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1989-94 GROUPE BULL + * Copyright (C) 1989-95 GROUPE BULL * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to @@ -28,7 +28,7 @@ * * * XPM library * * Create an X image and possibly its related shape mask * -* from the given xpmInternAttrib. * +* from the given XpmImage. * * * * Developed by Arnaud Le Hors * \*****************************************************************************/ @@ -38,22 +38,28 @@ * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94 */ -#include "xpm34p.h" -#ifdef VMS -#include "sys$library:ctype.h" -#else +/* + * The code related to AMIGA has been added by + * Lorens Younes (d93-hyo@nada.kth.se) 4/96 + */ + +#include "XpmI.h" #include -#endif LFUNC(xpmVisualType, int, (Visual *visual)); +LFUNC(AllocColor, int, (Display *display, Colormap colormap, + char *colorname, XColor *xcolor, void *closure)); +LFUNC(FreeColors, int, (Display *display, Colormap colormap, + Pixel *pixels, int n, void *closure)); + #ifndef FOR_MSW LFUNC(SetCloseColor, int, (Display *display, Colormap colormap, Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel, - Pixel **pixels, unsigned int *npixels, - XpmAttributes *attributes, - XColor *cols, int ncols)); + Pixel *alloc_pixels, unsigned int *nalloc_pixels, + XpmAttributes *attributes, XColor *cols, int ncols, + XpmAllocColorFunc allocColor, void *closure)); #else /* let the window system take care of close colors */ #endif @@ -61,56 +67,100 @@ LFUNC(SetCloseColor, int, (Display *display, Colormap colormap, LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel, Pixel *mask_pixel, - unsigned int *mask_pixel_index, Pixel **pixels, - unsigned int *npixels, XpmAttributes *attributes, - XColor *cols, int ncols)); + unsigned int *mask_pixel_index, + Pixel *alloc_pixels, unsigned int *nalloc_pixels, + Pixel *used_pixels, unsigned int *nused_pixels, + XpmAttributes *attributes, XColor *cols, int ncols, + XpmAllocColorFunc allocColor, void *closure)); LFUNC(CreateXImage, int, (Display *display, Visual *visual, - unsigned int depth, unsigned int width, - unsigned int height, XImage **image_return)); + unsigned int depth, int format, unsigned int width, + unsigned int height, XImage **image_return)); LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes, - XpmColor *ct, unsigned int ncolors, Pixel *ip, - Pixel *mp, unsigned int *mask_pixel, - Pixel **pixels, unsigned int *npixels)); + XpmColor *colors, unsigned int ncolors, + Pixel *image_pixels, Pixel *mask_pixels, + unsigned int *mask_pixel_index, + Pixel *alloc_pixels, unsigned int *nalloc_pixels, + Pixel *used_pixels, unsigned int *nused_pixels)); + +#ifndef FOR_MSW +LFUNC(ParseAndPutPixels, int, (xpmData *data, unsigned int width, + unsigned int height, unsigned int ncolors, + unsigned int cpp, XpmColor *colorTable, + xpmHashTable *hashtable, + XImage *image, Pixel *image_pixels, + XImage *mask, Pixel *mask_pixels)); +#else /* FOR_MSW */ +LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width, + unsigned int height, unsigned int ncolors, + unsigned int cpp, XpmColor *colorTable, + xpmHashTable *hashtable, + XImage *image, Pixel *image_pixels, + XImage *mask, Pixel *mask_pixels)); +#endif #ifndef FOR_MSW +# ifndef AMIGA /* XImage pixel routines */ -LFUNC(SetImagePixels, void, (XImage *image, unsigned int width, +LFUNC(PutImagePixels, void, (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -LFUNC(SetImagePixels32, void, (XImage *image, unsigned int width, +LFUNC(PutImagePixels32, void, (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -LFUNC(SetImagePixels16, void, (XImage *image, unsigned int width, +LFUNC(PutImagePixels16, void, (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -LFUNC(SetImagePixels8, void, (XImage *image, unsigned int width, +LFUNC(PutImagePixels8, void, (XImage *image, unsigned int width, + unsigned int height, unsigned int *pixelindex, + Pixel *pixels)); + +LFUNC(PutImagePixels1, void, (XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -LFUNC(SetImagePixels1, void, (XImage *image, unsigned int width, +LFUNC(PutPixel1, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel32, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel32MSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel32LSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel16MSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel16LSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel8, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel1MSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); +LFUNC(PutPixel1LSB, int, (XImage *ximage, int x, int y, unsigned long pixel)); + +# else /* AMIGA */ +LFUNC(APutImagePixels, void, (XImage *ximage, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -#else /* ndef FOR_MSW */ +# endif/* AMIGA */ +#else /* FOR_MSW */ /* FOR_MSW pixel routine */ -LFUNC(MSWSetImagePixels, void, (Display *dc, XImage *image, +LFUNC(MSWPutImagePixels, void, (Display *dc, XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels)); -#endif /* ndef FOR_MSW */ +#endif /* FOR_MSW */ #ifdef NEED_STRCASECMP -FUNC(strcasecmp, int, (char *s1, char *s2)); +FUNC(xpmstrcasecmp, int, (char *s1, char *s2)); /* * in case strcasecmp is not provided by the system here is one * which does the trick */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +int xpmstrcasecmp(register char* s1, register char* s2) +#else int -strcasecmp(register char *s1, register char *s2) +xpmstrcasecmp(s1, s2) + register char *s1, *s2; +#endif { register int c1, c2; @@ -130,19 +180,18 @@ strcasecmp(register char *s1, register char *s2) /* * return the default color key related to the given visual */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int xpmVisualType(Visual* visual) +#else static int -xpmVisualType(Visual *visual) +xpmVisualType(visual) + Visual *visual; +#endif { #ifndef FOR_MSW -/* Xlib.h defines this to be c_class or class, depending - * on whether we're doing C++ or C - */ -#if defined(__cplusplus) || defined(c_plusplus) - switch (visual->c_class) -#else - switch (visual->class) -#endif - { +# ifndef AMIGA + switch (visual->class) { case StaticGray: case GrayScale: switch (visual->map_entries) { @@ -156,6 +205,10 @@ xpmVisualType(Visual *visual) default: return (XPM_COLOR); } +# else + /* set the key explicitly in the XpmAttributes to override this */ + return (XPM_COLOR); +# endif #else /* there should be a similar switch for MSW */ return (XPM_COLOR); @@ -168,14 +221,55 @@ typedef struct { long closeness; } CloseColor; -static int -closeness_cmp(const void *a, const void *b) +#ifndef FOR_MSW +static int closeness_cmp(Const void* a, Const void* b) { CloseColor *x = (CloseColor *) a, *y = (CloseColor *) b; /* cast to int as qsort requires */ return (int) (x->closeness - y->closeness); } +#endif + + +/* default AllocColor function: + * call XParseColor if colorname is given, return negative value if failure + * call XAllocColor and return 0 if failure, positive otherwise + */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int +AllocColor( + Display* display +, Colormap colormap +, char* colorname +, XColor* xcolor +, void* closure +) +#else +static int +AllocColor(display, colormap, colorname, xcolor, closure) + Display *display; + Colormap colormap; + char *colorname; + XColor *xcolor; + void *closure; /* not used */ +#endif +{ + int status; + if (colorname) +#ifdef __OS2__ + if (!XParseColor(display, &colormap, colorname, xcolor)) + return -1; + status = XAllocColor(display, &colormap, xcolor); +#else + if (!XParseColor(display, colormap, colorname, xcolor)) + return -1; + status = XAllocColor(display, colormap, xcolor); +#endif + return status != 0 ? 1 : 0; +} + #ifndef FOR_MSW /* @@ -184,9 +278,21 @@ closeness_cmp(const void *a, const void *b) */ static int -SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, - Pixel *image_pixel, Pixel *mask_pixel, Pixel **pixels, unsigned int *npixels, XpmAttributes *attributes, - XColor *cols, int ncols) +SetCloseColor(display, colormap, visual, col, image_pixel, mask_pixel, + alloc_pixels, nalloc_pixels, attributes, cols, ncols, + allocColor, closure) + Display *display; + Colormap colormap; + Visual *visual; + XColor *col; + Pixel *image_pixel, *mask_pixel; + Pixel *alloc_pixels; + unsigned int *nalloc_pixels; + XpmAttributes *attributes; + XColor *cols; + int ncols; + XpmAllocColorFunc allocColor; + void *closure; { /* @@ -199,6 +305,7 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, long int red_closeness, green_closeness, blue_closeness; int n; + Bool alloc_color; if (attributes && (attributes->valuemask & XpmCloseness)) red_closeness = green_closeness = blue_closeness = @@ -208,7 +315,10 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, green_closeness = attributes->green_closeness; blue_closeness = attributes->blue_closeness; } - + if (attributes && (attributes->valuemask & XpmAllocCloseColors)) + alloc_color = attributes->alloc_close_colors; + else + alloc_color = True; /* * We sort the colormap by closeness and try to allocate the color @@ -280,20 +390,28 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, (long) cols[c].green <= (long) col->green + green_closeness && (long) cols[c].blue >= (long) col->blue - blue_closeness && (long) cols[c].blue <= (long) col->blue + blue_closeness) { - if (XAllocColor(display, colormap, &cols[c])) { + if (alloc_color) { + if ((*allocColor)(display, colormap, NULL, &cols[c], closure)){ + if (n == ITERATIONS) + XUngrabServer(display); + XpmFree(closenesses); + *image_pixel = cols[c].pixel; + *mask_pixel = 1; + alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel; + return (0); + } else { + ++i; + if (i == ncols) + break; + c = closenesses[i].cols_index; + } + } else { if (n == ITERATIONS) XUngrabServer(display); XpmFree(closenesses); *image_pixel = cols[c].pixel; *mask_pixel = 1; - (*pixels)[*npixels] = cols[c].pixel; - (*npixels)++; return (0); - } else { - ++i; - if (i == ncols) - break; - c = closenesses[i].cols_index; } } @@ -306,11 +424,10 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, if (i == 0 || i == ncols) /* no color close enough or cannot */ return (1); /* alloc any color (full of r/w's) */ - if (XAllocColor(display, colormap, col)) { + if ((*allocColor)(display, colormap, NULL, col, closure)) { *image_pixel = col->pixel; *mask_pixel = 1; - (*pixels)[*npixels] = col->pixel; - (*npixels)++; + alloc_pixels[(*nalloc_pixels)++] = col->pixel; return (0); } else { /* colormap has probably changed, so * re-read... */ @@ -318,7 +435,7 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, XGrabServer(display); #if 0 - if (visual->c_class == DirectColor) { + if (visual->class == DirectColor) { /* TODO */ } else #endif @@ -331,9 +448,9 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, #define USE_CLOSECOLOR attributes && \ (((attributes->valuemask & XpmCloseness) && attributes->closeness != 0) \ || ((attributes->valuemask & XpmRGBCloseness) && \ - attributes->red_closeness != 0 \ - && attributes->green_closeness != 0 \ - && attributes->blue_closeness != 0)) + (attributes->red_closeness != 0 \ + || attributes->green_closeness != 0 \ + || attributes->blue_closeness != 0))) #else /* FOR_MSW part */ @@ -345,61 +462,146 @@ SetCloseColor(Display *display, Colormap colormap, Visual *visual, XColor *col, * return 0 if success, 1 otherwise. */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int +SetColor( + Display* display +, Colormap colormap +, Visual* visual +, char* colorname +, unsigned int color_index +, Pixel* image_pixel +, Pixel* mask_pixel +, unsigned int* mask_pixel_index +, Pixel* alloc_pixels +, unsigned int* nalloc_pixels +, Pixel* used_pixels +, unsigned int* nused_pixels +, XpmAttributes* attributes +, XColor* cols +, int ncols +, XpmAllocColorFunc allocColor +, void* closure +) +#else static int -SetColor(Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, - Pixel *image_pixel, Pixel *mask_pixel, unsigned int *mask_pixel_index, - Pixel **pixels, unsigned int *npixels, XpmAttributes *attributes, XColor *cols, int ncols) +SetColor(display, colormap, visual, colorname, color_index, + image_pixel, mask_pixel, mask_pixel_index, + alloc_pixels, nalloc_pixels, used_pixels, nused_pixels, + attributes, cols, ncols, allocColor, closure) + Display *display; + Colormap colormap; + Visual *visual; + char *colorname; + unsigned int color_index; + Pixel *image_pixel, *mask_pixel; + unsigned int *mask_pixel_index; + Pixel *alloc_pixels; + unsigned int *nalloc_pixels; + Pixel *used_pixels; + unsigned int *nused_pixels; + XpmAttributes *attributes; + XColor *cols; + int ncols; + XpmAllocColorFunc allocColor; + void *closure; +#endif { XColor xcolor; + int status; - if (strcasecmp(colorname, TRANSPARENT_COLOR)) { -#ifdef wx_msw - if (!XParseColor(display, (Colormap *)colormap, colorname, &xcolor)) -#else - if (!XParseColor(display, (Colormap)colormap, colorname, &xcolor)) -#endif + if (xpmstrcasecmp(colorname, TRANSPARENT_COLOR)) { + status = (*allocColor)(display, colormap, colorname, &xcolor, closure); + if (status < 0) /* parse color failed */ return (1); -#ifdef wx_msw - if (!XAllocColor(display, (Colormap *)colormap, &xcolor)) { -#else - if (!XAllocColor(display, (Colormap)colormap, &xcolor)) { -#endif + + if (status == 0) { #ifndef FOR_MSW if (USE_CLOSECOLOR) return (SetCloseColor(display, colormap, visual, &xcolor, - image_pixel, mask_pixel, pixels, npixels, - attributes, cols, ncols)); + image_pixel, mask_pixel, + alloc_pixels, nalloc_pixels, + attributes, cols, ncols, + allocColor, closure)); else #endif /* ndef FOR_MSW */ return (1); - } + } else + alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel; *image_pixel = xcolor.pixel; +#ifndef FOR_MSW *mask_pixel = 1; - (*pixels)[*npixels] = xcolor.pixel; - (*npixels)++; +#else +#ifdef __OS2__ + *mask_pixel = OS2RGB(0,0,0); +#else + *mask_pixel = RGB(0,0,0); +#endif +#endif + used_pixels[(*nused_pixels)++] = xcolor.pixel; } else { *image_pixel = 0; +#ifndef FOR_MSW *mask_pixel = 0; - *mask_pixel_index = color_index; /* store the color table index */ +#else +#ifdef __OS2__ + *mask_pixel = OS2RGB(255,255,255); +#else + *mask_pixel = RGB(255,255,255); +#endif +#endif + /* store the color table index */ + *mask_pixel_index = color_index; } return (0); } - +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int +CreateColors( + Display* display +, XpmAttributes* attributes +, XpmColor* colors +, unsigned int ncolors +, Pixel* image_pixels +, Pixel* mask_pixels +, unsigned int* mask_pixel_index +, Pixel* alloc_pixels +, unsigned int* nalloc_pixels +, Pixel* used_pixels +, unsigned int* nused_pixels +) +#else static int -CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned int ncolors, - Pixel *ip, Pixel *mp, unsigned int *mask_pixel, Pixel **pixels, unsigned int *npixels) +CreateColors(display, attributes, colors, ncolors, image_pixels, mask_pixels, + mask_pixel_index, alloc_pixels, nalloc_pixels, + used_pixels, nused_pixels) + Display *display; + XpmAttributes *attributes; + XpmColor *colors; + unsigned int ncolors; + Pixel *image_pixels; + Pixel *mask_pixels; + unsigned int *mask_pixel_index; + Pixel *alloc_pixels; + unsigned int *nalloc_pixels; + Pixel *used_pixels; + unsigned int *nused_pixels; +#endif { /* variables stored in the XpmAttributes structure */ Visual *visual; Colormap colormap; XpmColorSymbol *colorsymbols; unsigned int numsymbols; + XpmAllocColorFunc allocColor; + void *closure; char *colorname; - unsigned int a, b, l; - int pixel_defined; - unsigned int key; + unsigned int color, key; + Bool pixel_defined; XpmColorSymbol *symbol; char **defaults; int ErrorStatus = XpmSuccess; @@ -423,21 +625,30 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned else visual = XDefaultVisual(display, XDefaultScreen(display)); - if (attributes && attributes->valuemask & XpmColormap) + if (attributes && (attributes->valuemask & XpmColormap)) colormap = attributes->colormap; else colormap = XDefaultColormap(display, XDefaultScreen(display)); - if (attributes && attributes->valuemask & XpmColorKey) + if (attributes && (attributes->valuemask & XpmColorKey)) key = attributes->color_key; else key = xpmVisualType(visual); + if (attributes && (attributes->valuemask & XpmAllocColor)) + allocColor = attributes->alloc_color; + else + allocColor = AllocColor; + if (attributes && (attributes->valuemask & XpmColorClosure)) + closure = attributes->color_closure; + else + closure = NULL; + #ifndef FOR_MSW if (USE_CLOSECOLOR) { /* originally from SetCloseColor */ #if 0 - if (visual->c_class == DirectColor) { + if (visual->class == DirectColor) { /* * TODO: Implement close colors for DirectColor visuals. This is @@ -451,7 +662,11 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned #endif int i; +#ifndef AMIGA ncols = visual->map_entries; +#else + ncols = colormap->Count; +#endif cols = (XColor *) XpmCalloc(ncols, sizeof(XColor)); for (i = 0; i < ncols; ++i) cols[i].pixel = i; @@ -478,17 +693,21 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned break; } - for (a = 0; a < ncolors; a++, ct++, ip++, mp++) { + for (color = 0; color < ncolors; color++, colors++, + image_pixels++, mask_pixels++) { colorname = NULL; pixel_defined = False; - defaults = (char **) ct; + defaults = (char **) colors; /* * look for a defined symbol */ if (numsymbols) { + + unsigned int n; + s = defaults[1]; - for (l = 0, symbol = colorsymbols; l < numsymbols; l++, symbol++) { + for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) { if (symbol->name && s && !strcmp(symbol->name, s)) /* override name */ break; @@ -505,11 +724,11 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned ++def_index; } if (def_index >= 2 && defaults[def_index] != NULL && - !strcasecmp(symbol->value, defaults[def_index])) + !xpmstrcasecmp(symbol->value, defaults[def_index])) break; } } - if (l != numsymbols) { + if (n != numsymbols) { if (symbol->name && symbol->value) colorname = symbol->value; else @@ -517,39 +736,50 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned } } if (!pixel_defined) { /* pixel not given as symbol value */ + + unsigned int k; + if (colorname) { /* colorname given as symbol value */ - if (!SetColor(display, colormap, visual, colorname, a, ip, mp, - mask_pixel, pixels, npixels, attributes, - cols, ncols)) + if (!SetColor(display, colormap, visual, colorname, color, + image_pixels, mask_pixels, mask_pixel_index, + alloc_pixels, nalloc_pixels, used_pixels, + nused_pixels, attributes, cols, ncols, + allocColor, closure)) pixel_defined = True; else ErrorStatus = XpmColorError; } - b = key; - while (!pixel_defined && b > 1) { - if (defaults[b]) { - if (!SetColor(display, colormap, visual, defaults[b], - a, ip, mp, mask_pixel, pixels, npixels, - attributes, cols, ncols)) { + k = key; + while (!pixel_defined && k > 1) { + if (defaults[k]) { + if (!SetColor(display, colormap, visual, defaults[k], + color, image_pixels, mask_pixels, + mask_pixel_index, alloc_pixels, + nalloc_pixels, used_pixels, nused_pixels, + attributes, cols, ncols, + allocColor, closure)) { pixel_defined = True; break; } else ErrorStatus = XpmColorError; } - b--; + k--; } - b = key + 1; - while (!pixel_defined && b < NKEYS + 1) { - if (defaults[b]) { - if (!SetColor(display, colormap, visual, defaults[b], - a, ip, mp, mask_pixel, pixels, npixels, - attributes, cols, ncols)) { + k = key + 1; + while (!pixel_defined && k < NKEYS + 1) { + if (defaults[k]) { + if (!SetColor(display, colormap, visual, defaults[k], + color, image_pixels, mask_pixels, + mask_pixel_index, alloc_pixels, + nalloc_pixels, used_pixels, nused_pixels, + attributes, cols, ncols, + allocColor, closure)) { pixel_defined = True; break; } else ErrorStatus = XpmColorError; } - b++; + k++; } if (!pixel_defined) { if (cols) @@ -557,13 +787,17 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned return (XpmColorFailed); } } else { - *ip = colorsymbols[l].pixel; + /* simply use the given pixel */ + *image_pixels = symbol->pixel; + /* the following makes the mask to be built even if none + is given a particular pixel */ if (symbol->value - && !strcasecmp(symbol->value, TRANSPARENT_COLOR)) { - *mp = 0; - *mask_pixel = 0; + && !xpmstrcasecmp(symbol->value, TRANSPARENT_COLOR)) { + *mask_pixels = 0; + *mask_pixel_index = color; } else - *mp = 1; + *mask_pixels = 1; + used_pixels[(*nused_pixels)++] = *image_pixels; } } if (cols) @@ -572,39 +806,85 @@ CreateColors(Display *display, XpmAttributes *attributes, XpmColor *ct, unsigned } -/* function call in case of error, frees only locally allocated variables */ +/* default FreeColors function, simply call XFreeColors */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int +FreeColors( + Display* display +, Colormap colormap +, Pixel* pixels +, int n +, void* closure +) +#else +static int +FreeColors(display, colormap, pixels, n, closure) + Display *display; + Colormap colormap; + Pixel *pixels; + int n; + void *closure; /* not used */ +#endif +{ + return XFreeColors(display, colormap, pixels, n, 0); +} + + +/* function call in case of error */ #undef RETURN #define RETURN(status) \ { \ - if (ximage) XDestroyImage(ximage); \ - if (shapeimage) XDestroyImage(shapeimage); \ - if (ximage_pixels) XpmFree(ximage_pixels); \ - if (mask_pixels) XpmFree(mask_pixels); \ - if (npixels) XFreeColors(display, colormap, pixels, npixels, 0); \ - if (pixels) XpmFree(pixels); \ - return (status); \ + ErrorStatus = status; \ + goto error; \ } +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +int XpmCreateImageFromXpmImage( + Display* display +, XpmImage* image +, XImage** image_return +, XImage** shapeimage_return +, XpmAttributes* attributes +) +#else int -XpmCreateImageFromXpmImage(Display *display, XpmImage *image, - XImage **image_return, XImage **shapeimage_return, XpmAttributes *attributes) +XpmCreateImageFromXpmImage(display, image, + image_return, shapeimage_return, attributes) + Display *display; + XpmImage *image; + XImage **image_return; + XImage **shapeimage_return; + XpmAttributes *attributes; +#endif { +#ifdef __OS2__ + HAB hab = WinQueryAnchorBlock(HWND_DESKTOP); + HPS hps; + SIZEL sizl = {0, 0}; +#endif /* variables stored in the XpmAttributes structure */ Visual *visual; Colormap colormap; unsigned int depth; + int bitmap_format; + XpmFreeColorsFunc freeColors; + void *closure; /* variables to return */ XImage *ximage = NULL; XImage *shapeimage = NULL; - unsigned int mask_pixel; + unsigned int mask_pixel_index = XpmUndefPixel; int ErrorStatus; /* calculation variables */ - Pixel *ximage_pixels = NULL; + Pixel *image_pixels = NULL; Pixel *mask_pixels = NULL; - Pixel *pixels = NULL; /* allocated pixels */ - unsigned int npixels = 0; /* number of allocated pixels */ + Pixel *alloc_pixels = NULL; + Pixel *used_pixels = NULL; + unsigned int nalloc_pixels = 0; + unsigned int nused_pixels = 0; /* initialize return values */ if (image_return) @@ -628,28 +908,46 @@ XpmCreateImageFromXpmImage(Display *display, XpmImage *image, else depth = XDefaultDepth(display, XDefaultScreen(display)); + if (attributes && (attributes->valuemask & XpmBitmapFormat)) + bitmap_format = attributes->bitmap_format; + else + bitmap_format = ZPixmap; + + if (attributes && (attributes->valuemask & XpmFreeColors)) + freeColors = attributes->free_colors; + else + freeColors = FreeColors; + if (attributes && (attributes->valuemask & XpmColorClosure)) + closure = attributes->color_closure; + else + closure = NULL; + ErrorStatus = XpmSuccess; /* malloc pixels index tables */ - ximage_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); - if (!ximage_pixels) + image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); + if (!image_pixels) return (XpmNoMemory); mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); if (!mask_pixels) RETURN(XpmNoMemory); - mask_pixel = XpmUndefPixel; + /* maximum of allocated pixels will be the number of colors */ + alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); + if (!alloc_pixels) + RETURN(XpmNoMemory); /* maximum of allocated pixels will be the number of colors */ - pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); - if (!pixels) + used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors); + if (!used_pixels) RETURN(XpmNoMemory); /* get pixel colors, store them in index tables */ ErrorStatus = CreateColors(display, attributes, image->colorTable, - image->ncolors, ximage_pixels, mask_pixels, - &mask_pixel, &pixels, &npixels); + image->ncolors, image_pixels, mask_pixels, + &mask_pixel_index, alloc_pixels, &nalloc_pixels, + used_pixels, &nused_pixels); if (ErrorStatus != XpmSuccess && (ErrorStatus < 0 || (attributes @@ -660,98 +958,84 @@ XpmCreateImageFromXpmImage(Display *display, XpmImage *image, /* create the ximage */ if (image_return) { ErrorStatus = CreateXImage(display, visual, depth, + (depth == 1 ? bitmap_format : ZPixmap), image->width, image->height, &ximage); if (ErrorStatus != XpmSuccess) RETURN(ErrorStatus); #ifndef FOR_MSW +# ifndef AMIGA /* - * set the ximage data - * - * In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use - * optimized functions, otherwise use slower but sure general one. - * + * set the ximage data using optimized functions for ZPixmap */ - if (ximage->depth == 1) - SetImagePixels1(ximage, image->width, image->height, - image->data, ximage_pixels); - else if (ximage->bits_per_pixel == 8) - SetImagePixels8(ximage, image->width, image->height, - image->data, ximage_pixels); + if (ximage->bits_per_pixel == 8) + PutImagePixels8(ximage, image->width, image->height, + image->data, image_pixels); + else if (((ximage->bits_per_pixel | ximage->depth) == 1) && + (ximage->byte_order == ximage->bitmap_bit_order)) + PutImagePixels1(ximage, image->width, image->height, + image->data, image_pixels); else if (ximage->bits_per_pixel == 16) - SetImagePixels16(ximage, image->width, image->height, - image->data, ximage_pixels); + PutImagePixels16(ximage, image->width, image->height, + image->data, image_pixels); else if (ximage->bits_per_pixel == 32) - SetImagePixels32(ximage, image->width, image->height, - image->data, ximage_pixels); + PutImagePixels32(ximage, image->width, image->height, + image->data, image_pixels); else - SetImagePixels(ximage, image->width, image->height, - image->data, ximage_pixels); + PutImagePixels(ximage, image->width, image->height, + image->data, image_pixels); +# else /* AMIGA */ + APutImagePixels(ximage, image->width, image->height, + image->data, image_pixels); +# endif #else /* FOR_MSW */ - MSWSetImagePixels(display, ximage, image->width, image->height, - image->data, ximage_pixels); + MSWPutImagePixels(display, ximage, image->width, image->height, + image->data, image_pixels); #endif } /* create the shape mask image */ - if (mask_pixel != XpmUndefPixel && shapeimage_return) { - ErrorStatus = CreateXImage(display, visual, 1, image->width, - image->height, &shapeimage); + if (mask_pixel_index != XpmUndefPixel && shapeimage_return) { + ErrorStatus = CreateXImage(display, visual, 1, bitmap_format, + image->width, image->height, &shapeimage); if (ErrorStatus != XpmSuccess) RETURN(ErrorStatus); #ifndef FOR_MSW - SetImagePixels1(shapeimage, image->width, image->height, +# ifndef AMIGA + PutImagePixels1(shapeimage, image->width, image->height, image->data, mask_pixels); -#else - MSWSetImagePixels(display, shapeimage, image->width, image->height, +# else /* AMIGA */ + APutImagePixels(shapeimage, image->width, image->height, + image->data, mask_pixels); +# endif +#else /* FOR_MSW */ + MSWPutImagePixels(display, shapeimage, image->width, image->height, image->data, mask_pixels); #endif } + XpmFree(image_pixels); XpmFree(mask_pixels); - XpmFree(pixels); - /* if requested store alloc'ed pixels in the XpmAttributes structure */ - if (attributes) { - if (attributes->valuemask & XpmReturnPixels || -/* 3.2 backward compatibility code */ - attributes->valuemask & XpmReturnInfos) { -/* end 3.2 bc */ - if (mask_pixel != XpmUndefPixel) { - Pixel *pixels, *p1, *p2; - unsigned int a; - - attributes->npixels = image->ncolors - 1; - pixels = (Pixel *) XpmMalloc(sizeof(Pixel) - * attributes->npixels); - if (pixels) { - p1 = ximage_pixels; - p2 = pixels; - for (a = 0; a < image->ncolors; a++, p1++) - if (a != mask_pixel) - *p2++ = *p1; - attributes->pixels = pixels; - } else { - /* if error just say we can't return requested data */ - attributes->valuemask &= ~XpmReturnPixels; + /* if requested return used pixels in the XpmAttributes structure */ + if (attributes && (attributes->valuemask & XpmReturnPixels || /* 3.2 backward compatibility code */ - attributes->valuemask &= ~XpmReturnInfos; + attributes->valuemask & XpmReturnInfos)) { /* end 3.2 bc */ - attributes->pixels = NULL; - attributes->npixels = 0; - } - XpmFree(ximage_pixels); - } else { - attributes->pixels = ximage_pixels; - attributes->npixels = image->ncolors; - } - attributes->mask_pixel = mask_pixel; - } else - XpmFree(ximage_pixels); + attributes->pixels = used_pixels; + attributes->npixels = nused_pixels; + attributes->mask_pixel = mask_pixel_index; } else - XpmFree(ximage_pixels); + XpmFree(used_pixels); + + /* if requested return alloc'ed pixels in the XpmAttributes structure */ + if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) { + attributes->alloc_pixels = alloc_pixels; + attributes->nalloc_pixels = nalloc_pixels; + } else + XpmFree(alloc_pixels); /* return created images */ if (image_return) @@ -760,15 +1044,53 @@ XpmCreateImageFromXpmImage(Display *display, XpmImage *image, *shapeimage_return = shapeimage; return (ErrorStatus); + +/* exit point in case of error, free only locally allocated variables */ +error: + if (ximage) + XDestroyImage(ximage); + if (shapeimage) + XDestroyImage(shapeimage); + if (image_pixels) + XpmFree(image_pixels); + if (mask_pixels) + XpmFree(mask_pixels); + if (nalloc_pixels) + (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL); + if (alloc_pixels) + XpmFree(alloc_pixels); + if (used_pixels) + XpmFree(used_pixels); + + return (ErrorStatus); } /* - * Create an XImage + * Create an XImage with its data */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int CreateXImage( + Display* display +, Visual* visual +, unsigned int depth +, int format +, unsigned int width +, unsigned int height +, XImage** image_return +) +#else static int -CreateXImage(Display *display, Visual *visual, unsigned int depth, - unsigned int width, unsigned int height, XImage **image_return) +CreateXImage(display, visual, depth, format, width, height, image_return) + Display *display; + Visual *visual; + unsigned int depth; + int format; + unsigned int width; + unsigned int height; + XImage **image_return; +#endif { int bitmap_pad; @@ -781,12 +1103,12 @@ CreateXImage(Display *display, Visual *visual, unsigned int depth, bitmap_pad = 8; /* then create the XImage with data = NULL and bytes_per_line = 0 */ - *image_return = XCreateImage(display, visual, depth, ZPixmap, 0, 0, + *image_return = XCreateImage(display, visual, depth, format, 0, 0, width, height, bitmap_pad, 0); if (!*image_return) return (XpmNoMemory); -#ifndef FOR_MSW +#if !defined(FOR_MSW) && !defined(AMIGA) /* now that bytes_per_line must have been set properly alloc data */ (*image_return)->data = (char *) XpmMalloc((*image_return)->bytes_per_line * height); @@ -797,12 +1119,13 @@ CreateXImage(Display *display, Visual *visual, unsigned int depth, return (XpmNoMemory); } #else - /* under FOR_MSW XCreateImage has done it all */ + /* under FOR_MSW and AMIGA XCreateImage has done it all */ #endif return (XpmSuccess); } #ifndef FOR_MSW +# ifndef AMIGA /* * The functions below are written from X11R5 MIT's code (XImUtil.c) * @@ -852,8 +1175,16 @@ static unsigned char Const _reverse_byte[0x100] = { 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff }; +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ static int -_XReverse_Bytes(register unsigned char *bpt, register int nb) +_XReverse_Bytes(register unsigned char* bpt, register int nb) +#else +static int +_XReverse_Bytes(bpt, nb) + register unsigned char *bpt; + register int nb; +#endif { do { *bpt = _reverse_byte[*bpt]; @@ -863,8 +1194,15 @@ _XReverse_Bytes(register unsigned char *bpt, register int nb) } +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +void xpm_xynormalizeimagebits(register unsigned char* bp, register XImage* img) +#else void -xpm_xynormalizeimagebits(register unsigned char *bp, register XImage *img) +xpm_xynormalizeimagebits(bp, img) + register unsigned char *bp; + register XImage *img; +#endif { register unsigned char c; @@ -891,8 +1229,15 @@ xpm_xynormalizeimagebits(register unsigned char *bp, register XImage *img) _XReverse_Bytes(bp, img->bitmap_unit >> 3); } +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +void xpm_znormalizeimagebits(register unsigned char* bp, register XImage* img) +#else void -xpm_znormalizeimagebits(register unsigned char *bp, register XImage *img) +xpm_znormalizeimagebits(bp, img) + register unsigned char *bp; + register XImage *img; +#endif { register unsigned char c; @@ -934,15 +1279,24 @@ static unsigned char Const _lomask[0x09] = { static unsigned char Const _himask[0x09] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00}; +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void _putbits( + register char* src +, int dstoffset +, register int numbits +, register char* dst +) +#else static void -_putbits(register char *src, int dstoffset, register int numbits, register char *dst) - -/* register char *src; */ /* address of source bit string */ -/* int dstoffset; */ /* bit offset into destination; +_putbits(src, dstoffset, numbits, dst) + register char *src; /* address of source bit string */ + int dstoffset; /* bit offset into destination; * range is 0-31 */ -/* register int numbits; */ /* number of bits to copy to + register int numbits; /* number of bits to copy to * destination */ -/* register char *dst; */ /* address of destination bit string */ + register char *dst; /* address of destination bit string */ +#endif { register unsigned char chlo, chhi; int hibits; @@ -983,8 +1337,24 @@ _putbits(register char *src, int dstoffset, register int numbits, register char * copy the temp back into the destination image data */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void PutImagePixels( +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) +#else static void -SetImagePixels(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) +PutImagePixels(image, width, height, pixelindex, pixels) + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { register char *src; register char *dst; @@ -1050,13 +1420,13 @@ SetImagePixels(XImage *image, unsigned int width, unsigned int height, unsigned * write pixels into a 32-bits Z image data structure */ -#ifndef WORD64 +#if !defined(WORD64) && !defined(LONG64) /* this item is static but deterministic so let it slide; doesn't * hurt re-entrancy of this library. Note if it is actually const then would * be OK under rules of ANSI-C but probably not C++ which may not * want to allocate space for it. */ -static unsigned long /* constant */ RTXpm_byteorderpixel = MSBFirst << 24; +static unsigned long byteorderpixel = MSBFirst << 24; #endif @@ -1065,8 +1435,25 @@ static unsigned long /* constant */ RTXpm_byteorderpixel = MSBFirst << 24; 3.2e code - by default you get the speeded-up version. */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ static void -SetImagePixels32(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) +PutImagePixels32( +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) +#else +static void +PutImagePixels32(image, width, height, pixelindex, pixels) + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { unsigned char *data; unsigned int *iptr; @@ -1080,8 +1467,8 @@ SetImagePixels32(XImage *image, unsigned int width, unsigned int height, unsigne data = (unsigned char *) image->data; iptr = pixelindex; -#ifndef WORD64 - if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) { +#if !defined(WORD64) && !defined(LONG64) + if (*((char *) &byteorderpixel) == image->byte_order) { for (y = 0; y < height; y++) for (x = 0; x < width; x++, iptr++) { addr = &data[ZINDEX32(x, y, image)]; @@ -1117,8 +1504,8 @@ SetImagePixels32(XImage *image, unsigned int width, unsigned int height, unsigne data = (unsigned char *) image->data; iptr = pixelindex; -#ifndef WORD64 - if (*((char *) &RTXpm_byteorderpixel) == image->byte_order) { +#if !defined(WORD64) && !defined(LONG64) + if (*((char *) &byteorderpixel) == image->byte_order) { for (y = 0; y < height; y++) { data_ptr = data; max_data = data_ptr + (width << 2); @@ -1170,8 +1557,24 @@ SetImagePixels32(XImage *image, unsigned int width, unsigned int height, unsigne * write pixels into a 16-bits Z image data structure */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void PutImagePixels16( +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) +#else static void -SetImagePixels16(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) +PutImagePixels16(image, width, height, pixelindex, pixels) + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { unsigned char *data; unsigned int *iptr; @@ -1246,8 +1649,24 @@ SetImagePixels16(XImage *image, unsigned int width, unsigned int height, unsigne * write pixels into a 8-bits Z image data structure */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void PutImagePixels8( +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) +#else static void -SetImagePixels8(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) +PutImagePixels8(image, width, height, pixelindex, pixels) + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { char *data; unsigned int *iptr; @@ -1288,11 +1707,27 @@ SetImagePixels8(XImage *image, unsigned int width, unsigned int height, unsigned * write pixels into a 1-bit depth image data structure and **offset null** */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void PutImagePixels1( +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) +#else static void -SetImagePixels1(XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) +PutImagePixels1(image, width, height, pixelindex, pixels) + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { if (image->byte_order != image->bitmap_bit_order) - SetImagePixels(image, width, height, pixelindex, pixels); + PutImagePixels(image, width, height, pixelindex, pixels); else { unsigned int *iptr; int y; @@ -1397,9 +1832,26 @@ SetImagePixels1(XImage *image, unsigned int width, unsigned int height, unsigned } } +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +int XpmCreatePixmapFromXpmImage( +, Display* display +, Drawable d +, XpmImage* image +, Pixmap* pixmap_return +, Pixmap* shapemask_return +, XpmAttributes* attributes +#else int -XpmCreatePixmapFromXpmImage(Display *display, Drawable d, XpmImage *image, - Pixmap *pixmap_return, Pixmap *shapemask_return, XpmAttributes *attributes) +XpmCreatePixmapFromXpmImage(display, d, image, + pixmap_return, shapemask_return, attributes) + Display *display; + Drawable d; + XpmImage *image; + Pixmap *pixmap_return; + Pixmap *shapemask_return; + XpmAttributes *attributes; +#endif { XImage *ximage, *shapeimage; int ErrorStatus; @@ -1431,62 +1883,983 @@ XpmCreatePixmapFromXpmImage(Display *display, Drawable d, XpmImage *image, return (ErrorStatus); } -#else /* FOR_MSW part follows */ -#if !defined(__VISAGECPP__) +# else /* AMIGA */ + static void -MSWSetImagePixels(Display *dc, XImage *image, unsigned int width, unsigned int height, - unsigned int *pixelindex, Pixel *pixels) +APutImagePixels ( + XImage *image, + unsigned int width, + unsigned int height, + unsigned int *pixelindex, + Pixel *pixels) { - unsigned int *data = pixelindex; - unsigned int x, y; - - SelectObject(*dc, image->bitmap); - if (image->depth == 1) - { - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - SetPixel(*dc, x, y, (pixels[*(data++)] ? RGB(255,255,255) : 0)); /* data is [x+y*width] */ - } - } - } - else + unsigned int *data = pixelindex; + unsigned int x, y; + unsigned char *array; + XImage *tmp_img; + BOOL success = FALSE; + + array = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*array)); + if (array != NULL) + { + tmp_img = AllocXImage ((((width+15)>>4)<<4), 1, + image->rp->BitMap->Depth); + if (tmp_img != NULL) { - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */ - } - } + for (y = 0; y < height; ++y) + { + for (x = 0; x < width; ++x) + array[x] = pixels[*(data++)]; + WritePixelLine8 (image->rp, 0, y, width, array, tmp_img->rp); + } + FreeXImage (tmp_img); + success = TRUE; } + XpmFree (array); + } + + if (!success) + { + for (y = 0; y < height; ++y) + for (x = 0; x < width; ++x) + XPutPixel (image, x, y, pixels[*(data++)]); + } } + +# endif/* AMIGA */ +#else /* FOR_MSW part follows */ + +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static void MSWPutImagePixels( + Display* dc +, XImage* image +, unsigned int width +, unsigned int height +, unsigned int* pixelindex +, Pixel* pixels +) #else -void MSWSetImagePixels(Display *dc, XImage *image, unsigned int width, unsigned int height, - unsigned int *pixelindex, Pixel *pixels) +static void +MSWPutImagePixels(dc, image, width, height, pixelindex, pixels) + Display *dc; + XImage *image; + unsigned int width; + unsigned int height; + unsigned int *pixelindex; + Pixel *pixels; +#endif { unsigned int *data = pixelindex; unsigned int x, y; -// TODO: -/* - SelectObject(*dc, image->bitmap); - if (image->depth == 1) - { - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - SetPixel(*dc, x, y, (pixels[*(data++)] ? RGB(255,255,255) : 0)); - } - } - } - else - { - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - SetPixel(*dc, x, y, pixels[*(data++)]); - } - } + HBITMAP obm; + +#ifdef __OS2__ + POINTL point; + + obm = GpiSetBitmap(*dc, image->bitmap); +#else + obm = SelectObject(*dc, image->bitmap); +#endif + + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { +#ifdef __OS2__ + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)pixels[*(data++)]); + GpiSetPel(*dc, &point); +#else + + SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */ +#endif } -*/ - return; + } +#ifdef __OS2__ + GpiSetBitmap(*dc, obm); +#else + SelectObject(*dc, obm); +#endif } -#endif // __VISAGECPP__ - #endif /* FOR_MSW */ + + + +#if !defined(FOR_MSW) && !defined(AMIGA) + +static int +PutPixel1(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + register char *src; + register char *dst; + register int i; + register char *data; + Pixel px; + int nbytes; + + for (i=0, px=pixel; i>=8) + ((unsigned char *)&pixel)[i] = px; + src = &ximage->data[XYINDEX(x, y, ximage)]; + dst = (char *)&px; + px = 0; + nbytes = ximage->bitmap_unit >> 3; + for (i = nbytes; --i >= 0; ) *dst++ = *src++; + XYNORMALIZE(&px, ximage); + i = ((x + ximage->xoffset) % ximage->bitmap_unit); + _putbits ((char *)&pixel, i, 1, (char *)&px); + XYNORMALIZE(&px, ximage); + src = (char *) &px; + dst = &ximage->data[XYINDEX(x, y, ximage)]; + for (i = nbytes; --i >= 0; ) + *dst++ = *src++; + + return 1; +} + +static int +PutPixel(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + register char *src; + register char *dst; + register int i; + register char *data; + Pixel px; + int nbytes, ibpp; + + ibpp = ximage->bits_per_pixel; + if (ximage->depth == 4) + pixel &= 0xf; + for (i = 0, px = pixel; i < sizeof(unsigned long); i++, px >>= 8) + ((unsigned char *) &pixel)[i] = px; + src = &ximage->data[ZINDEX(x, y, ximage)]; + dst = (char *) &px; + px = 0; + nbytes = (ibpp + 7) >> 3; + for (i = nbytes; --i >= 0;) + *dst++ = *src++; + ZNORMALIZE(&px, ximage); + _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px); + ZNORMALIZE(&px, ximage); + src = (char *) &px; + dst = &ximage->data[ZINDEX(x, y, ximage)]; + for (i = nbytes; --i >= 0;) + *dst++ = *src++; + + return 1; +} + +static int +PutPixel32(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + unsigned char *addr; + + addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)]; + *((unsigned long *)addr) = pixel; + return 1; +} + +static int +PutPixel32MSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + unsigned char *addr; + + addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)]; + addr[0] = pixel >> 24; + addr[1] = pixel >> 16; + addr[2] = pixel >> 8; + addr[3] = pixel; + return 1; +} + +static int +PutPixel32LSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + unsigned char *addr; + + addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)]; + addr[3] = pixel >> 24; + addr[2] = pixel >> 16; + addr[1] = pixel >> 8; + addr[0] = pixel; + return 1; +} + +static int +PutPixel16MSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + unsigned char *addr; + + addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)]; + addr[0] = pixel >> 8; + addr[1] = pixel; + return 1; +} + +static int +PutPixel16LSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + unsigned char *addr; + + addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)]; + addr[1] = pixel >> 8; + addr[0] = pixel; + return 1; +} + +static int +PutPixel8(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + ximage->data[ZINDEX8(x, y, ximage)] = pixel; + return 1; +} + +static int +PutPixel1MSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + if (pixel & 1) + ximage->data[ZINDEX1(x, y, ximage)] |= 0x80 >> (x & 7); + else + ximage->data[ZINDEX1(x, y, ximage)] &= ~(0x80 >> (x & 7)); + return 1; +} + +static int +PutPixel1LSB(ximage, x, y, pixel) + register XImage *ximage; + int x; + int y; + unsigned long pixel; +{ + if (pixel & 1) + ximage->data[ZINDEX1(x, y, ximage)] |= 1 << (x & 7); + else + ximage->data[ZINDEX1(x, y, ximage)] &= ~(1 << (x & 7)); + return 1; +} + +#endif /* not FOR_MSW && not AMIGA */ + +/* + * This function parses an Xpm file or data and directly create an XImage + */ +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +int xpmParseDataAndCreate( + Display* display +, xpmData* data +, XImage** image_return +, XImage** shapeimage_return +, XpmImage* image +, XpmInfo* info +, XpmAttributes* attributes +) +#else +int +xpmParseDataAndCreate(display, data, image_return, shapeimage_return, + image, info, attributes) + Display *display; + xpmData *data; + XImage **image_return; + XImage **shapeimage_return; + XpmImage *image; + XpmInfo *info; + XpmAttributes *attributes; +#endif +{ + /* variables stored in the XpmAttributes structure */ + Visual *visual; + Colormap colormap; + unsigned int depth; + int bitmap_format; + XpmFreeColorsFunc freeColors; + void *closure; + + /* variables to return */ + XImage *ximage = NULL; + XImage *shapeimage = NULL; + unsigned int mask_pixel_index = XpmUndefPixel; + + /* calculation variables */ + Pixel *image_pixels = NULL; + Pixel *mask_pixels = NULL; + Pixel *alloc_pixels = NULL; + Pixel *used_pixels = NULL; + unsigned int nalloc_pixels = 0; + unsigned int nused_pixels = 0; + unsigned int width, height, ncolors, cpp; + unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0; + XpmColor *colorTable = NULL; + char *hints_cmt = NULL; + char *colors_cmt = NULL; + char *pixels_cmt = NULL; + + unsigned int cmts; + int ErrorStatus; + xpmHashTable hashtable; + + + /* initialize return values */ + if (image_return) + *image_return = NULL; + if (shapeimage_return) + *shapeimage_return = NULL; + + + /* retrieve information from the XpmAttributes */ + if (attributes && (attributes->valuemask & XpmVisual)) + visual = attributes->visual; + else + visual = XDefaultVisual(display, XDefaultScreen(display)); + + if (attributes && (attributes->valuemask & XpmColormap)) + colormap = attributes->colormap; + else + colormap = XDefaultColormap(display, XDefaultScreen(display)); + + if (attributes && (attributes->valuemask & XpmDepth)) + depth = attributes->depth; + else + depth = XDefaultDepth(display, XDefaultScreen(display)); + + if (attributes && (attributes->valuemask & XpmBitmapFormat)) + bitmap_format = attributes->bitmap_format; + else + bitmap_format = ZPixmap; + + if (attributes && (attributes->valuemask & XpmFreeColors)) + freeColors = attributes->free_colors; + else + freeColors = FreeColors; + if (attributes && (attributes->valuemask & XpmColorClosure)) + closure = attributes->color_closure; + else + closure = NULL; + + cmts = info && (info->valuemask & XpmReturnComments); + + /* + * parse the header + */ + ErrorStatus = xpmParseHeader(data); + if (ErrorStatus != XpmSuccess) + return (ErrorStatus); + + /* + * read values + */ + ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp, + &x_hotspot, &y_hotspot, &hotspot, + &extensions); + if (ErrorStatus != XpmSuccess) + return (ErrorStatus); + + /* + * store the hints comment line + */ + if (cmts) + xpmGetCmt(data, &hints_cmt); + + /* + * init the hastable + */ + if (USE_HASHTABLE) { + ErrorStatus = xpmHashTableInit(&hashtable); + if (ErrorStatus != XpmSuccess) + return (ErrorStatus); + } + + /* + * read colors + */ + ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable); + if (ErrorStatus != XpmSuccess) + RETURN(ErrorStatus); + + /* + * store the colors comment line + */ + if (cmts) + xpmGetCmt(data, &colors_cmt); + + /* malloc pixels index tables */ + image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors); + if (!image_pixels) + RETURN(XpmNoMemory); + + mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors); + if (!mask_pixels) + RETURN(XpmNoMemory); + + /* maximum of allocated pixels will be the number of colors */ + alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors); + if (!alloc_pixels) + RETURN(XpmNoMemory); + + /* maximum of allocated pixels will be the number of colors */ + used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors); + if (!used_pixels) + RETURN(XpmNoMemory); + + /* get pixel colors, store them in index tables */ + ErrorStatus = CreateColors(display, attributes, colorTable, ncolors, + image_pixels, mask_pixels, &mask_pixel_index, + alloc_pixels, &nalloc_pixels, used_pixels, + &nused_pixels); + + if (ErrorStatus != XpmSuccess + && (ErrorStatus < 0 || (attributes + && (attributes->valuemask & XpmExactColors) + && attributes->exactColors))) + RETURN(ErrorStatus); + + /* now create the ximage */ + if (image_return) { + ErrorStatus = CreateXImage(display, visual, depth, + (depth == 1 ? bitmap_format : ZPixmap), + width, height, &ximage); + if (ErrorStatus != XpmSuccess) + RETURN(ErrorStatus); + +#if !defined(FOR_MSW) && !defined(AMIGA) + + /* + * set the XImage pointer function, to be used with XPutPixel, + * to an internal optimized function + */ + + if (ximage->bits_per_pixel == 8) + ximage->f.put_pixel = PutPixel8; + else if (((ximage->bits_per_pixel | ximage->depth) == 1) && + (ximage->byte_order == ximage->bitmap_bit_order)) + if (ximage->bitmap_bit_order == MSBFirst) + ximage->f.put_pixel = PutPixel1MSB; + else + ximage->f.put_pixel = PutPixel1LSB; + else if (ximage->bits_per_pixel == 16) + if (ximage->bitmap_bit_order == MSBFirst) + ximage->f.put_pixel = PutPixel16MSB; + else + ximage->f.put_pixel = PutPixel16LSB; + else if (ximage->bits_per_pixel == 32) +#if !defined(WORD64) && !defined(LONG64) + if (*((char *)&byteorderpixel) == ximage->byte_order) + ximage->f.put_pixel = PutPixel32; + else +#endif + if (ximage->bitmap_bit_order == MSBFirst) + ximage->f.put_pixel = PutPixel32MSB; + else + ximage->f.put_pixel = PutPixel32LSB; + else if ((ximage->bits_per_pixel | ximage->depth) == 1) + ximage->f.put_pixel = PutPixel1; + else + ximage->f.put_pixel = PutPixel; +#endif /* not FOR_MSW && not AMIGA */ + } + + /* create the shape mask image */ + if (mask_pixel_index != XpmUndefPixel && shapeimage_return) { + ErrorStatus = CreateXImage(display, visual, 1, bitmap_format, + width, height, &shapeimage); + if (ErrorStatus != XpmSuccess) + RETURN(ErrorStatus); + +#if !defined(FOR_MSW) && !defined(AMIGA) + if (shapeimage->bitmap_bit_order == MSBFirst) + shapeimage->f.put_pixel = PutPixel1MSB; + else + shapeimage->f.put_pixel = PutPixel1LSB; +#endif + } + + /* + * read pixels and put them in the XImage + */ + ErrorStatus = ParseAndPutPixels( +#ifdef FOR_MSW + display, +#endif + data, width, height, ncolors, cpp, + colorTable, &hashtable, + ximage, image_pixels, + shapeimage, mask_pixels); + XpmFree(image_pixels); + image_pixels = NULL; + XpmFree(mask_pixels); + mask_pixels = NULL; + + /* + * free the hastable + */ + if (ErrorStatus != XpmSuccess) + RETURN(ErrorStatus) + else if (USE_HASHTABLE) + xpmHashTableFree(&hashtable); + + /* + * store the pixels comment line + */ + if (cmts) + xpmGetCmt(data, &pixels_cmt); + + /* + * parse extensions + */ + if (info && (info->valuemask & XpmReturnExtensions)) + if (extensions) { + ErrorStatus = xpmParseExtensions(data, &info->extensions, + &info->nextensions); + if (ErrorStatus != XpmSuccess) + RETURN(ErrorStatus); + } else { + info->extensions = NULL; + info->nextensions = 0; + } + + /* + * store found informations in the XpmImage structure + */ + image->width = width; + image->height = height; + image->cpp = cpp; + image->ncolors = ncolors; + image->colorTable = colorTable; + image->data = NULL; + + if (info) { + if (cmts) { + info->hints_cmt = hints_cmt; + info->colors_cmt = colors_cmt; + info->pixels_cmt = pixels_cmt; + } + if (hotspot) { + info->x_hotspot = x_hotspot; + info->y_hotspot = y_hotspot; + info->valuemask |= XpmHotspot; + } + } + /* if requested return used pixels in the XpmAttributes structure */ + if (attributes && (attributes->valuemask & XpmReturnPixels || +/* 3.2 backward compatibility code */ + attributes->valuemask & XpmReturnInfos)) { +/* end 3.2 bc */ + attributes->pixels = used_pixels; + attributes->npixels = nused_pixels; + attributes->mask_pixel = mask_pixel_index; + } else + XpmFree(used_pixels); + + /* if requested return alloc'ed pixels in the XpmAttributes structure */ + if (attributes && (attributes->valuemask & XpmReturnAllocPixels)) { + attributes->alloc_pixels = alloc_pixels; + attributes->nalloc_pixels = nalloc_pixels; + } else + XpmFree(alloc_pixels); + + /* return created images */ + if (image_return) + *image_return = ximage; + if (shapeimage_return) + *shapeimage_return = shapeimage; + + return (XpmSuccess); + +/* exit point in case of error, free only locally allocated variables */ +error: + if (USE_HASHTABLE) + xpmHashTableFree(&hashtable); + if (colorTable) + xpmFreeColorTable(colorTable, ncolors); + if (hints_cmt) + XpmFree(hints_cmt); + if (colors_cmt) + XpmFree(colors_cmt); + if (pixels_cmt) + XpmFree(pixels_cmt); + if (ximage) + XDestroyImage(ximage); + if (shapeimage) + XDestroyImage(shapeimage); + if (image_pixels) + XpmFree(image_pixels); + if (mask_pixels) + XpmFree(mask_pixels); + if (nalloc_pixels) + (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL); + if (alloc_pixels) + XpmFree(alloc_pixels); + if (used_pixels) + XpmFree(used_pixels); + + return (ErrorStatus); +} + +#ifdef __OS2__ +/* Visual Age cannot deal with old, non-ansi, code */ +static int ParseAndPutPixels( + Display* dc +, xpmData* data +, unsigned int width +, unsigned int height +, unsigned int ncolors +, unsigned int cpp +, XpmColor* colorTable +, xpmHashTable* hashtable +, XImage* image +, Pixel* image_pixels +, XImage* shapeimage +, Pixel* shape_pixels +) +#else +static int +ParseAndPutPixels( +#ifdef FOR_MSW + dc, +#endif + data, width, height, ncolors, cpp, colorTable, hashtable, + image, image_pixels, shapeimage, shape_pixels) +#ifdef FOR_MSW + Display *dc; +#endif + xpmData *data; + unsigned int width; + unsigned int height; + unsigned int ncolors; + unsigned int cpp; + XpmColor *colorTable; + xpmHashTable *hashtable; + XImage *image; + Pixel *image_pixels; + XImage *shapeimage; + Pixel *shape_pixels; +#endif +{ + unsigned int a, x, y; +#ifdef __OS2__ + HAB hab = WinQueryAnchorBlock(HWND_DESKTOP); + DEVOPENSTRUC dop = {NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL}; + SIZEL sizl = {0, 0}; + POINTL point; +#endif + + switch (cpp) { + + case (1): /* Optimize for single character + * colors */ + { + unsigned short colidx[256]; +#ifdef FOR_MSW + HDC shapedc; + HBITMAP obm, sobm; + + if ( shapeimage ) { +#ifdef __OS2__ + shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE); + *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS); + sobm = GpiSetBitmap(*dc, shapeimage->bitmap); +#else + shapedc = CreateCompatibleDC(*dc); + sobm = SelectObject(shapedc, shapeimage->bitmap); +#endif + } else { + shapedc = NULL; + } +#ifdef __OS2__ + obm = GpiSetBitmap(*dc, image->bitmap); +#else + obm = SelectObject(*dc, image->bitmap); +#endif + +#endif + + + bzero((char *)colidx, 256 * sizeof(short)); + for (a = 0; a < ncolors; a++) + colidx[(unsigned char)colorTable[a].string[0]] = a + 1; + + for (y = 0; y < height; y++) { + xpmNextString(data); + for (x = 0; x < width; x++) { + int c = xpmGetC(data); + + if (c > 0 && c < 256 && colidx[c] != 0) { +#ifndef FOR_MSW + XPutPixel(image, x, y, image_pixels[colidx[c] - 1]); + if (shapeimage) + XPutPixel(shapeimage, x, y, + shape_pixels[colidx[c] - 1]); +#else +#ifdef __OS2__ + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)image_pixels[colidx[c] - 1]); + GpiSetPel(*dc, &point); +#else + SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]); +#endif + if (shapedc) { +#ifdef __OS2__ + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)shape_pixels[colidx[c] - 1]); + GpiSetPel(*dc, &point); +#else + SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]); +#endif + } +#endif + } else + return (XpmFileInvalid); + } + } +#ifdef FOR_MSW + if ( shapedc ) { +#ifdef __OS2__ + GpiSetBitmap(*dc, sobm); + GpiDestroyPS(*dc); + DevCloseDC(shapedc); +#else + SelectObject(shapedc, sobm); + DeleteDC(shapedc); +#endif + } +#ifdef __OS2__ + GpiSetBitmap(*dc, obm); +#else + SelectObject(*dc, obm); +#endif +#endif + } + break; + + case (2): /* Optimize for double character + * colors */ + { +/* free all allocated pointers at all exits */ +#define FREE_CIDX {int f; for (f = 0; f < 256; f++) \ +if (cidx[f]) XpmFree(cidx[f]);} + + /* array of pointers malloced by need */ + unsigned short *cidx[256]; + int char1; +#ifdef __OS2__ + HDC shapedc; +#endif + + bzero((char *)cidx, 256 * sizeof(unsigned short *)); /* init */ + for (a = 0; a < ncolors; a++) { + char1 = colorTable[a].string[0]; + if (cidx[char1] == NULL) { /* get new memory */ + cidx[char1] = (unsigned short *) + XpmCalloc(256, sizeof(unsigned short)); + if (cidx[char1] == NULL) { /* new block failed */ + FREE_CIDX; + return (XpmNoMemory); + } + } + cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1; + } + + for (y = 0; y < height; y++) { + xpmNextString(data); + for (x = 0; x < width; x++) { + int cc1 = xpmGetC(data); + if (cc1 > 0 && cc1 < 256) { + int cc2 = xpmGetC(data); + if (cc2 > 0 && cc2 < 256 && + cidx[cc1] && cidx[cc1][cc2] != 0) { +#ifndef FOR_MSW + XPutPixel(image, x, y, + image_pixels[cidx[cc1][cc2] - 1]); + if (shapeimage) + XPutPixel(shapeimage, x, y, + shape_pixels[cidx[cc1][cc2] - 1]); +#else +#ifdef __OS2__ + shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE); + *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS); + + GpiSetBitmap(*dc, image->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)image_pixels[cidx[cc1][cc2] - 1]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, image->bitmap); + SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]); +#endif + if (shapeimage) { +#ifdef __OS2__ + GpiSetBitmap(*dc, shapeimage->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)shape_pixels[cidx[cc1][cc2] - 1]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, shapeimage->bitmap); + SetPixel(*dc, x, y, + shape_pixels[cidx[cc1][cc2] - 1]); +#endif + } +#endif + } else { + FREE_CIDX; + return (XpmFileInvalid); + } + } else { + FREE_CIDX; + return (XpmFileInvalid); + } + } + } + FREE_CIDX; + } + break; + + default: /* Non-optimized case of long color + * names */ + { + char *s; + char buf[BUFSIZ]; +#ifdef __OS2__ + HDC shapedc; +#endif + + buf[cpp] = '\0'; + if (USE_HASHTABLE) { + xpmHashAtom *slot; + + for (y = 0; y < height; y++) { + xpmNextString(data); + for (x = 0; x < width; x++) { + for (a = 0, s = buf; a < cpp; a++, s++) + *s = xpmGetC(data); + slot = xpmHashSlot(hashtable, buf); + if (!*slot) /* no color matches */ + return (XpmFileInvalid); +#ifndef FOR_MSW + XPutPixel(image, x, y, + image_pixels[HashColorIndex(slot)]); + if (shapeimage) + XPutPixel(shapeimage, x, y, + shape_pixels[HashColorIndex(slot)]); +#else +#ifdef __OS2__ + + shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE); + *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS); + + GpiSetBitmap(*dc, image->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)image_pixels[HashColorIndex(slot)]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, image->bitmap); + SetPixel(*dc, x, y, + image_pixels[HashColorIndex(slot)]); +#endif + if (shapeimage) { +#ifdef __OS2__ + GpiSetBitmap(*dc, shapeimage->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)shape_pixels[HashColorIndex(slot)]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, shapeimage->bitmap); + SetPixel(*dc, x, y, + shape_pixels[HashColorIndex(slot)]); +#endif + } +#endif + } + } + } else { + for (y = 0; y < height; y++) { + xpmNextString(data); + for (x = 0; x < width; x++) { + for (a = 0, s = buf; a < cpp; a++, s++) + *s = xpmGetC(data); + for (a = 0; a < ncolors; a++) + if (!strcmp(colorTable[a].string, buf)) + break; + if (a == ncolors) /* no color matches */ + return (XpmFileInvalid); +#ifndef FOR_MSW + XPutPixel(image, x, y, image_pixels[a]); + if (shapeimage) + XPutPixel(shapeimage, x, y, shape_pixels[a]); +#else +#ifdef __OS2__ + + shapedc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE); + *dc = GpiCreatePS(hab, shapedc, &sizl, GPIA_ASSOC | PU_PELS); + + GpiSetBitmap(*dc, image->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)image_pixels[a]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, image->bitmap); + SetPixel(*dc, x, y, image_pixels[a]); +#endif + if (shapeimage) { +#ifdef __OS2__ + GpiSetBitmap(*dc, image->bitmap); + point.x = x; + point.y = y; + GpiSetColor(*dc, (LONG)shape_pixels[a]); + GpiSetPel(*dc, &point); +#else + SelectObject(*dc, shapeimage->bitmap); + SetPixel(*dc, x, y, shape_pixels[a]); +#endif + } +#endif + } + } + } + } + break; + } + return (XpmSuccess); +}