src/xpm/crdatfri.c

/*
 * Copyright (C) 1989-94 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.
 */

/*****************************************************************************\
* XpmCrDataFI.c:                                                              *
*                                                                             *
*  XPM library                                                                *
*  Scan an image and possibly its mask and create an XPM array                *
*                                                                             *
*  Developed by Arnaud Le Hors                                                *
\*****************************************************************************/

#include "xpm34p.h"
#ifdef VMS
#include "sys$library:string.h"
#else
#if defined(SYSV) || defined(SVR4)
#include <string.h>
#else
#include <strings.h>
#endif
#endif

LFUNC(CreateColors, int, (char **dataptr, unsigned int *data_size,
			  XpmColor *colors, unsigned int ncolors,
			  unsigned int cpp));

LFUNC(CreatePixels, void, (char **dataptr, unsigned int width,
			   unsigned int height, unsigned int cpp,
			   unsigned int *pixels, XpmColor *colors));

LFUNC(CountExtensions, void, (XpmExtension *ext, unsigned int num,
			      unsigned int *ext_size,
			      unsigned int *ext_nlines));

LFUNC(CreateExtensions, void, (char **dataptr, unsigned int offset,
			       XpmExtension *ext, unsigned int num,
			       unsigned int ext_nlines));

int
XpmCreateDataFromImage(Display *display, char ***data_return, XImage *image,
  XImage *shapeimage, XpmAttributes *attributes)
{
    XpmImage xpmimage;
    XpmInfo info;
    int ErrorStatus;

    /* initialize return value */
    if (data_return)
	*data_return = NULL;

    /* create an XpmImage from the image */
    ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
					     &xpmimage, attributes);
    if (ErrorStatus != XpmSuccess)
	return (ErrorStatus);

    /* create the data from the XpmImage */
    if (attributes) {
	xpmSetInfo(&info, attributes);
	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, &info);
    } else
	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, NULL);

    /* free the XpmImage */
    XpmFreeXpmImage(&xpmimage);

    return (ErrorStatus);
}

#undef RETURN
#define RETURN(status) \
{ \
    if (header) { \
	for (l = 0; l < header_nlines; l++) \
	    if (header[l]) \
		XpmFree(header[l]); \
		XpmFree(header); \
    } \
    return(status); \
}

int
XpmCreateDataFromXpmImage(char ***data_return, XpmImage *image, XpmInfo *info)
{
    /* calculation variables */
    int ErrorStatus;
    char buf[BUFSIZ];
    char **header = NULL, **data, **sptr, **sptr2, *s;
    unsigned int header_size, header_nlines;
    unsigned int data_size, data_nlines;
    unsigned int extensions = 0, ext_size = 0, ext_nlines = 0;
    unsigned int offset, l, n;

    *data_return = NULL;

    extensions = info && (info->valuemask & XpmExtensions)
	&& info->nextensions;

    /* compute the number of extensions lines and size */
    if (extensions)
	CountExtensions(info->extensions, info->nextensions,
			&ext_size, &ext_nlines);

    /*
     * alloc a temporary array of char pointer for the header section which
     * is the hints line + the color table lines
     */
    header_nlines = 1 + image->ncolors;
    header_size = sizeof(char *) * header_nlines;
    header = (char **) XpmCalloc(header_size, sizeof(char *));
    if (!header)
	return (XpmNoMemory);

    /* print the hints line */
    s = buf;
    sprintf(s, "%d %d %d %d", image->width, image->height,
	    image->ncolors, image->cpp);
    s += strlen(s);

    if (info && (info->valuemask & XpmHotspot)) {
	sprintf(s, " %d %d", info->x_hotspot, info->y_hotspot);
	s += strlen(s);
    }
    if (extensions)
	sprintf(s, " XPMEXT");

    l = strlen(buf) + 1;
    *header = (char *) XpmMalloc(l);
    if (!*header)
	RETURN(XpmNoMemory);
    header_size += l;
    strcpy(*header, buf);

    /* print colors */
    ErrorStatus = CreateColors(header + 1, &header_size,
			       image->colorTable, image->ncolors, image->cpp);

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

    /* now we know the size needed, alloc the data and copy the header lines */
    offset = image->width * image->cpp + 1;
    data_size = header_size + (image->height + ext_nlines) * sizeof(char *)
	+ image->height * offset + ext_size;

    data = (char **) XpmMalloc(data_size);
    if (!data)
	RETURN(XpmNoMemory);

    data_nlines = header_nlines + image->height + ext_nlines;
    *data = (char *) (data + data_nlines);
    n = image->ncolors;
    for (l = 0, sptr = data, sptr2 = header; l <= n; l++, sptr++, sptr2++) {
	strcpy(*sptr, *sptr2);
	*(sptr + 1) = *sptr + strlen(*sptr2) + 1;
    }

    /* print pixels */
    data[header_nlines] = (char *) data + header_size
	+ (image->height + ext_nlines) * sizeof(char *);

    CreatePixels(data + header_nlines, image->width, image->height,
		 image->cpp, image->data, image->colorTable);

    /* print extensions */
    if (extensions)
	CreateExtensions(data + header_nlines + image->height - 1, offset,
			 info->extensions, info->nextensions,
			 ext_nlines);

    *data_return = data;

    RETURN(XpmSuccess);
}

