src/mac/xpm/macx.c

/*
 * Copyright (C) 1998 Stefan Csomor
 *
 * 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
 * Lorens Younes 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 Lorens Younes shall not be
 * used in advertising or otherwise to promote the sale, use or other dealings
 * in this Software without prior written authorization from Lorens Younes.
 */

/*****************************************************************************\
* amigax.c:                                                                   *
*                                                                             *
*  XPM library                                                                *
*  Emulates some Xlib functionality for Amiga.                                *
*                                                                             *
*  Developed by Lorens Younes (d93-hyo@nada.kth.se) 7/95                      *
*  Revised 4/96                                                               *
\*****************************************************************************/

#include "xpmi.h"
//#include "macx.h"
#include "simx.h"

XImage *
AllocXImage (
    unsigned int   width,
    unsigned int   height,
    unsigned int   depth)
{
    XImage  *img;

    img = XpmMalloc (sizeof (*img));
    if (img != NULL)
    {
			Rect rect ;
			rect.left = rect.top = 0 ;
			rect.bottom = height ;
			rect.right = width ;

			img->width = width;
			img->height = height;


			NewGWorld( &img->gworldptr , depth , &rect , NULL , NULL , 0 ) ;
			if (img->gworldptr == NULL)
			{
		    	XDestroyImage (img);
		    	return NULL;
			}
    }

    return img;
}

