[wxWidgets.git] / src / mac / xpm / scan.c

/*
 * 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
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name of GROUPE BULL shall not be
 * used in advertising or otherwise to promote the sale, use or other dealings
 * in this Software without prior written authorization from GROUPE BULL.
 */

/*****************************************************************************\
* scan.c:                                                                     *
*                                                                             *
*  XPM library                                                                *
*  Scanning utility for XPM file format                                       *
*                                                                             *
*  Developed by Arnaud Le Hors                                                *
\*****************************************************************************/

/*
 * The code related to FOR_MSW has been added by
 * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
 */

/*
 * The code related to AMIGA has been added by
 * Lorens Younes (d93-hyo@nada.kth.se) 4/96
 */

#include "xpmi.h"

#define MAXPRINTABLE 92			/* number of printable ascii chars
					 * minus \ and " for string compat
					 * and ? to avoid ANSI trigraphs. */

static char *printable =
" .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\
ASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";

/*
 * printable begin with a space, so in most case, due to my algorithm, when
 * the number of different colors is less than MAXPRINTABLE, it will give a
 * char follow by "nothing" (a space) in the readable xpm file
 */


typedef struct {
    Pixel *pixels;
    unsigned int *pixelindex;
    unsigned int size;
    unsigned int ncolors;
    unsigned int mask_pixel;		/* whether there is or not */
}      PixelsMap;

LFUNC(storePixel, int, (Pixel pixel, PixelsMap *pmap,
			unsigned int *index_return));

LFUNC(storeMaskPixel, int, (Pixel pixel, PixelsMap *pmap,
			    unsigned int *index_return));

LFUNC(PlatformGetImagePixels, int, (Display *d, XImage *image, unsigned int width,
			       unsigned int height, PixelsMap *pmap,
			       int (*storeFunc) ()));
LFUNC(ScanTransparentColor, int, (XpmColor *color, unsigned int cpp,
				  XpmAttributes *attributes));

LFUNC(ScanOtherColors, int, (Display *display, XpmColor *colors, int ncolors,
			     Pixel *pixels, unsigned int mask,
			     unsigned int cpp, XpmAttributes *attributes));

/*
 * This function stores the given pixel in the given arrays which are grown
 * if not large enough.
 */
static int
storePixel(pixel, pmap, index_return)
    Pixel pixel;
    PixelsMap *pmap;
    unsigned int *index_return;
{
    unsigned int i;
    Pixel *p;
    unsigned int ncolors;

    if (*index_return) {		/* this is a transparent pixel! */
	*index_return = 0;
	return 0;
    }
    ncolors = pmap->ncolors;
    p = pmap->pixels + pmap->mask_pixel;
    for (i = pmap->mask_pixel; i < ncolors; i++, p++)
	if ( IS_EQUAL_PIXEL(*p , pixel) )
	    break;
    if (i == ncolors) {
	if (ncolors >= pmap->size) {
	    pmap->size *= 2;
	    p = (Pixel *) XpmRealloc(pmap->pixels, sizeof(Pixel) * pmap->size);
	    if (!p)
		return (1);
	    pmap->pixels = p;

	}
	(pmap->pixels)[ncolors] = pixel;
	pmap->ncolors++;
    }
    *index_return = i;
    return 0;
}

static int
storeMaskPixel(pixel, pmap, index_return)
    Pixel pixel;
    PixelsMap *pmap;
    unsigned int *index_return;
{
    if (IS_ZERO_PIXEL(pixel)) {
	if (!pmap->ncolors) {
	    pmap->ncolors = 1;
	    SET_ZERO_PIXEL((pmap->pixels)[0]);
	    pmap->mask_pixel = 1;
	}
	*index_return = 1;
    } else
	*index_return = 0;
    return 0;
}

/* function call in case of error */
#undef RETURN
#define RETURN(status) \
{ \
      ErrorStatus = status; \
      goto error; \
}

/*
 * This function scans the given image and stores the found informations in
 * the given XpmImage structure.
 */