static int
CreateColors(char **dataptr, unsigned int *data_size, XpmColor *colors, unsigned int ncolors, unsigned int cpp)
{
    char buf[BUFSIZ];
    unsigned int a, key, l;
    char *s, *s2;
    char **defaults;

    for (a = 0; a < ncolors; a++, colors++, dataptr++) {

	defaults = (char **) colors;
	strncpy(buf, *defaults++, cpp);
	s = buf + cpp;

	for (key = 1; key <= NKEYS; key++, defaults++) {
	    if (s2 = *defaults) {
		sprintf(s, "\t%s %s", xpmColorKeys[key - 1], s2);
		s += strlen(s);
	    }
	}
	l = strlen(buf) + 1;
	s = (char *) XpmMalloc(l);
	if (!s)
	    return (XpmNoMemory);
	*data_size += l;
	strcpy(s, buf);
	*dataptr = s;
    }
    return (XpmSuccess);
}

static void
CreatePixels(char **dataptr, unsigned int width, unsigned int height, unsigned int cpp,
   unsigned int *pixels, XpmColor *colors)
{
    char *s;
    unsigned int x, y, h, offset;

    h = height - 1;
    offset = width * cpp + 1;
    for (y = 0; y < h; y++, dataptr++) {
	s = *dataptr;
	for (x = 0; x < width; x++, pixels++) {
	    strncpy(s, colors[*pixels].string, cpp);
	    s += cpp;
	}
	*s = '\0';
	*(dataptr + 1) = *dataptr + offset;
    }
    /* duplicate some code to avoid a test in the loop */
    s = *dataptr;
    for (x = 0; x < width; x++, pixels++) {
	strncpy(s, colors[*pixels].string, cpp);
	s += cpp;
    }
    *s = '\0';
}

static void
CountExtensions(XpmExtension *ext, unsigned int num, unsigned int *ext_size, unsigned int *ext_nlines)
{
    unsigned int x, y, a, size, nlines;
    char **line;

    size = 0;
    nlines = 0;
    for (x = 0; x < num; x++, ext++) {
	/* 1 for the name */
	nlines += ext->nlines + 1;
	/* 8 = 7 (for "XPMEXT ") + 1 (for 0) */
	size += strlen(ext->name) + 8;
	a = ext->nlines;
	for (y = 0, line = ext->lines; y < a; y++, line++)
	    size += strlen(*line) + 1;
    }
    /* 10 and 1 are for the ending "XPMENDEXT" */
    *ext_size = size + 10;
    *ext_nlines = nlines + 1;
}