/*

static struct RastPort *
AllocRastPort (unsigned int, unsigned int, unsigned int);
static void
FreeRastPort (struct RastPort *, unsigned int,unsigned int);


static struct RastPort *
AllocRastPort (
    unsigned int   width,
    unsigned int   height,
    unsigned int   depth)
{
    struct RastPort  *rp;

    rp = XpmMalloc (sizeof (*rp));
    if (rp != NULL)
    {
	InitRastPort (rp);
	if (GfxBase->LibNode.lib_Version >= 39)
	{
	    rp->BitMap = AllocBitMap (width, height, depth, BMF_CLEAR, NULL);
	    if (rp->BitMap == NULL)
	    {
		FreeRastPort (rp, width, height);
		return NULL;
	    }
	}
	else
	{
	    unsigned int   i;

	    rp->BitMap = XpmMalloc (sizeof (*rp->BitMap));
	    if (rp->BitMap == NULL)
	    {
		FreeRastPort (rp, width, height);
		return NULL;
	    }

	    InitBitMap (rp->BitMap, depth, width, height);
	    for (i = 0; i < depth; ++i)
		rp->BitMap->Planes[i] = NULL;
	    for (i = 0; i < depth; ++i)
	    {
		rp->BitMap->Planes[i] = (PLANEPTR)AllocRaster (width, height);
		if (rp->BitMap->Planes[i] == NULL)
		{
		    FreeRastPort (rp, width, height);
		    return NULL;
		}
	    }
	}
    }

    return rp;
}


static void
FreeRastPort (
    struct RastPort  *rp,
    unsigned int      width,
    unsigned int      height)
{
    if (rp != NULL)
    {
	if (rp->BitMap != NULL)
	{
	    WaitBlit ();
	    if (GfxBase->LibNode.lib_Version >= 39)
		FreeBitMap (rp->BitMap);
	    else
	    {
		unsigned int   i;

		for (i = 0; i < rp->BitMap->Depth; ++i)
		{
		    if (rp->BitMap->Planes[i] != NULL)
			FreeRaster (rp->BitMap->Planes[i], width, height);
		}
		XpmFree (rp->BitMap);
	    }
	}
	XpmFree (rp);
    }
}


XImage *
AllocXImage (
    unsigned int   width,
    unsigned int   height,
    unsigned int   depth)
{
    XImage  *img;

    img = XpmMalloc (sizeof (*img));
    if (img != NULL)
    {
	img->width = width;
	img->height = height;
	img->rp = AllocRastPort (img->width, img->height, depth);
	if (img->rp == NULL)
	{
	    FreeXImage (img);
	    return NULL;
	}
    }

    return img;
}


int
FreeXImage (
    XImage  *ximage)
{
    if (ximage != NULL)
    {
	FreeRastPort (ximage->rp, ximage->width, ximage->height);
	XpmFree (ximage);
    }

    return Success;
}


int
XPutPixel (
    XImage         *ximage,
    int             x,
    int             y,
    unsigned long   pixel)
{
    SetAPen (ximage->rp, pixel);
    WritePixel (ximage->rp, x, y);

    return Success;
}


Status
AllocBestPen (
    Colormap        colormap,
    XColor         *screen_in_out,
    unsigned long   precision,
    Bool            fail_if_bad)
{
    if (GfxBase->LibNode.lib_Version >= 39)
    {
	unsigned long   r, g, b;

	r = screen_in_out->red * 0x00010001;
	g = screen_in_out->green * 0x00010001;
	b = screen_in_out->blue * 0x00010001;
	screen_in_out->pixel = ObtainBestPen (colormap, r, g, b,
					      OBP_Precision, precision,
					      OBP_FailIfBad, fail_if_bad,
					      TAG_DONE);
	if (screen_in_out->pixel == -1)
	    return False;

	QueryColor (colormap, screen_in_out);
    }
    else
    {
	XColor   nearest, trial;
	long     nearest_delta, trial_delta;
	int      num_cells, i;

	num_cells = colormap->Count;
	nearest.pixel = 0;
	QueryColor (colormap, &nearest);
	nearest_delta = ((((screen_in_out->red >> 8) - (nearest.red >> 8))
			  * ((screen_in_out->red >> 8) - (nearest.red >> 8)))
			 +
			 (((screen_in_out->green >> 8) - (nearest.green >> 8))
			  * ((screen_in_out->green >> 8) - (nearest.green >> 8)))
			 +
			 (((screen_in_out->blue >> 8) - (nearest.blue >> 8))
			  * ((screen_in_out->blue >> 8) - (nearest.blue >> 8))));
	for (i = 1; i < num_cells; i++)
	{
	// precision and fail_if_bad is ignored under pre V39
	    trial.pixel = i;
	    QueryColor (colormap, &trial);
	    trial_delta = ((((screen_in_out->red >> 8) - (trial.red >> 8))
			    * ((screen_in_out->red >> 8) - (trial.red >> 8)))
			   +
			   (((screen_in_out->green >> 8) - (trial.green >> 8))
			    * ((screen_in_out->green >> 8) - (trial.green >> 8)))
			   +
			   (((screen_in_out->blue >> 8) - (trial.blue >> 8))
			    * ((screen_in_out->blue >> 8) - (trial.blue >> 8))));
	    if (trial_delta < nearest_delta)
	    {
		nearest = trial;
		nearest_delta = trial_delta;
	    }
	}
	screen_in_out->pixel = nearest.pixel;
	screen_in_out->red = nearest.red;
	screen_in_out->green = nearest.green;
	screen_in_out->blue = nearest.blue;
    }

    return True;
}


int
FreePens (
    Colormap        colormap,
    unsigned long  *pixels,
    int             npixels)
{
    if (GfxBase->LibNode.lib_Version >= 39)
    {
	int   i;

	for (i = 0; i < npixels; i++)
	    ReleasePen (colormap, pixels[i]);
    }

    return Success;
}


Status
ParseColor (
    char    *spec,
    XColor  *exact_def_return)
{
    int spec_length;

    if (spec == 0)
	return False;

    spec_length = strlen(spec);
    if (spec[0] == '#')
    {
	int hexlen;
	char hexstr[10];

	hexlen = (spec_length - 1) / 3;
	if (hexlen < 1 || hexlen > 4 || hexlen * 3 != spec_length - 1)
	    return False;

	hexstr[hexlen] = '\0';
	strncpy (hexstr, spec + 1, hexlen);
	exact_def_return->red = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);
	strncpy (hexstr, spec + 1 + hexlen, hexlen);
	exact_def_return->green = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);
	strncpy (hexstr, spec + 1 + 2 * hexlen, hexlen);
	exact_def_return->blue = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);

	return True;
    }
    else
    {
	FILE  *rgbf;
	int    items, red, green, blue;
	char   line[512], name[512];
	Bool   success = False;

	rgbf = fopen ("LIBS:rgb.txt", "r");
	if (rgbf == NULL)
	    return False;

	while (fgets(line, sizeof (line), rgbf) && !success)
	{
	    items = sscanf (line, "%d %d %d %[^\n]\n",
			    &red, &green, &blue, name);
	    if (items != 4)
		continue;

	    if (red < 0 || red > 0xFF
		|| green < 0 || green > 0xFF
		|| blue < 0 || blue > 0xFF)
	    {
		continue;
	    }

	    if (0 == xpmstrcasecmp (spec, name))
	    {
		exact_def_return->red = red * 0x0101;
		exact_def_return->green = green * 0x0101;
		exact_def_return->blue = blue * 0x0101;
		success = True;
	    }
	}
	fclose (rgbf);

	return success;
    }
}


int
QueryColor (
    Colormap   colormap,
    XColor    *def_in_out)
{
    if (GfxBase->LibNode.lib_Version >= 39)
    {
	unsigned long   rgb[3];

	GetRGB32 (colormap, def_in_out->pixel, 1, rgb);
	def_in_out->red = rgb[0] >> 16;
	def_in_out->green = rgb[1] >> 16;
	def_in_out->blue = rgb[2] >> 16;
    }
    else
    {
	unsigned short   rgb;

	rgb = GetRGB4 (colormap, def_in_out->pixel);
	def_in_out->red = ((rgb >> 8) & 0xF) * 0x1111;
	def_in_out->green = ((rgb >> 4) & 0xF) * 0x1111;
	def_in_out->blue = (rgb & 0xF) * 0x1111;
    }

    return Success;
}


int
QueryColors (
    Colormap   colormap,
    XColor    *defs_in_out,
    int        ncolors)
{
    int   i;

    for (i = 0; i < ncolors; i++)
	QueryColor (colormap, &defs_in_out[i]);

    return Success;
}

*/
Commit	Line	Data
	1	/*
	2	* Copyright (C) 1998 Stefan Csomor
	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	* Lorens Younes BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
	18	* IN 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 Lorens Younes 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 Lorens Younes.
	24	*/
	25
	26	/*****************************************************************************\
	27	* amigax.c: *
	28	* *
	29	* XPM library *
	30	* Emulates some Xlib functionality for Amiga. *
	31	* *
	32	* Developed by Lorens Younes (d93-hyo@nada.kth.se) 7/95 *
	33	* Revised 4/96 *
	34	\*****************************************************************************/
	35
	36	#include "xpmi.h"
	37	//#include "macx.h"
	38	#include "simx.h"
	39
	40	XImage *
	41	AllocXImage (
	42	unsigned int width,
	43	unsigned int height,
	44	unsigned int depth)
	45	{
	46	XImage *img;
	47
	48	img = XpmMalloc (sizeof (*img));
	49	if (img != NULL)
	50	{
	51	Rect rect ;
	52	rect.left = rect.top = 0 ;
	53	rect.bottom = height ;
	54	rect.right = width ;
	55
	56	img->width = width;
	57	img->height = height;
	58
	59
	60	NewGWorld( &img->gworldptr , depth , &rect , NULL , NULL , 0 ) ;
	61	if (img->gworldptr == NULL)
	62	{
	63	XDestroyImage (img);
	64	return NULL;
	65	}
	66	}
	67
	68	return img;
	69	}
	70
	71	/*
	72
	73	static struct RastPort *
	74	AllocRastPort (unsigned int, unsigned int, unsigned int);
	75	static void
	76	FreeRastPort (struct RastPort *, unsigned int,unsigned int);
	77
	78
	79	static struct RastPort *
	80	AllocRastPort (
	81	unsigned int width,
	82	unsigned int height,
	83	unsigned int depth)
	84	{
	85	struct RastPort *rp;
	86
	87	rp = XpmMalloc (sizeof (*rp));
	88	if (rp != NULL)
	89	{
	90	InitRastPort (rp);
	91	if (GfxBase->LibNode.lib_Version >= 39)
	92	{
	93	rp->BitMap = AllocBitMap (width, height, depth, BMF_CLEAR, NULL);
	94	if (rp->BitMap == NULL)
	95	{
	96	FreeRastPort (rp, width, height);
	97	return NULL;
	98	}
	99	}
	100	else
	101	{
	102	unsigned int i;
	103
	104	rp->BitMap = XpmMalloc (sizeof (*rp->BitMap));
	105	if (rp->BitMap == NULL)
	106	{
	107	FreeRastPort (rp, width, height);
	108	return NULL;
	109	}
	110
	111	InitBitMap (rp->BitMap, depth, width, height);
	112	for (i = 0; i < depth; ++i)
	113	rp->BitMap->Planes[i] = NULL;
	114	for (i = 0; i < depth; ++i)
	115	{
	116	rp->BitMap->Planes[i] = (PLANEPTR)AllocRaster (width, height);
	117	if (rp->BitMap->Planes[i] == NULL)
	118	{
	119	FreeRastPort (rp, width, height);
	120	return NULL;
	121	}
	122	}
	123	}
	124	}
	125
	126	return rp;
	127	}
	128
	129
	130	static void
	131	FreeRastPort (
	132	struct RastPort *rp,
	133	unsigned int width,
	134	unsigned int height)
	135	{
	136	if (rp != NULL)
	137	{
	138	if (rp->BitMap != NULL)
	139	{
	140	WaitBlit ();
	141	if (GfxBase->LibNode.lib_Version >= 39)
	142	FreeBitMap (rp->BitMap);
	143	else
	144	{
	145	unsigned int i;
	146
	147	for (i = 0; i < rp->BitMap->Depth; ++i)
	148	{
	149	if (rp->BitMap->Planes[i] != NULL)
	150	FreeRaster (rp->BitMap->Planes[i], width, height);
	151	}
	152	XpmFree (rp->BitMap);
	153	}
	154	}
	155	XpmFree (rp);
	156	}
	157	}
	158
	159
	160	XImage *
	161	AllocXImage (
	162	unsigned int width,
	163	unsigned int height,
	164	unsigned int depth)
	165	{
	166	XImage *img;
	167
	168	img = XpmMalloc (sizeof (*img));
	169	if (img != NULL)
	170	{
	171	img->width = width;
	172	img->height = height;
	173	img->rp = AllocRastPort (img->width, img->height, depth);
	174	if (img->rp == NULL)
	175	{
	176	FreeXImage (img);
	177	return NULL;
	178	}
	179	}
	180
	181	return img;
	182	}
	183
	184
	185	int
	186	FreeXImage (
	187	XImage *ximage)
	188	{
	189	if (ximage != NULL)
	190	{
	191	FreeRastPort (ximage->rp, ximage->width, ximage->height);
	192	XpmFree (ximage);
	193	}
	194
	195	return Success;
	196	}
	197
	198
	199	int
	200	XPutPixel (
	201	XImage *ximage,
	202	int x,
	203	int y,
	204	unsigned long pixel)
	205	{
	206	SetAPen (ximage->rp, pixel);
	207	WritePixel (ximage->rp, x, y);
	208
	209	return Success;
	210	}
	211
	212
	213	Status
	214	AllocBestPen (
	215	Colormap colormap,
	216	XColor *screen_in_out,
	217	unsigned long precision,
	218	Bool fail_if_bad)
	219	{
	220	if (GfxBase->LibNode.lib_Version >= 39)
	221	{
	222	unsigned long r, g, b;
	223
	224	r = screen_in_out->red * 0x00010001;
	225	g = screen_in_out->green * 0x00010001;
	226	b = screen_in_out->blue * 0x00010001;
	227	screen_in_out->pixel = ObtainBestPen (colormap, r, g, b,
	228	OBP_Precision, precision,
	229	OBP_FailIfBad, fail_if_bad,
	230	TAG_DONE);
	231	if (screen_in_out->pixel == -1)
	232	return False;
	233
	234	QueryColor (colormap, screen_in_out);
	235	}
	236	else
	237	{
	238	XColor nearest, trial;
	239	long nearest_delta, trial_delta;
	240	int num_cells, i;
	241
	242	num_cells = colormap->Count;
	243	nearest.pixel = 0;
	244	QueryColor (colormap, &nearest);
	245	nearest_delta = ((((screen_in_out->red >> 8) - (nearest.red >> 8))
	246	* ((screen_in_out->red >> 8) - (nearest.red >> 8)))
	247	+
	248	(((screen_in_out->green >> 8) - (nearest.green >> 8))
	249	* ((screen_in_out->green >> 8) - (nearest.green >> 8)))
	250	+
	251	(((screen_in_out->blue >> 8) - (nearest.blue >> 8))
	252	* ((screen_in_out->blue >> 8) - (nearest.blue >> 8))));
	253	for (i = 1; i < num_cells; i++)
	254	{
	255	// precision and fail_if_bad is ignored under pre V39
	256	trial.pixel = i;
	257	QueryColor (colormap, &trial);
	258	trial_delta = ((((screen_in_out->red >> 8) - (trial.red >> 8))
	259	* ((screen_in_out->red >> 8) - (trial.red >> 8)))
	260	+
	261	(((screen_in_out->green >> 8) - (trial.green >> 8))
	262	* ((screen_in_out->green >> 8) - (trial.green >> 8)))
	263	+
	264	(((screen_in_out->blue >> 8) - (trial.blue >> 8))
	265	* ((screen_in_out->blue >> 8) - (trial.blue >> 8))));
	266	if (trial_delta < nearest_delta)
	267	{
	268	nearest = trial;
	269	nearest_delta = trial_delta;
	270	}
	271	}
	272	screen_in_out->pixel = nearest.pixel;
	273	screen_in_out->red = nearest.red;
	274	screen_in_out->green = nearest.green;
	275	screen_in_out->blue = nearest.blue;
	276	}
	277
	278	return True;
	279	}
	280
	281
	282	int
	283	FreePens (
	284	Colormap colormap,
	285	unsigned long *pixels,
	286	int npixels)
	287	{
	288	if (GfxBase->LibNode.lib_Version >= 39)
	289	{
	290	int i;
	291
	292	for (i = 0; i < npixels; i++)
	293	ReleasePen (colormap, pixels[i]);
	294	}
	295
	296	return Success;
	297	}
	298
	299
	300	Status
	301	ParseColor (
	302	char *spec,
	303	XColor *exact_def_return)
	304	{
	305	int spec_length;
	306
	307	if (spec == 0)
	308	return False;
	309
	310	spec_length = strlen(spec);
	311	if (spec[0] == '#')
	312	{
	313	int hexlen;
	314	char hexstr[10];
	315
	316	hexlen = (spec_length - 1) / 3;
	317	if (hexlen < 1 \|\| hexlen > 4 \|\| hexlen * 3 != spec_length - 1)
	318	return False;
	319
	320	hexstr[hexlen] = '\0';
	321	strncpy (hexstr, spec + 1, hexlen);
	322	exact_def_return->red = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);
	323	strncpy (hexstr, spec + 1 + hexlen, hexlen);
	324	exact_def_return->green = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);
	325	strncpy (hexstr, spec + 1 + 2 * hexlen, hexlen);
	326	exact_def_return->blue = strtoul (hexstr, NULL, 16) << (16 - 4*hexlen);
	327
	328	return True;
	329	}
	330	else
	331	{
	332	FILE *rgbf;
	333	int items, red, green, blue;
	334	char line[512], name[512];
	335	Bool success = False;
	336
	337	rgbf = fopen ("LIBS:rgb.txt", "r");
	338	if (rgbf == NULL)
	339	return False;
	340
	341	while (fgets(line, sizeof (line), rgbf) && !success)
	342	{
	343	items = sscanf (line, "%d %d %d %[^\n]\n",
	344	&red, &green, &blue, name);
	345	if (items != 4)
	346	continue;
	347
	348	if (red < 0 \|\| red > 0xFF
	349	\|\| green < 0 \|\| green > 0xFF
	350	\|\| blue < 0 \|\| blue > 0xFF)
	351	{
	352	continue;
	353	}
	354
	355	if (0 == xpmstrcasecmp (spec, name))
	356	{
	357	exact_def_return->red = red * 0x0101;
	358	exact_def_return->green = green * 0x0101;
	359	exact_def_return->blue = blue * 0x0101;
	360	success = True;
	361	}
	362	}
	363	fclose (rgbf);
	364
	365	return success;
	366	}
	367	}
	368
	369
	370	int
	371	QueryColor (
	372	Colormap colormap,
	373	XColor *def_in_out)
	374	{
	375	if (GfxBase->LibNode.lib_Version >= 39)
	376	{
	377	unsigned long rgb[3];
	378
	379	GetRGB32 (colormap, def_in_out->pixel, 1, rgb);
	380	def_in_out->red = rgb[0] >> 16;
	381	def_in_out->green = rgb[1] >> 16;
	382	def_in_out->blue = rgb[2] >> 16;
	383	}
	384	else
	385	{
	386	unsigned short rgb;
	387
	388	rgb = GetRGB4 (colormap, def_in_out->pixel);
	389	def_in_out->red = ((rgb >> 8) & 0xF) * 0x1111;
	390	def_in_out->green = ((rgb >> 4) & 0xF) * 0x1111;
	391	def_in_out->blue = (rgb & 0xF) * 0x1111;
	392	}
	393
	394	return Success;
	395	}
	396
	397
	398	int
	399	QueryColors (
	400	Colormap colormap,
	401	XColor *defs_in_out,
	402	int ncolors)
	403	{
	404	int i;
	405
	406	for (i = 0; i < ncolors; i++)
	407	QueryColor (colormap, &defs_in_out[i]);
	408
	409	return Success;
	410	}
	411
	412	*/