int
XpmCreateXpmImageFromImage(display, image, shapeimage,
			   xpmimage, attributes)
    Display *display;
    XImage *image;
    XImage *shapeimage;
    XpmImage *xpmimage;
    XpmAttributes *attributes;
{
    /* variables stored in the XpmAttributes structure */
    unsigned int cpp;

    /* variables to return */
    PixelsMap pmap;
    XpmColor *colorTable = NULL;
    int ErrorStatus;

    /* calculation variables */
    unsigned int width = 0;
    unsigned int height = 0;
    unsigned int cppm;			/* minimum chars per pixel */
    unsigned int c;

    /* initialize pmap */
    pmap.pixels = NULL;
    pmap.pixelindex = NULL;
    pmap.size = 256;			/* should be enough most of the time */
    pmap.ncolors = 0;
    pmap.mask_pixel = 0;

    /*
     * get geometry
     */
    if (image) {
	width = image->width;
	height = image->height;
    } else if (shapeimage) {
	width = shapeimage->width;
	height = shapeimage->height;
    }

    /*
     * retrieve information from the XpmAttributes
     */
    if (attributes && (attributes->valuemask & XpmCharsPerPixel
/* 3.2 backward compatibility code */
		       || attributes->valuemask & XpmInfos))
/* end 3.2 bc */
	cpp = attributes->cpp;
    else
	cpp = 0;

    pmap.pixelindex =
	(unsigned int *) XpmCalloc(width * height, sizeof(unsigned int));
    if (!pmap.pixelindex)
	RETURN(XpmNoMemory);

    pmap.pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * pmap.size);
    if (!pmap.pixels)
	RETURN(XpmNoMemory);

    /*
     * scan shape mask if any
     */
    if (shapeimage) {

	ErrorStatus = PlatformGetImagePixels(display, shapeimage, width, height,
					&pmap, storeMaskPixel);

	if (ErrorStatus != XpmSuccess)
	    RETURN(ErrorStatus);
    }

    /*
     * scan the image 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.
     * 
     */

    if (image) {

	ErrorStatus = PlatformGetImagePixels(display, image, width, height, &pmap,
					storePixel);

	if (ErrorStatus != XpmSuccess)
	    RETURN(ErrorStatus);
    }

    /*
     * get rgb values and a string of char, and possibly a name for each
     * color
     */

    colorTable = (XpmColor *) XpmCalloc(pmap.ncolors, sizeof(XpmColor));
    if (!colorTable)
	RETURN(XpmNoMemory);

    /* compute the minimal cpp */
    for (cppm = 1, c = MAXPRINTABLE; pmap.ncolors > c; cppm++)
	c *= MAXPRINTABLE;
    if (cpp < cppm)
	cpp = cppm;

    if (pmap.mask_pixel) {
	ErrorStatus = ScanTransparentColor(colorTable, cpp, attributes);
	if (ErrorStatus != XpmSuccess)
	    RETURN(ErrorStatus);
    }

    ErrorStatus = ScanOtherColors(display, colorTable, pmap.ncolors,
				  pmap.pixels, pmap.mask_pixel, cpp,
				  attributes);
    if (ErrorStatus != XpmSuccess)
	RETURN(ErrorStatus);

    /*
     * store found informations in the XpmImage structure
     */
    xpmimage->width = width;
    xpmimage->height = height;
    xpmimage->cpp = cpp;
    xpmimage->ncolors = pmap.ncolors;
    xpmimage->colorTable = colorTable;
    xpmimage->data = pmap.pixelindex;

    XpmFree(pmap.pixels);
    return (XpmSuccess);

/* exit point in case of error, free only locally allocated variables */
error:
    if (pmap.pixelindex)
	XpmFree(pmap.pixelindex);
    if (pmap.pixels)
	XpmFree(pmap.pixels);
    if (colorTable)
	xpmFreeColorTable(colorTable, pmap.ncolors);

    return (ErrorStatus);
}

