src/px/x11raster.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 * x11raster.c - routines to handle images for X windows.
 *
 *      2/18/88
 */

#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>

#include "color.h"
#include "x11raster.h"


XRASTER *
make_raster(disp, vis, npixbits, data, width, height, bm_pad)
Display *disp;
XVisualInfo     *vis;
int     npixbits;
char    *data;
int     width, height;
int     bm_pad;
{
        static long     swaptest = 1;
        register XRASTER        *xr;

        if ((xr = (XRASTER *)calloc(1, sizeof(XRASTER))) == NULL)
                return(NULL);
        xr->disp = disp;
        xr->screen = vis->screen;
        xr->visual = vis->visual;
        if (npixbits == 1)
                xr->image = XCreateImage(disp,vis->visual,1,
                                XYBitmap,0,data,width,height,bm_pad,0);
        else
                xr->image = XCreateImage(disp,vis->visual,vis->depth,
                                ZPixmap,0,data,width,height,bm_pad,0);
        xr->image->bitmap_bit_order = MSBFirst;
        xr->image->bitmap_unit = bm_pad;
        xr->image->byte_order = *(char *)&swaptest ? LSBFirst : MSBFirst;
        if (vis->depth >= 24 && (xr->image->red_mask != 0xff ||
                        xr->image->green_mask != 0xff00 ||
                        xr->image->blue_mask != 0xff0000) &&
                        (xr->image->red_mask != 0xff0000 ||
                        xr->image->green_mask != 0xff00 ||
                        xr->image->blue_mask != 0xff)) {
                xr->image->red_mask = 0xff;
                xr->image->green_mask = 0xff00;
                xr->image->blue_mask = 0xff0000;
        }
        xr->gc = 0;
        return(xr);
}


int
init_rcolors(xr, cmap)                  /* initialize colors */
register XRASTER        *xr;
BYTE    cmap[][3];
{
        register unsigned char  *p;
        register int    i;

        if (xr->image->depth > 8 | xr->ncolors != 0)
                return(xr->ncolors);
        xr->pmap = (short *)malloc(256*sizeof(short));
        if (xr->pmap == NULL)
                return(0);
        xr->cdefs = (XColor *)malloc(256*sizeof(XColor));
        if (xr->cdefs == NULL)
                return(0);
        for (i = 0; i < 256; i++)
                xr->pmap[i] = -1;
        for (p = (unsigned char *)xr->image->data,
                        i = xr->image->width*xr->image->height;
                        i--; p++)
                if (xr->pmap[*p] == -1) {
                        xr->cdefs[xr->ncolors].red = cmap[*p][RED] << 8;
                        xr->cdefs[xr->ncolors].green = cmap[*p][GRN] << 8;
                        xr->cdefs[xr->ncolors].blue = cmap[*p][BLU] << 8;
                        xr->cdefs[xr->ncolors].pixel = *p;
                        xr->cdefs[xr->ncolors].flags = DoRed|DoGreen|DoBlue;
                        xr->pmap[*p] = xr->ncolors++;
                }
        xr->cdefs = (XColor *)realloc((char *)xr->cdefs,
                        xr->ncolors*sizeof(XColor));
        if (xr->cdefs == NULL)
                return(0);
        return(xr->ncolors);
}


Colormap
newcmap(disp, scrn, vis)                /* get colormap and fix b & w */
Display *disp;
int     scrn;
Visual  *vis;
{
        XColor  thiscolor;
        unsigned long   *pixels;
        Colormap        cmap;
        int     n;
        register int    i, j;

        cmap = XCreateColormap(disp, RootWindow(disp,scrn), vis, AllocNone);
        if (cmap == 0 || vis->class != PseudoColor)
                return(cmap);
        pixels=(unsigned long *)malloc(vis->map_entries*sizeof(unsigned long));
        if (pixels == NULL)
                return(0);
        for (n = vis->map_entries; n > 0; n--)
                if (XAllocColorCells(disp, cmap, 0, NULL, 0, pixels, n) != 0)
                        break;
        if (n == 0)
                return(0);
                                        /* reset black and white */
        for (i = 0; i < n; i++) {
                if (pixels[i] != BlackPixel(disp,scrn)
                                && pixels[i] != WhitePixel(disp,scrn))
                        continue;
                thiscolor.pixel = pixels[i];
                thiscolor.flags = DoRed|DoGreen|DoBlue;
                XQueryColor(disp, DefaultColormap(disp,scrn), &thiscolor);
                XStoreColor(disp, cmap, &thiscolor);
                for (j = i; j+1 < n; j++)
                        pixels[j] = pixels[j+1];
                n--;
                i--;
        }
        XFreeColors(disp, cmap, pixels, n, 0);
        free((void *)pixels);
        return(cmap);
}