static void
CreateExtensions(char **dataptr, unsigned int offset, XpmExtension *ext, unsigned int num, unsigned int ext_nlines)
{
    unsigned int x, y, a, b;
    char **line;

    *(dataptr + 1) = *dataptr + offset;
    dataptr++;
    a = 0;
    for (x = 0; x < num; x++, ext++) {
	sprintf(*dataptr, "XPMEXT %s", ext->name);
	a++;
	if (a < ext_nlines)
	    *(dataptr + 1) = *dataptr + strlen(ext->name) + 8;
	dataptr++;
	b = ext->nlines;
	for (y = 0, line = ext->lines; y < b; y++, line++) {
	    strcpy(*dataptr, *line);
	    a++;
	    if (a < ext_nlines)
		*(dataptr + 1) = *dataptr + strlen(*line) + 1;
	    dataptr++;
	}
    }
    strcpy(*dataptr, "XPMENDEXT");
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 1989-94 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	* XpmCrDataFI.c: *
	28	* *
	29	* XPM library *
	30	* Scan an image and possibly its mask and create an XPM array *
	31	* *
	32	* Developed by Arnaud Le Hors *
	33	\*****************************************************************************/
	34
	35	#include "xpm34p.h"
	36	#ifdef VMS
	37	#include "sys$library:string.h"
	38	#else
	39	#if defined(SYSV) \|\| defined(SVR4)
	40	#include <string.h>
	41	#else
	42	#include <strings.h>
	43	#endif
	44	#endif
	45
	46	LFUNC(CreateColors, int, (char *dataptr, unsigned int data_size,
	47	XpmColor *colors, unsigned int ncolors,
	48	unsigned int cpp));
	49
	50	LFUNC(CreatePixels, void, (char **dataptr, unsigned int width,
	51	unsigned int height, unsigned int cpp,
	52	unsigned int pixels, XpmColor colors));
	53
	54	LFUNC(CountExtensions, void, (XpmExtension *ext, unsigned int num,
	55	unsigned int *ext_size,
	56	unsigned int *ext_nlines));
	57
	58	LFUNC(CreateExtensions, void, (char **dataptr, unsigned int offset,
	59	XpmExtension *ext, unsigned int num,
	60	unsigned int ext_nlines));
	61
	62	int
	63	XpmCreateDataFromImage(Display display, char *data_return, XImage image,
	64	XImage shapeimage, XpmAttributes attributes)
	65	{
	66	XpmImage xpmimage;
	67	XpmInfo info;
	68	int ErrorStatus;
	69
	70	/* initialize return value */
	71	if (data_return)
	72	*data_return = NULL;
	73
	74	/* create an XpmImage from the image */
	75	ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
	76	&xpmimage, attributes);
	77	if (ErrorStatus != XpmSuccess)
	78	return (ErrorStatus);
	79
	80	/* create the data from the XpmImage */
	81	if (attributes) {
	82	xpmSetInfo(&info, attributes);
	83	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, &info);
	84	} else
	85	ErrorStatus = XpmCreateDataFromXpmImage(data_return, &xpmimage, NULL);
	86
	87	/* free the XpmImage */
	88	XpmFreeXpmImage(&xpmimage);
	89
	90	return (ErrorStatus);
	91	}
	92
	93	#undef RETURN
	94	#define RETURN(status) \
	95	{ \
	96	if (header) { \
	97	for (l = 0; l < header_nlines; l++) \
	98	if (header[l]) \
	99	XpmFree(header[l]); \
	100	XpmFree(header); \
	101	} \
	102	return(status); \
	103	}
	104
	105	int
	106	XpmCreateDataFromXpmImage(char **data_return, XpmImage image, XpmInfo *info)
	107	{
	108	/* calculation variables */
	109	int ErrorStatus;
	110	char buf[BUFSIZ];
	111	char header = NULL, data, sptr, sptr2, *s;
	112	unsigned int header_size, header_nlines;
	113	unsigned int data_size, data_nlines;
	114	unsigned int extensions = 0, ext_size = 0, ext_nlines = 0;
	115	unsigned int offset, l, n;
	116
	117	*data_return = NULL;
	118
	119	extensions = info && (info->valuemask & XpmExtensions)
	120	&& info->nextensions;
	121
	122	/* compute the number of extensions lines and size */
	123	if (extensions)
	124	CountExtensions(info->extensions, info->nextensions,
	125	&ext_size, &ext_nlines);
	126
	127	/*
	128	* alloc a temporary array of char pointer for the header section which
	129	* is the hints line + the color table lines
	130	*/
	131	header_nlines = 1 + image->ncolors;
	132	header_size = sizeof(char ) header_nlines;
	133	header = (char *) XpmCalloc(header_size, sizeof(char ));
	134	if (!header)
	135	return (XpmNoMemory);
	136
	137	/* print the hints line */
	138	s = buf;
	139	sprintf(s, "%d %d %d %d", image->width, image->height,
	140	image->ncolors, image->cpp);
	141	s += strlen(s);
	142
	143	if (info && (info->valuemask & XpmHotspot)) {
	144	sprintf(s, " %d %d", info->x_hotspot, info->y_hotspot);
	145	s += strlen(s);
	146	}
	147	if (extensions)
	148	sprintf(s, " XPMEXT");
	149
	150	l = strlen(buf) + 1;
	151	header = (char ) XpmMalloc(l);
	152	if (!*header)
	153	RETURN(XpmNoMemory);
	154	header_size += l;
	155	strcpy(*header, buf);
	156
	157	/* print colors */
	158	ErrorStatus = CreateColors(header + 1, &header_size,
	159	image->colorTable, image->ncolors, image->cpp);
	160
	161	if (ErrorStatus != XpmSuccess)
	162	RETURN(ErrorStatus);
	163
	164	/* now we know the size needed, alloc the data and copy the header lines */
	165	offset = image->width * image->cpp + 1;
	166	data_size = header_size + (image->height + ext_nlines) * sizeof(char *)
	167	+ image->height * offset + ext_size;
	168
	169	data = (char **) XpmMalloc(data_size);
	170	if (!data)
	171	RETURN(XpmNoMemory);
	172
	173	data_nlines = header_nlines + image->height + ext_nlines;
	174	data = (char ) (data + data_nlines);
	175	n = image->ncolors;
	176	for (l = 0, sptr = data, sptr2 = header; l <= n; l++, sptr++, sptr2++) {
	177	strcpy(sptr, sptr2);
	178	(sptr + 1) = sptr + strlen(*sptr2) + 1;
	179	}
	180
	181	/* print pixels */
	182	data[header_nlines] = (char *) data + header_size
	183	+ (image->height + ext_nlines) * sizeof(char *);
	184
	185	CreatePixels(data + header_nlines, image->width, image->height,
	186	image->cpp, image->data, image->colorTable);
	187
	188	/* print extensions */
	189	if (extensions)
	190	CreateExtensions(data + header_nlines + image->height - 1, offset,
	191	info->extensions, info->nextensions,
	192	ext_nlines);
	193
	194	*data_return = data;
	195
	196	RETURN(XpmSuccess);
	197	}
	198
	199	static int
	200	CreateColors(char *dataptr, unsigned int data_size, XpmColor *colors, unsigned int ncolors, unsigned int cpp)
	201	{
	202	char buf[BUFSIZ];
	203	unsigned int a, key, l;
	204	char s, s2;
	205	char **defaults;
	206
	207	for (a = 0; a < ncolors; a++, colors++, dataptr++) {
	208
	209	defaults = (char **) colors;
	210	strncpy(buf, *defaults++, cpp);
	211	s = buf + cpp;
	212
	213	for (key = 1; key <= NKEYS; key++, defaults++) {
	214	if (s2 = *defaults) {
	215	sprintf(s, "\t%s %s", xpmColorKeys[key - 1], s2);
	216	s += strlen(s);
	217	}
	218	}
	219	l = strlen(buf) + 1;
	220	s = (char *) XpmMalloc(l);
	221	if (!s)
	222	return (XpmNoMemory);
	223	*data_size += l;
	224	strcpy(s, buf);
	225	*dataptr = s;
	226	}
	227	return (XpmSuccess);
	228	}
	229
	230	static void
	231	CreatePixels(char **dataptr, unsigned int width, unsigned int height, unsigned int cpp,
	232	unsigned int pixels, XpmColor colors)
	233	{
	234	char *s;
	235	unsigned int x, y, h, offset;
	236
	237	h = height - 1;
	238	offset = width * cpp + 1;
	239	for (y = 0; y < h; y++, dataptr++) {
	240	s = *dataptr;
	241	for (x = 0; x < width; x++, pixels++) {
	242	strncpy(s, colors[*pixels].string, cpp);
	243	s += cpp;
	244	}
	245	*s = '\0';
	246	(dataptr + 1) = dataptr + offset;
	247	}
	248	/* duplicate some code to avoid a test in the loop */
	249	s = *dataptr;
	250	for (x = 0; x < width; x++, pixels++) {
	251	strncpy(s, colors[*pixels].string, cpp);
	252	s += cpp;
	253	}
	254	*s = '\0';
	255	}
	256
	257	static void
	258	CountExtensions(XpmExtension ext, unsigned int num, unsigned int ext_size, unsigned int *ext_nlines)
	259	{
	260	unsigned int x, y, a, size, nlines;
	261	char **line;
	262
	263	size = 0;
	264	nlines = 0;
	265	for (x = 0; x < num; x++, ext++) {
	266	/* 1 for the name */
	267	nlines += ext->nlines + 1;
	268	/* 8 = 7 (for "XPMEXT ") + 1 (for 0) */
	269	size += strlen(ext->name) + 8;
	270	a = ext->nlines;
	271	for (y = 0, line = ext->lines; y < a; y++, line++)
	272	size += strlen(*line) + 1;
	273	}
	274	/* 10 and 1 are for the ending "XPMENDEXT" */
	275	*ext_size = size + 10;
	276	*ext_nlines = nlines + 1;
	277	}
	278
	279	static void
	280	CreateExtensions(char *dataptr, unsigned int offset, XpmExtension ext, unsigned int num, unsigned int ext_nlines)
	281	{
	282	unsigned int x, y, a, b;
	283	char **line;
	284
	285	(dataptr + 1) = dataptr + offset;
	286	dataptr++;
	287	a = 0;
	288	for (x = 0; x < num; x++, ext++) {
	289	sprintf(*dataptr, "XPMEXT %s", ext->name);
	290	a++;
	291	if (a < ext_nlines)
	292	(dataptr + 1) = dataptr + strlen(ext->name) + 8;
	293	dataptr++;
	294	b = ext->nlines;
	295	for (y = 0, line = ext->lines; y < b; y++, line++) {
	296	strcpy(dataptr, line);
	297	a++;
	298	if (a < ext_nlines)
	299	(dataptr + 1) = dataptr + strlen(*line) + 1;
	300	dataptr++;
	301	}
	302	}
	303	strcpy(*dataptr, "XPMENDEXT");
	304	}