static int
ScanTransparentColor(color, cpp, attributes)
    XpmColor *color;
    unsigned int cpp;
    XpmAttributes *attributes;
{
    char *s;
    unsigned int a, b, c;

    /* first get a character string */
    a = 0;
    if (!(s = color->string = (char *) XpmMalloc(cpp + 1)))
	return (XpmNoMemory);
    *s++ = printable[c = a % MAXPRINTABLE];
    for (b = 1; b < cpp; b++, s++)
	*s = printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];
    *s = '\0';

    /* then retreive related info from the attributes if any */
    if (attributes && (attributes->valuemask & XpmColorTable
/* 3.2 backward compatibility code */
		       || attributes->valuemask & XpmInfos)
/* end 3.2 bc */
	&& attributes->mask_pixel != XpmUndefPixel) {

	unsigned int key;
	char **defaults = (char **) color;
	char **mask_defaults;

/* 3.2 backward compatibility code */
	if (attributes->valuemask & XpmColorTable)
/* end 3.2 bc */
	    mask_defaults = (char **) (
		attributes->colorTable + attributes->mask_pixel);
/* 3.2 backward compatibility code */
	else
	    mask_defaults = (char **)
		((XpmColor **) attributes->colorTable)[attributes->mask_pixel];
/* end 3.2 bc */
	for (key = 1; key <= NKEYS; key++) {
	    if (s = mask_defaults[key]) {
		defaults[key] = (char *) xpmstrdup(s);
		if (!defaults[key])
		    return (XpmNoMemory);
	    }
	}
    } else {
	color->c_color = (char *) xpmstrdup(TRANSPARENT_COLOR);
	if (!color->c_color)
	    return (XpmNoMemory);
    }
    return (XpmSuccess);
}