unsigned long *
map_rcolors(xr, w)                      /* get and assign pixels */
register XRASTER        *xr;
Window  w;
{
        register int    i;
        register unsigned char  *p;

        if (xr->ncolors == 0 || xr->image->depth > 8)
                return(NULL);
        if (xr->pixels != NULL)
                return(xr->pixels);
        xr->pixels = (unsigned long *)malloc(xr->ncolors*sizeof(unsigned long));
        if (xr->pixels == NULL)
                return(NULL);
        if (xr->visual == DefaultVisual(xr->disp, xr->screen))
                xr->cmap = DefaultColormap(xr->disp, xr->screen);
        else
                xr->cmap = newcmap(xr->disp, xr->screen, xr->visual);
        while (XAllocColorCells(xr->disp, xr->cmap, 0,
                        NULL, 0, xr->pixels, xr->ncolors) == 0)
                if (xr->cmap == DefaultColormap(xr->disp, xr->screen))
                        xr->cmap = newcmap(xr->disp, xr->screen, xr->visual);
                else {
                        free((void *)xr->pixels);
                        xr->pixels = NULL;
                        return(NULL);
                }
        for (i = 0; i < xr->ncolors; i++)
                if (xr->pmap[xr->pixels[i]] == -1)
                        break;
        if (i < xr->ncolors) {                  /* different pixels */
                for (p = (unsigned char *)xr->image->data,
                                i = xr->image->width*xr->image->height;
                                i--; p++)
                        *p = xr->pixels[xr->pmap[*p]];
                for (i = 0; i < 256; i++)
                        xr->pmap[i] = -1;
                for (i = 0; i < xr->ncolors; i++) {
                        xr->cdefs[i].pixel = xr->pixels[i];
                        xr->pmap[xr->pixels[i]] = i;
                }
                free_rpixmap(xr);               /* Pixmap invalid */
        }
        XStoreColors(xr->disp, xr->cmap, xr->cdefs, xr->ncolors);
        XSetWindowColormap(xr->disp, w, xr->cmap);
        return(xr->pixels);
}


Pixmap
make_rpixmap(xr, w)                     /* make pixmap for raster */
register XRASTER        *xr;
Window  w;
{
        XWindowAttributes       xwattr;
        Pixmap  pm;

        if (xr->pm != 0)
                return(xr->pm);
        XGetWindowAttributes(xr->disp, w, &xwattr);
        pm = XCreatePixmap(xr->disp, w,
                        xr->image->width, xr->image->height,
                        xwattr.depth);
        if (pm == 0)
                return(0);
        put_raster(pm, 0, 0, xr);
        return(xr->pm = pm);
}


patch_raster(d, xsrc, ysrc, xdst, ydst, width, height, xr)      /* redraw */
Drawable        d;
int     xsrc, ysrc, xdst, ydst;
int     width, height;
register XRASTER        *xr;
{
        if (xsrc >= xr->image->width || ysrc >= xr->image->height)
                return;
        if (xsrc < 0) {
                xdst -= xsrc; width += xsrc;
                xsrc = 0;
        }
        if (ysrc < 0) {
                ydst -= ysrc; height += ysrc;
                ysrc = 0;
        }
        if (width <= 0 || height <= 0)
                return;
        if (xsrc + width > xr->image->width)
                width = xr->image->width - xsrc;
        if (ysrc + height > xr->image->height)
                height = xr->image->height - ysrc;

        if (xr->gc == 0) {
                xr->gc = XCreateGC(xr->disp, d, 0, 0);
                XSetState(xr->disp, xr->gc, BlackPixel(xr->disp,xr->screen),
                        WhitePixel(xr->disp,xr->screen), GXcopy, AllPlanes);
        }
        if (xr->pm == 0)
                XPutImage(xr->disp, d, xr->gc, xr->image, xsrc, ysrc,
                                xdst, ydst, width, height);
        else
                XCopyArea(xr->disp, xr->pm, d, xr->gc, xsrc, ysrc,
                                width, height, xdst, ydst);
}


