src/xpm/crbuffri.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.
 */

/*****************************************************************************\
* XpmCrBufFrI.c:                                                              *
*                                                                             *
*  XPM library                                                                *
*  Scan an image and possibly its mask and create an XPM buffer               *
*                                                                             *
*  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(WriteColors, int, (char **dataptr, unsigned int *data_size,
			 unsigned int *used_size, XpmColor *colors,
			 unsigned int ncolors, unsigned int cpp));

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

LFUNC(WriteExtensions, void, (char *dataptr, unsigned int *used_size,
			      XpmExtension *ext, unsigned int num));

LFUNC(ExtensionsSize, int, (XpmExtension *ext, unsigned int num));
LFUNC(CommentsSize, int, (XpmInfo *info));

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

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

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

    /* create the buffer from the XpmImage */
    if (attributes) {
	xpmSetInfo(&info, attributes);
	ErrorStatus =
	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, &info);
    } else
	ErrorStatus =
	    XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, NULL);

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

    return (ErrorStatus);
}


#undef RETURN
#define RETURN(status) \
{ \
    if (ptr) \
	XpmFree(ptr); \
    return(status); \
}

int
XpmCreateBufferFromXpmImage(char **buffer_return, XpmImage *image, XpmInfo *info)
{
    /* calculation variables */
    int ErrorStatus;
    char buf[BUFSIZ];
    unsigned int cmts, extensions, ext_size = 0;
    unsigned int l, cmt_size = 0;
    char *ptr = NULL, *p;
    unsigned int ptr_size, used_size;

    *buffer_return = NULL;

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

    /* compute the extensions and comments size */
    if (extensions)
	ext_size = ExtensionsSize(info->extensions, info->nextensions);
    if (cmts)
	cmt_size = CommentsSize(info);

    /* write the header line */
    sprintf(buf, "/* XPM */\nstatic char * image_name[] = {\n");
    used_size = strlen(buf);
    ptr_size = used_size + ext_size + cmt_size + 1;
    ptr = (char *) XpmMalloc(ptr_size);
    if (!ptr)
	return XpmNoMemory;
    strcpy(ptr, buf);

    /* write the values line */
    if (cmts && info->hints_cmt) {
	sprintf(ptr + used_size, "/*%s*/\n", info->hints_cmt);
	used_size += strlen(info->hints_cmt) + 5;
    }
    sprintf(buf, "\"%d %d %d %d", image->width, image->height,
	    image->ncolors, image->cpp);
    l = strlen(buf);

    if (info && (info->valuemask & XpmHotspot)) {
	sprintf(buf + l, " %d %d", info->x_hotspot, info->y_hotspot);
	l = strlen(buf);
    }
    if (extensions) {
	sprintf(buf + l, " XPMEXT");
	l = strlen(buf);
    }
    sprintf(buf + l, "\",\n");
    l = strlen(buf);
    ptr_size += l;
    p = (char *) XpmRealloc(ptr, ptr_size);
    if (!p)
	RETURN(XpmNoMemory);
    ptr = p;
    strcpy(ptr + used_size, buf);
    used_size += l;

    /* write colors */
    if (cmts && info->colors_cmt) {
	sprintf(ptr + used_size, "/*%s*/\n", info->colors_cmt);
	used_size += strlen(info->colors_cmt) + 5;
    }
    ErrorStatus = WriteColors(&ptr, &ptr_size, &used_size,
			      image->colorTable, image->ncolors, image->cpp);

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

    /*
     * now we know the exact size we needed, realloc the data 4 = 1 (for
     * '"') + 3 (for '",\n') 1 = - 2 is because the last line does not end
     * with ',\n' + 3 (for '};\n')
     */
    ptr_size += image->height * (image->width * image->cpp + 4) + 1;

    p = (char *) XpmRealloc(ptr, ptr_size);
    if (!p)
	RETURN(XpmNoMemory);
    ptr = p;

    /* print pixels */
    if (cmts && info->pixels_cmt) {
	sprintf(ptr + used_size, "/*%s*/\n", info->pixels_cmt);
	used_size += strlen(info->pixels_cmt) + 5;
    }
    WritePixels(ptr + used_size, &used_size, image->width, image->height,
		image->cpp, image->data, image->colorTable);

    /* print extensions */
    if (extensions)
	WriteExtensions(ptr + used_size, &used_size,
			info->extensions, info->nextensions);

    /* close the array */
    sprintf(ptr + used_size, "};\n");

    *buffer_return = ptr;

    return (XpmSuccess);
}

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

    *buf = '"';
    for (a = 0; a < ncolors; a++, colors++) {

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

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

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

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

static int
ExtensionsSize(XpmExtension *ext, unsigned int num)
{
    unsigned int x, y, a, size;
    char **line;

    size = 0;
    for (x = 0; x < num; x++, ext++) {
	/* 11 = 10 (for ',\n"XPMEXT ') + 1 (for '"') */
	size += strlen(ext->name) + 11;
	a = ext->nlines;
	for (y = 0, line = ext->lines; y < a; y++, line++)
	    /* 4 = 3 (for ',\n"') + 1 (for '"') */
	    size += strlen(*line) + 4;
    }
    /* 13 is for ',\n"XPMENDEXT"' */
    return size + 13;
}

static void
WriteExtensions(char *dataptr, unsigned int *used_size, XpmExtension *ext, unsigned int num)
{
    unsigned int x, y, a;
    char **line;
    char *s = dataptr;

    for (x = 0; x < num; x++, ext++) {
	sprintf(s, ",\n\"XPMEXT %s\"", ext->name);
	s += strlen(ext->name) + 11;
	a = ext->nlines;
	for (y = 0, line = ext->lines; y < a; y++, line++) {
	    sprintf(s, ",\n\"%s\"", *line);
	    s += strlen(*line) + 4;
	}
    }
    strcpy(s, ",\n\"XPMENDEXT\"");
    *used_size += s - dataptr + 13;
}

static int
CommentsSize(XpmInfo *info)
{
    int size = 0;

    /* 5 = 2 (for "/_*") + 3 (for "*_/\n") */
    if (info->hints_cmt)
	size += 5 + strlen(info->hints_cmt);

    if (info->colors_cmt)
	size += 5 + strlen(info->colors_cmt);

    if (info->pixels_cmt)
	size += 5 + strlen(info->pixels_cmt);

    return size;
}
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	* XpmCrBufFrI.c: *
	28	* *
	29	* XPM library *
	30	* Scan an image and possibly its mask and create an XPM buffer *
	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(WriteColors, int, (char *dataptr, unsigned int data_size,
	47	unsigned int used_size, XpmColor colors,
	48	unsigned int ncolors, unsigned int cpp));
	49
	50	LFUNC(WritePixels, void, (char dataptr, unsigned int used_size,
	51	unsigned int width, unsigned int height,
	52	unsigned int cpp, unsigned int *pixels,
	53	XpmColor *colors));
	54
	55	LFUNC(WriteExtensions, void, (char dataptr, unsigned int used_size,
	56	XpmExtension *ext, unsigned int num));
	57
	58	LFUNC(ExtensionsSize, int, (XpmExtension *ext, unsigned int num));
	59	LFUNC(CommentsSize, int, (XpmInfo *info));
	60
	61	int
	62	XpmCreateBufferFromImage(Display display, char buffer_return, XImage image,
	63	XImage shapeimage, XpmAttributes attributes)
	64	{
	65	XpmImage xpmimage;
	66	XpmInfo info;
	67	int ErrorStatus;
	68
	69	/* initialize return value */
	70	if (buffer_return)
	71	*buffer_return = NULL;
	72
	73	/* create an XpmImage from the image */
	74	ErrorStatus = XpmCreateXpmImageFromImage(display, image, shapeimage,
	75	&xpmimage, attributes);
	76	if (ErrorStatus != XpmSuccess)
	77	return (ErrorStatus);
	78
	79	/* create the buffer from the XpmImage */
	80	if (attributes) {
	81	xpmSetInfo(&info, attributes);
	82	ErrorStatus =
	83	XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, &info);
	84	} else
	85	ErrorStatus =
	86	XpmCreateBufferFromXpmImage(buffer_return, &xpmimage, NULL);
	87
	88	/* free the XpmImage */
	89	XpmFreeXpmImage(&xpmimage);
	90
	91	return (ErrorStatus);
	92	}
	93
	94
	95	#undef RETURN
	96	#define RETURN(status) \
	97	{ \
	98	if (ptr) \
	99	XpmFree(ptr); \
	100	return(status); \
	101	}
	102
	103	int
	104	XpmCreateBufferFromXpmImage(char *buffer_return, XpmImage image, XpmInfo *info)
	105	{
	106	/* calculation variables */
	107	int ErrorStatus;
	108	char buf[BUFSIZ];
	109	unsigned int cmts, extensions, ext_size = 0;
	110	unsigned int l, cmt_size = 0;
	111	char ptr = NULL, p;
	112	unsigned int ptr_size, used_size;
	113
	114	*buffer_return = NULL;
	115
	116	cmts = info && (info->valuemask & XpmComments);
	117	extensions = info && (info->valuemask & XpmExtensions)
	118	&& info->nextensions;
	119
	120	/* compute the extensions and comments size */
	121	if (extensions)
	122	ext_size = ExtensionsSize(info->extensions, info->nextensions);
	123	if (cmts)
	124	cmt_size = CommentsSize(info);
	125
	126	/* write the header line */
	127	sprintf(buf, "/* XPM /\nstatic char image_name[] = {\n");
	128	used_size = strlen(buf);
	129	ptr_size = used_size + ext_size + cmt_size + 1;
	130	ptr = (char *) XpmMalloc(ptr_size);
	131	if (!ptr)
	132	return XpmNoMemory;
	133	strcpy(ptr, buf);
	134
	135	/* write the values line */
	136	if (cmts && info->hints_cmt) {
	137	sprintf(ptr + used_size, "/%s/\n", info->hints_cmt);
	138	used_size += strlen(info->hints_cmt) + 5;
	139	}
	140	sprintf(buf, "\"%d %d %d %d", image->width, image->height,
	141	image->ncolors, image->cpp);
	142	l = strlen(buf);
	143
	144	if (info && (info->valuemask & XpmHotspot)) {
	145	sprintf(buf + l, " %d %d", info->x_hotspot, info->y_hotspot);
	146	l = strlen(buf);
	147	}
	148	if (extensions) {
	149	sprintf(buf + l, " XPMEXT");
	150	l = strlen(buf);
	151	}
	152	sprintf(buf + l, "\",\n");
	153	l = strlen(buf);
	154	ptr_size += l;
	155	p = (char *) XpmRealloc(ptr, ptr_size);
	156	if (!p)
	157	RETURN(XpmNoMemory);
	158	ptr = p;
	159	strcpy(ptr + used_size, buf);
	160	used_size += l;
	161
	162	/* write colors */
	163	if (cmts && info->colors_cmt) {
	164	sprintf(ptr + used_size, "/%s/\n", info->colors_cmt);
	165	used_size += strlen(info->colors_cmt) + 5;
	166	}
	167	ErrorStatus = WriteColors(&ptr, &ptr_size, &used_size,
	168	image->colorTable, image->ncolors, image->cpp);
	169
	170	if (ErrorStatus != XpmSuccess)
	171	RETURN(ErrorStatus);
	172
	173	/*
	174	* now we know the exact size we needed, realloc the data 4 = 1 (for
	175	* '"') + 3 (for '",\n') 1 = - 2 is because the last line does not end
	176	* with ',\n' + 3 (for '};\n')
	177	*/
	178	ptr_size += image->height * (image->width * image->cpp + 4) + 1;
	179
	180	p = (char *) XpmRealloc(ptr, ptr_size);
	181	if (!p)
	182	RETURN(XpmNoMemory);
	183	ptr = p;
	184
	185	/* print pixels */
	186	if (cmts && info->pixels_cmt) {
	187	sprintf(ptr + used_size, "/%s/\n", info->pixels_cmt);
	188	used_size += strlen(info->pixels_cmt) + 5;
	189	}
	190	WritePixels(ptr + used_size, &used_size, image->width, image->height,
	191	image->cpp, image->data, image->colorTable);
	192
	193	/* print extensions */
	194	if (extensions)
	195	WriteExtensions(ptr + used_size, &used_size,
	196	info->extensions, info->nextensions);
	197
	198	/* close the array */
	199	sprintf(ptr + used_size, "};\n");
	200
	201	*buffer_return = ptr;
	202
	203	return (XpmSuccess);
	204	}
	205
	206	static int
	207	WriteColors(char *dataptr, unsigned int data_size, unsigned int *used_size,
	208	XpmColor *colors, unsigned int ncolors, unsigned int cpp)
	209	{
	210	char buf[BUFSIZ];
	211	unsigned int a, key, l;
	212	char s, s2;
	213	char **defaults;
	214
	215	*buf = '"';
	216	for (a = 0; a < ncolors; a++, colors++) {
	217
	218	defaults = (char **) colors;
	219	s = buf + 1;
	220	strncpy(s, *defaults++, cpp);
	221	s += cpp;
	222
	223	for (key = 1; key <= NKEYS; key++, defaults++) {
	224	if (s2 = *defaults) {
	225	sprintf(s, "\t%s %s", xpmColorKeys[key - 1], s2);
	226	s += strlen(s);
	227	}
	228	}
	229	strcpy(s, "\",\n");
	230	l = strlen(buf);
	231	s = (char ) XpmRealloc(dataptr, *data_size + l);
	232	if (!s)
	233	return (XpmNoMemory);
	234	*data_size += l;
	235	strcpy(s + *used_size, buf);
	236	*used_size += l;
	237	*dataptr = s;
	238	}
	239	return (XpmSuccess);
	240	}
	241
	242	static void
	243	WritePixels(char dataptr, unsigned int used_size, unsigned int width, unsigned int height,
	244	unsigned int cpp, unsigned int pixels, XpmColor colors)
	245	{
	246	char *s = dataptr;
	247	unsigned int x, y, h;
	248
	249	h = height - 1;
	250	for (y = 0; y < h; y++) {
	251	*s++ = '"';
	252	for (x = 0; x < width; x++, pixels++) {
	253	strncpy(s, colors[*pixels].string, cpp);
	254	s += cpp;
	255	}
	256	strcpy(s, "\",\n");
	257	s += 3;
	258	}
	259	/* duplicate some code to avoid a test in the loop */
	260	*s++ = '"';
	261	for (x = 0; x < width; x++, pixels++) {
	262	strncpy(s, colors[*pixels].string, cpp);
	263	s += cpp;
	264	}
	265	*s++ = '"';
	266	*used_size += s - dataptr;
	267	}
	268
	269	static int
	270	ExtensionsSize(XpmExtension *ext, unsigned int num)
	271	{
	272	unsigned int x, y, a, size;
	273	char **line;
	274
	275	size = 0;
	276	for (x = 0; x < num; x++, ext++) {
	277	/* 11 = 10 (for ',\n"XPMEXT ') + 1 (for '"') */
	278	size += strlen(ext->name) + 11;
	279	a = ext->nlines;
	280	for (y = 0, line = ext->lines; y < a; y++, line++)
	281	/* 4 = 3 (for ',\n"') + 1 (for '"') */
	282	size += strlen(*line) + 4;
	283	}
	284	/* 13 is for ',\n"XPMENDEXT"' */
	285	return size + 13;
	286	}
	287
	288	static void
	289	WriteExtensions(char dataptr, unsigned int used_size, XpmExtension *ext, unsigned int num)
	290	{
	291	unsigned int x, y, a;
	292	char **line;
	293	char *s = dataptr;
	294
	295	for (x = 0; x < num; x++, ext++) {
	296	sprintf(s, ",\n\"XPMEXT %s\"", ext->name);
	297	s += strlen(ext->name) + 11;
	298	a = ext->nlines;
	299	for (y = 0, line = ext->lines; y < a; y++, line++) {
	300	sprintf(s, ",\n\"%s\"", *line);
	301	s += strlen(*line) + 4;
	302	}
	303	}
	304	strcpy(s, ",\n\"XPMENDEXT\"");
	305	*used_size += s - dataptr + 13;
	306	}
	307
	308	static int
	309	CommentsSize(XpmInfo *info)
	310	{
	311	int size = 0;
	312
	313	/* 5 = 2 (for "/_") + 3 (for "_/\n") */
	314	if (info->hints_cmt)
	315	size += 5 + strlen(info->hints_cmt);
	316
	317	if (info->colors_cmt)
	318	size += 5 + strlen(info->colors_cmt);
	319
	320	if (info->pixels_cmt)
	321	size += 5 + strlen(info->pixels_cmt);
	322
	323	return size;
	324	}