static int
ScanOtherColors(display, colors, ncolors, pixels, mask, cpp, attributes)
    Display *display;
    XpmColor *colors;
    int ncolors;
    Pixel *pixels;
    unsigned int mask;
    unsigned int cpp;
    XpmAttributes *attributes;
{
    /* variables stored in the XpmAttributes structure */
    Colormap colormap;
    char *rgb_fname;

    xpmRgbName *rgbn = NULL; 

    int rgbn_max = 0;
    unsigned int i, j, c, i2;
    XpmColor *color;
    XColor *xcolors = NULL, *xcolor;
    char *colorname, *s;
    XpmColor *colorTable, **oldColorTable = NULL;
    unsigned int ancolors = 0;
    Pixel *apixels;
    unsigned int mask_pixel;
    Bool found;

    /* retrieve information from the XpmAttributes */
    if (attributes && (attributes->valuemask & XpmColormap))
	colormap = attributes->colormap;
    else
	colormap = XDefaultColormap(display, XDefaultScreen(display));
    if (attributes && (attributes->valuemask & XpmRgbFilename))
	rgb_fname = attributes->rgb_fname;
    else
	rgb_fname = NULL;

    /* start from the right element */
    if (mask) {
	colors++;
	ncolors--;
	pixels++;
    }

    /* first get character strings and rgb values */
    xcolors = (XColor *) XpmMalloc(sizeof(XColor) * ncolors);
    if (!xcolors)
	return (XpmNoMemory);

    for (i = 0, i2 = mask, color = colors, xcolor = xcolors;
	 i < ncolors; i++, i2++, color++, xcolor++, pixels++) {

	if (!(s = color->string = (char *) XpmMalloc(cpp + 1))) {
	    XpmFree(xcolors);
	    return (XpmNoMemory);
	}
	*s++ = printable[c = i2 % MAXPRINTABLE];
	for (j = 1; j < cpp; j++, s++)
	    *s = printable[c = ((i2 - c) / MAXPRINTABLE) % MAXPRINTABLE];
	*s = '\0';

	xcolor->pixel = *pixels;
    }
    XQueryColors(display, colormap, xcolors, ncolors);

    rgbn_max = xpmReadRgbNames(NULL, NULL);

    if (attributes && attributes->valuemask & XpmColorTable) {
	colorTable = attributes->colorTable;
	ancolors = attributes->ncolors;
	apixels = attributes->pixels;
	mask_pixel = attributes->mask_pixel;
    }
/* 3.2 backward compatibility code */
    else if (attributes && attributes->valuemask & XpmInfos) {
	oldColorTable = (XpmColor **) attributes->colorTable;
	ancolors = attributes->ncolors;
	apixels = attributes->pixels;
	mask_pixel = attributes->mask_pixel;
    }
/* end 3.2 bc */

    for (i = 0, color = colors, xcolor = xcolors; i < ncolors;
						  i++, color++, xcolor++) {

	/* look for related info from the attributes if any */
	found = False;
	if (ancolors) {
	    unsigned int offset = 0;

	    for (j = 0; j < ancolors; j++) {
		if (j == mask_pixel) {
		    offset = 1;
		    continue;
		}
		if (IS_EQUAL_PIXEL( apixels[j - offset] , xcolor->pixel) )
		    break;
	    }
	    if (j != ancolors) {
		unsigned int key;
		char **defaults = (char **) color;
		char **adefaults;

/* 3.2 backward compatibility code */
		if (oldColorTable)
		    adefaults = (char **) oldColorTable[j];
		else
/* end 3.2 bc */
		    adefaults = (char **) (colorTable + j);

		found = True;
		for (key = 1; key <= NKEYS; key++) {
		    if (s = adefaults[key])
			defaults[key] = (char *) xpmstrdup(s);
		}
	    }
	}
	if (!found) {
	    /* if nothing found look for a color name */
	    colorname = NULL;
	    if (rgbn_max)
		colorname = xpmGetRgbName(rgbn, rgbn_max, xcolor->red,
					  xcolor->green, xcolor->blue);
	    if (colorname)
		color->c_color = (char *) xpmstrdup(colorname);
	    else {
		/* at last store the rgb value */
		char buf[BUFSIZ];
//		sprintf(buf, "#%04X%04X%04X",
		sprintf(buf, "#%02x%02x%02x",
			xcolor->red, xcolor->green, xcolor->blue);

		color->c_color = (char *) xpmstrdup(buf);
	    }
	    if (!color->c_color) {
		XpmFree(xcolors);
		xpmFreeRgbNames(rgbn, rgbn_max);
		return (XpmNoMemory);
	    }
	}
    }

    XpmFree(xcolors);
    xpmFreeRgbNames(rgbn, rgbn_max);
    return (XpmSuccess);
}