unmap_rcolors(xr)                       /* free colors */
register XRASTER        *xr;
{
        if (xr->pixels == NULL)
                return;
        XFreeColors(xr->disp, xr->cmap, xr->pixels, xr->ncolors, 0);
        if (xr->cmap != DefaultColormap(xr->disp, xr->screen))
                XFreeColormap(xr->disp, xr->cmap);
        free((void *)xr->pixels);
        xr->pixels = NULL;
}


free_rpixmap(xr)                        /* release Pixmap */
register XRASTER        *xr;
{
        if (xr->pm == 0)
                return;
        XFreePixmap(xr->disp, xr->pm);
        xr->pm = 0;
}


free_raster(xr)                         /* free raster data */
register XRASTER        *xr;
{
        free_rpixmap(xr);
        if (xr->ncolors > 0) {
                unmap_rcolors(xr);
                free((void *)xr->pmap);
                free((void *)xr->cdefs);
        }
        XDestroyImage(xr->image);
        if (xr->gc != 0)
                XFreeGC(xr->disp, xr->gc);
        free((void *)xr);
}
Revision:	2.10
Committed:	Sat Feb 22 02:07:28 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.9:	+7 -12 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.10	static const char RCSid[] = "$Id$";
3	greg	1.1	#endif
4			/*
5			* x11raster.c - routines to handle images for X windows.
6			*
7			* 2/18/88
8			*/
9
10			#include <stdio.h>
11			#include <X11/Xlib.h>
12			#include <X11/Xutil.h>
13
14	greg	2.7	#include "color.h"
15	greg	1.1	#include "x11raster.h"
16
17
18			XRASTER *
19	greg	2.5	make_raster(disp, vis, npixbits, data, width, height, bm_pad)
20	greg	1.1	Display *disp;
21	greg	2.5	XVisualInfo *vis;
22			int npixbits;
23	greg	1.1	char *data;
24			int width, height;
25			int bm_pad;
26			{
27	greg	2.5	static long swaptest = 1;
28	greg	1.1	register XRASTER *xr;
29	greg	2.5
30	greg	1.1	if ((xr = (XRASTER *)calloc(1, sizeof(XRASTER))) == NULL)
31			return(NULL);
32			xr->disp = disp;
33	greg	2.5	xr->screen = vis->screen;
34			xr->visual = vis->visual;
35			if (npixbits == 1)
36			xr->image = XCreateImage(disp,vis->visual,1,
37			XYBitmap,0,data,width,height,bm_pad,0);
38			else
39			xr->image = XCreateImage(disp,vis->visual,vis->depth,
40			ZPixmap,0,data,width,height,bm_pad,0);
41	greg	2.4	xr->image->bitmap_bit_order = MSBFirst;
42	greg	2.6	xr->image->bitmap_unit = bm_pad;
43	greg	2.5	xr->image->byte_order = (char )&swaptest ? LSBFirst : MSBFirst;
44			if (vis->depth >= 24 && (xr->image->red_mask != 0xff \|\|
45			xr->image->green_mask != 0xff00 \|\|
46			xr->image->blue_mask != 0xff0000) &&
47			(xr->image->red_mask != 0xff0000 \|\|
48			xr->image->green_mask != 0xff00 \|\|
49			xr->image->blue_mask != 0xff)) {
50			xr->image->red_mask = 0xff;
51			xr->image->green_mask = 0xff00;
52			xr->image->blue_mask = 0xff0000;
53	greg	1.4	}
54	greg	2.5	xr->gc = 0;
55	greg	1.1	return(xr);
56			}
57
58
59			int
60	greg	2.7	init_rcolors(xr, cmap) /* initialize colors */
61	greg	1.1	register XRASTER *xr;
62	greg	2.7	BYTE cmap[][3];
63	greg	1.1	{
64			register unsigned char *p;
65			register int i;
66
67	greg	2.7	if (xr->image->depth > 8 \| xr->ncolors != 0)
68	greg	1.1	return(xr->ncolors);
69			xr->pmap = (short )malloc(256sizeof(short));
70			if (xr->pmap == NULL)
71			return(0);
72			xr->cdefs = (XColor )malloc(256sizeof(XColor));
73			if (xr->cdefs == NULL)
74			return(0);
75			for (i = 0; i < 256; i++)
76			xr->pmap[i] = -1;
77			for (p = (unsigned char *)xr->image->data,
78			i = xr->image->width*xr->image->height;
79			i--; p++)
80			if (xr->pmap[*p] == -1) {
81	greg	2.7	xr->cdefs[xr->ncolors].red = cmap[*p][RED] << 8;
82			xr->cdefs[xr->ncolors].green = cmap[*p][GRN] << 8;
83			xr->cdefs[xr->ncolors].blue = cmap[*p][BLU] << 8;
84	greg	1.1	xr->cdefs[xr->ncolors].pixel = *p;
85			xr->cdefs[xr->ncolors].flags = DoRed\|DoGreen\|DoBlue;
86			xr->pmap[*p] = xr->ncolors++;
87			}
88			xr->cdefs = (XColor )realloc((char )xr->cdefs,
89			xr->ncolors*sizeof(XColor));
90			if (xr->cdefs == NULL)
91			return(0);
92			return(xr->ncolors);
93			}
94
95	greg	2.5
96	greg	1.3	Colormap
97	greg	2.9	newcmap(disp, scrn, vis) /* get colormap and fix b & w */
98	greg	1.3	Display *disp;
99			int scrn;
100			Visual *vis;
101			{
102			XColor thiscolor;
103			unsigned long *pixels;
104			Colormap cmap;
105			int n;
106			register int i, j;
107	greg	1.1
108	greg	2.9	cmap = XCreateColormap(disp, RootWindow(disp,scrn), vis, AllocNone);
109			if (cmap == 0 \|\| vis->class != PseudoColor)
110			return(cmap);
111	greg	1.3	pixels=(unsigned long )malloc(vis->map_entriessizeof(unsigned long));
112			if (pixels == NULL)
113			return(0);
114			for (n = vis->map_entries; n > 0; n--)
115			if (XAllocColorCells(disp, cmap, 0, NULL, 0, pixels, n) != 0)
116			break;
117			if (n == 0)
118			return(0);
119			/* reset black and white */
120			for (i = 0; i < n; i++) {
121			if (pixels[i] != BlackPixel(disp,scrn)
122			&& pixels[i] != WhitePixel(disp,scrn))
123			continue;
124			thiscolor.pixel = pixels[i];
125			thiscolor.flags = DoRed\|DoGreen\|DoBlue;
126			XQueryColor(disp, DefaultColormap(disp,scrn), &thiscolor);
127			XStoreColor(disp, cmap, &thiscolor);
128			for (j = i; j+1 < n; j++)
129			pixels[j] = pixels[j+1];
130			n--;
131			i--;
132			}
133			XFreeColors(disp, cmap, pixels, n, 0);
134	greg	2.10	free((void *)pixels);
135	greg	1.3	return(cmap);
136			}
137
138
139	greg	1.1	unsigned long *
140	greg	2.9	map_rcolors(xr, w) /* get and assign pixels */
141	greg	1.1	register XRASTER *xr;
142			Window w;
143			{
144			register int i;
145			register unsigned char *p;
146
147	greg	2.6	if (xr->ncolors == 0 \|\| xr->image->depth > 8)
148	greg	1.1	return(NULL);
149			if (xr->pixels != NULL)
150			return(xr->pixels);
151			xr->pixels = (unsigned long )malloc(xr->ncolorssizeof(unsigned long));
152			if (xr->pixels == NULL)
153			return(NULL);
154	greg	1.3	if (xr->visual == DefaultVisual(xr->disp, xr->screen))
155	greg	1.1	xr->cmap = DefaultColormap(xr->disp, xr->screen);
156	greg	1.3	else
157	greg	2.9	xr->cmap = newcmap(xr->disp, xr->screen, xr->visual);
158	greg	1.3	while (XAllocColorCells(xr->disp, xr->cmap, 0,
159			NULL, 0, xr->pixels, xr->ncolors) == 0)
160	greg	1.1	if (xr->cmap == DefaultColormap(xr->disp, xr->screen))
161	greg	2.9	xr->cmap = newcmap(xr->disp, xr->screen, xr->visual);
162	greg	1.3	else {
163	greg	2.10	free((void *)xr->pixels);
164	greg	1.3	xr->pixels = NULL;
165			return(NULL);
166			}
167	greg	1.1	for (i = 0; i < xr->ncolors; i++)
168			if (xr->pmap[xr->pixels[i]] == -1)
169			break;
170			if (i < xr->ncolors) { /* different pixels */
171			for (p = (unsigned char *)xr->image->data,
172			i = xr->image->width*xr->image->height;
173			i--; p++)
174			p = xr->pixels[xr->pmap[p]];
175			for (i = 0; i < 256; i++)
176			xr->pmap[i] = -1;
177			for (i = 0; i < xr->ncolors; i++) {
178			xr->cdefs[i].pixel = xr->pixels[i];
179			xr->pmap[xr->pixels[i]] = i;
180			}
181			free_rpixmap(xr); /* Pixmap invalid */
182			}
183			XStoreColors(xr->disp, xr->cmap, xr->cdefs, xr->ncolors);
184			XSetWindowColormap(xr->disp, w, xr->cmap);
185			return(xr->pixels);
186			}
187
188
189			Pixmap
190	greg	2.6	make_rpixmap(xr, w) /* make pixmap for raster */
191	greg	1.1	register XRASTER *xr;
192	greg	2.6	Window w;
193	greg	1.1	{
194	greg	2.6	XWindowAttributes xwattr;
195	greg	1.1	Pixmap pm;
196
197			if (xr->pm != 0)
198			return(xr->pm);
199	greg	2.6	XGetWindowAttributes(xr->disp, w, &xwattr);
200			pm = XCreatePixmap(xr->disp, w,
201	greg	1.3	xr->image->width, xr->image->height,
202	greg	2.6	xwattr.depth);
203	greg	1.1	if (pm == 0)
204			return(0);
205			put_raster(pm, 0, 0, xr);
206			return(xr->pm = pm);
207	greg	1.2	}
208
209
210			patch_raster(d, xsrc, ysrc, xdst, ydst, width, height, xr) /* redraw */
211			Drawable d;
212			int xsrc, ysrc, xdst, ydst;
213			int width, height;
214			register XRASTER *xr;
215			{
216			if (xsrc >= xr->image->width \|\| ysrc >= xr->image->height)
217			return;
218			if (xsrc < 0) {
219			xdst -= xsrc; width += xsrc;
220			xsrc = 0;
221			}
222			if (ysrc < 0) {
223			ydst -= ysrc; height += ysrc;
224			ysrc = 0;
225			}
226			if (width <= 0 \|\| height <= 0)
227			return;
228			if (xsrc + width > xr->image->width)
229			width = xr->image->width - xsrc;
230			if (ysrc + height > xr->image->height)
231			height = xr->image->height - ysrc;
232
233	greg	2.5	if (xr->gc == 0) {
234			xr->gc = XCreateGC(xr->disp, d, 0, 0);
235			XSetState(xr->disp, xr->gc, BlackPixel(xr->disp,xr->screen),
236			WhitePixel(xr->disp,xr->screen), GXcopy, AllPlanes);
237			}
238	greg	1.2	if (xr->pm == 0)
239			XPutImage(xr->disp, d, xr->gc, xr->image, xsrc, ysrc,
240			xdst, ydst, width, height);
241			else
242			XCopyArea(xr->disp, xr->pm, d, xr->gc, xsrc, ysrc,
243			width, height, xdst, ydst);
244	greg	1.1	}
245
246
247			unmap_rcolors(xr) /* free colors */
248			register XRASTER *xr;
249			{
250			if (xr->pixels == NULL)
251			return;
252			XFreeColors(xr->disp, xr->cmap, xr->pixels, xr->ncolors, 0);
253			if (xr->cmap != DefaultColormap(xr->disp, xr->screen))
254			XFreeColormap(xr->disp, xr->cmap);
255	greg	2.10	free((void *)xr->pixels);
256	greg	1.1	xr->pixels = NULL;
257			}
258
259
260			free_rpixmap(xr) /* release Pixmap */
261			register XRASTER *xr;
262			{
263			if (xr->pm == 0)
264			return;
265			XFreePixmap(xr->disp, xr->pm);
266			xr->pm = 0;
267			}
268
269
270			free_raster(xr) /* free raster data */
271			register XRASTER *xr;
272			{
273			free_rpixmap(xr);
274			if (xr->ncolors > 0) {
275			unmap_rcolors(xr);
276	greg	2.10	free((void *)xr->pmap);
277			free((void *)xr->cdefs);
278	greg	1.1	}
279			XDestroyImage(xr->image);
280	greg	2.5	if (xr->gc != 0)
281			XFreeGC(xr->disp, xr->gc);
282	greg	2.10	free((void *)xr);
283	greg	1.1	}