static int
PlatformGetImagePixels(display, image, width, height, pmap, storeFunc)
    Display *display;
    XImage *image;
    unsigned int width;
    unsigned int height;
    PixelsMap *pmap;
    int (*storeFunc) ();
{
	#if FOR_MSW
    unsigned int *iptr;
    unsigned int x, y;
    Pixel pixel;

    iptr = pmap->pixelindex;

    SelectObject(*display, image->bitmap);
    for (y = 0; y < height; y++) {
	for (x = 0; x < width; x++, iptr++) {
	    pixel = GetPixel(*display, x, y);
	    if ((*storeFunc) (pixel, pmap, iptr))
		return (XpmNoMemory);
	}
    }
    #elif macintosh
    #endif
    return (XpmSuccess);
}
Commit	Line	Data
0240e8b1 SC	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	* scan.c: *
	28	* *
	29	* XPM library *
	30	* Scanning utility for XPM file format *
	31	* *
	32	* Developed by Arnaud Le Hors *
	33	\*****************************************************************************/
	34
	35	/*
	36	* The code related to FOR_MSW has been added by
	37	* HeDu (hedu@cul-ipn.uni-kiel.de) 4/94
	38	*/
	39
	40	/*
	41	* The code related to AMIGA has been added by
	42	* Lorens Younes (d93-hyo@nada.kth.se) 4/96
	43	*/
	44
	45	#include "xpmi.h"
	46
	47	#define MAXPRINTABLE 92 /* number of printable ascii chars
	48	* minus \ and " for string compat
	49	* and ? to avoid ANSI trigraphs. */
	50
	51	static char *printable =
	52	" .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZ\
	53	ASDFGHJKLPIUYTREWQ!~^/()_`'][{}\|";
	54
	55	/*
	56	* printable begin with a space, so in most case, due to my algorithm, when
	57	* the number of different colors is less than MAXPRINTABLE, it will give a
	58	* char follow by "nothing" (a space) in the readable xpm file
	59	*/
	60
	61
	62	typedef struct {
	63	Pixel *pixels;
	64	unsigned int *pixelindex;
65	unsigned int size;
66	unsigned int ncolors;
67	unsigned int mask_pixel; /* whether there is or not */
68	} PixelsMap;
69
70	LFUNC(storePixel, int, (Pixel pixel, PixelsMap *pmap,
71	unsigned int *index_return));
72
73	LFUNC(storeMaskPixel, int, (Pixel pixel, PixelsMap *pmap,
74	unsigned int *index_return));
75
76	LFUNC(PlatformGetImagePixels, int, (Display d, XImage image, unsigned int width,
77	unsigned int height, PixelsMap *pmap,
78	int (*storeFunc) ()));
79	LFUNC(ScanTransparentColor, int, (XpmColor *color, unsigned int cpp,
80	XpmAttributes *attributes));
81
82	LFUNC(ScanOtherColors, int, (Display display, XpmColor colors, int ncolors,
83	Pixel *pixels, unsigned int mask,
84	unsigned int cpp, XpmAttributes *attributes));
85
86	/*
87	* This function stores the given pixel in the given arrays which are grown
88	* if not large enough.
89	*/
90	static int
91	storePixel(pixel, pmap, index_return)
92	Pixel pixel;
93	PixelsMap *pmap;
94	unsigned int *index_return;
95	{
96	unsigned int i;
97	Pixel *p;
98	unsigned int ncolors;
99
100	if (index_return) { / this is a transparent pixel! */
101	*index_return = 0;
102	return 0;
103	}
104	ncolors = pmap->ncolors;
105	p = pmap->pixels + pmap->mask_pixel;
106	for (i = pmap->mask_pixel; i < ncolors; i++, p++)
107	if ( IS_EQUAL_PIXEL(*p , pixel) )
108	break;
109	if (i == ncolors) {
110	if (ncolors >= pmap->size) {
111	pmap->size *= 2;
112	p = (Pixel ) XpmRealloc(pmap->pixels, sizeof(Pixel) pmap->size);
113	if (!p)
114	return (1);
115	pmap->pixels = p;
116
117	}
118	(pmap->pixels)[ncolors] = pixel;
119	pmap->ncolors++;
120	}
121	*index_return = i;
122	return 0;
123	}
124
125	static int
126	storeMaskPixel(pixel, pmap, index_return)
127	Pixel pixel;
128	PixelsMap *pmap;
129	unsigned int *index_return;
130	{
131	if (IS_ZERO_PIXEL(pixel)) {
132	if (!pmap->ncolors) {
133	pmap->ncolors = 1;
134	SET_ZERO_PIXEL((pmap->pixels)[0]);
135	pmap->mask_pixel = 1;
136	}
137	*index_return = 1;
138	} else
139	*index_return = 0;
140	return 0;
141	}
142
143	/* function call in case of error */
144	#undef RETURN
145	#define RETURN(status) \
146	{ \
147	ErrorStatus = status; \
148	goto error; \
149	}
150
151	/*
152	* This function scans the given image and stores the found informations in
153	* the given XpmImage structure.
154	*/
155	int
156	XpmCreateXpmImageFromImage(display, image, shapeimage,
157	xpmimage, attributes)
158	Display *display;
159	XImage *image;
160	XImage *shapeimage;
161	XpmImage *xpmimage;
162	XpmAttributes *attributes;
163	{
164	/* variables stored in the XpmAttributes structure */
165	unsigned int cpp;
166
167	/* variables to return */
168	PixelsMap pmap;
169	XpmColor *colorTable = NULL;
170	int ErrorStatus;
171
172	/* calculation variables */
173	unsigned int width = 0;
174	unsigned int height = 0;
175	unsigned int cppm; /* minimum chars per pixel */
176	unsigned int c;
177
178	/* initialize pmap */
179	pmap.pixels = NULL;
180	pmap.pixelindex = NULL;
181	pmap.size = 256; /* should be enough most of the time */
182	pmap.ncolors = 0;
183	pmap.mask_pixel = 0;
184
185	/*
186	* get geometry
187	*/
188	if (image) {
189	width = image->width;
190	height = image->height;
191	} else if (shapeimage) {
192	width = shapeimage->width;
193	height = shapeimage->height;
194	}
195
196	/*
197	* retrieve information from the XpmAttributes
198	*/
199	if (attributes && (attributes->valuemask & XpmCharsPerPixel
200	/* 3.2 backward compatibility code */
201	\|\| attributes->valuemask & XpmInfos))
202	/* end 3.2 bc */
203	cpp = attributes->cpp;
204	else
205	cpp = 0;
206
207	pmap.pixelindex =
208	(unsigned int ) XpmCalloc(width height, sizeof(unsigned int));
209	if (!pmap.pixelindex)
210	RETURN(XpmNoMemory);
211
212	pmap.pixels = (Pixel ) XpmMalloc(sizeof(Pixel) pmap.size);
213	if (!pmap.pixels)
214	RETURN(XpmNoMemory);
215
216	/*
217	* scan shape mask if any
218	*/
219	if (shapeimage) {
220
221	ErrorStatus = PlatformGetImagePixels(display, shapeimage, width, height,
222	&pmap, storeMaskPixel);
223
224	if (ErrorStatus != XpmSuccess)
225	RETURN(ErrorStatus);
226	}
227
228	/*
229	* scan the image data
230	*
231	* In case depth is 1 or bits_per_pixel is 4, 6, 8, 24 or 32 use optimized
232	* functions, otherwise use slower but sure general one.
233	*
234	*/
235
236	if (image) {
237
238	ErrorStatus = PlatformGetImagePixels(display, image, width, height, &pmap,
239	storePixel);
240
241	if (ErrorStatus != XpmSuccess)
242	RETURN(ErrorStatus);
243	}
244
245	/*
246	* get rgb values and a string of char, and possibly a name for each
247	* color
248	*/
249
250	colorTable = (XpmColor *) XpmCalloc(pmap.ncolors, sizeof(XpmColor));
251	if (!colorTable)
252	RETURN(XpmNoMemory);
253
254	/* compute the minimal cpp */
255	for (cppm = 1, c = MAXPRINTABLE; pmap.ncolors > c; cppm++)
256	c *= MAXPRINTABLE;
257	if (cpp < cppm)
258	cpp = cppm;
259
260	if (pmap.mask_pixel) {
261	ErrorStatus = ScanTransparentColor(colorTable, cpp, attributes);
262	if (ErrorStatus != XpmSuccess)
263	RETURN(ErrorStatus);
264	}
265
266	ErrorStatus = ScanOtherColors(display, colorTable, pmap.ncolors,
267	pmap.pixels, pmap.mask_pixel, cpp,
268	attributes);
269	if (ErrorStatus != XpmSuccess)
270	RETURN(ErrorStatus);
271
272	/*
273	* store found informations in the XpmImage structure
274	*/
275	xpmimage->width = width;
276	xpmimage->height = height;
277	xpmimage->cpp = cpp;
278	xpmimage->ncolors = pmap.ncolors;
279	xpmimage->colorTable = colorTable;
280	xpmimage->data = pmap.pixelindex;
281
282	XpmFree(pmap.pixels);
283	return (XpmSuccess);
284
285	/* exit point in case of error, free only locally allocated variables */
286	error:
287	if (pmap.pixelindex)
288	XpmFree(pmap.pixelindex);
289	if (pmap.pixels)
290	XpmFree(pmap.pixels);
291	if (colorTable)
292	xpmFreeColorTable(colorTable, pmap.ncolors);
293
294	return (ErrorStatus);
295	}
296
297	static int
298	ScanTransparentColor(color, cpp, attributes)
299	XpmColor *color;
300	unsigned int cpp;
301	XpmAttributes *attributes;
302	{
303	char *s;
304	unsigned int a, b, c;
305
306	/* first get a character string */
307	a = 0;
308	if (!(s = color->string = (char *) XpmMalloc(cpp + 1)))
309	return (XpmNoMemory);
310	*s++ = printable[c = a % MAXPRINTABLE];
311	for (b = 1; b < cpp; b++, s++)
312	*s = printable[c = ((a - c) / MAXPRINTABLE) % MAXPRINTABLE];
313	*s = '\0';
314
315	/* then retreive related info from the attributes if any */
316	if (attributes && (attributes->valuemask & XpmColorTable
317	/* 3.2 backward compatibility code */
318	\|\| attributes->valuemask & XpmInfos)
319	/* end 3.2 bc */
320	&& attributes->mask_pixel != XpmUndefPixel) {
321
322	unsigned int key;
323	char defaults = (char ) color;
324	char **mask_defaults;
325
326	/* 3.2 backward compatibility code */
327	if (attributes->valuemask & XpmColorTable)
328	/* end 3.2 bc */
329	mask_defaults = (char **) (
330	attributes->colorTable + attributes->mask_pixel);
331	/* 3.2 backward compatibility code */
332	else
333	mask_defaults = (char **)
334	((XpmColor **) attributes->colorTable)[attributes->mask_pixel];
335	/* end 3.2 bc */
336	for (key = 1; key <= NKEYS; key++) {
337	if (s = mask_defaults[key]) {
338	defaults[key] = (char *) xpmstrdup(s);
339	if (!defaults[key])
340	return (XpmNoMemory);
341	}
342	}
343	} else {
344	color->c_color = (char *) xpmstrdup(TRANSPARENT_COLOR);
345	if (!color->c_color)
346	return (XpmNoMemory);
347	}
348	return (XpmSuccess);
349	}
350
351	static int
352	ScanOtherColors(display, colors, ncolors, pixels, mask, cpp, attributes)
353	Display *display;
354	XpmColor *colors;
355	int ncolors;
356	Pixel *pixels;
357	unsigned int mask;
358	unsigned int cpp;
359	XpmAttributes *attributes;
360	{
361	/* variables stored in the XpmAttributes structure */
362	Colormap colormap;
363	char *rgb_fname;
364
365	xpmRgbName *rgbn = NULL;
366
367	int rgbn_max = 0;
368	unsigned int i, j, c, i2;
369	XpmColor *color;
370	XColor xcolors = NULL, xcolor;
371	char colorname, s;
372	XpmColor colorTable, *oldColorTable = NULL;
373	unsigned int ancolors = 0;
374	Pixel *apixels;
375	unsigned int mask_pixel;
376	Bool found;
377
378	/* retrieve information from the XpmAttributes */
379	if (attributes && (attributes->valuemask & XpmColormap))
380	colormap = attributes->colormap;
381	else
382	colormap = XDefaultColormap(display, XDefaultScreen(display));
383	if (attributes && (attributes->valuemask & XpmRgbFilename))
384	rgb_fname = attributes->rgb_fname;
385	else
386	rgb_fname = NULL;
387
388	/* start from the right element */
389	if (mask) {
390	colors++;
391	ncolors--;
392	pixels++;
393	}
394
395	/* first get character strings and rgb values */
396	xcolors = (XColor ) XpmMalloc(sizeof(XColor) ncolors);
397	if (!xcolors)
398	return (XpmNoMemory);
399
400	for (i = 0, i2 = mask, color = colors, xcolor = xcolors;
401	i < ncolors; i++, i2++, color++, xcolor++, pixels++) {
402
403	if (!(s = color->string = (char *) XpmMalloc(cpp + 1))) {
404	XpmFree(xcolors);
405	return (XpmNoMemory);
406	}
407	*s++ = printable[c = i2 % MAXPRINTABLE];
408	for (j = 1; j < cpp; j++, s++)
409	*s = printable[c = ((i2 - c) / MAXPRINTABLE) % MAXPRINTABLE];
410	*s = '\0';
411
412	xcolor->pixel = *pixels;
413	}
414	XQueryColors(display, colormap, xcolors, ncolors);
415
416	rgbn_max = xpmReadRgbNames(NULL, NULL);
417
418	if (attributes && attributes->valuemask & XpmColorTable) {
419	colorTable = attributes->colorTable;
420	ancolors = attributes->ncolors;
421	apixels = attributes->pixels;
422	mask_pixel = attributes->mask_pixel;
423	}
424	/* 3.2 backward compatibility code */
425	else if (attributes && attributes->valuemask & XpmInfos) {
426	oldColorTable = (XpmColor **) attributes->colorTable;
427	ancolors = attributes->ncolors;
428	apixels = attributes->pixels;
429	mask_pixel = attributes->mask_pixel;
430	}
431	/* end 3.2 bc */
432
433	for (i = 0, color = colors, xcolor = xcolors; i < ncolors;
434	i++, color++, xcolor++) {
435
436	/* look for related info from the attributes if any */
437	found = False;
438	if (ancolors) {
439	unsigned int offset = 0;
440
441	for (j = 0; j < ancolors; j++) {
442	if (j == mask_pixel) {
443	offset = 1;
444	continue;
445	}
446	if (IS_EQUAL_PIXEL( apixels[j - offset] , xcolor->pixel) )
447	break;
448	}
449	if (j != ancolors) {
450	unsigned int key;
451	char defaults = (char ) color;
452	char **adefaults;
453
454	/* 3.2 backward compatibility code */
455	if (oldColorTable)
456	adefaults = (char **) oldColorTable[j];
457	else
458	/* end 3.2 bc */
459	adefaults = (char **) (colorTable + j);
460
461	found = True;
462	for (key = 1; key <= NKEYS; key++) {
463	if (s = adefaults[key])
464	defaults[key] = (char *) xpmstrdup(s);
465	}
466	}
467	}
468	if (!found) {
469	/* if nothing found look for a color name */
470	colorname = NULL;
471	if (rgbn_max)
472	colorname = xpmGetRgbName(rgbn, rgbn_max, xcolor->red,
473	xcolor->green, xcolor->blue);
474	if (colorname)
475	color->c_color = (char *) xpmstrdup(colorname);
476	else {
477	/* at last store the rgb value */
478	char buf[BUFSIZ];
479	// sprintf(buf, "#%04X%04X%04X",
480	sprintf(buf, "#%02x%02x%02x",
481	xcolor->red, xcolor->green, xcolor->blue);
482
483	color->c_color = (char *) xpmstrdup(buf);
484	}
485	if (!color->c_color) {
486	XpmFree(xcolors);
487	xpmFreeRgbNames(rgbn, rgbn_max);
488	return (XpmNoMemory);
489	}
490	}
491	}
492
493	XpmFree(xcolors);
494	xpmFreeRgbNames(rgbn, rgbn_max);
495	return (XpmSuccess);
496	}
497
498
499	static int
500	PlatformGetImagePixels(display, image, width, height, pmap, storeFunc)
501	Display *display;
502	XImage *image;
503	unsigned int width;
504	unsigned int height;
505	PixelsMap *pmap;
506	int (*storeFunc) ();
507	{
508	#if FOR_MSW
509	unsigned int *iptr;
510	unsigned int x, y;
511	Pixel pixel;
512
513	iptr = pmap->pixelindex;
514
515	SelectObject(*display, image->bitmap);
516	for (y = 0; y < height; y++) {
517	for (x = 0; x < width; x++, iptr++) {
518	pixel = GetPixel(*display, x, y);
519	if ((*storeFunc) (pixel, pmap, iptr))
520	return (XpmNoMemory);
521	}
522	}
523	#elif macintosh
524	#endif
525	return (XpmSuccess);
526	}