ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/x11raster.c
(Generate patch)

Comparing ray/src/px/x11raster.c (file contents):
Revision 1.1 by greg, Thu Mar 1 13:18:23 1990 UTC vs.
Revision 2.8 by greg, Mon Jul 19 15:18:10 1993 UTC

# Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14   #include <X11/Xlib.h>
15   #include <X11/Xutil.h>
16  
17 + #include "color.h"
18   #include "x11raster.h"
19  
20 + extern char  *malloc(), *realloc(), *calloc();
21  
22 +
23   XRASTER *
24 < make_raster(disp, scrn, depth, data, width, height, bm_pad)
24 > make_raster(disp, vis, npixbits, data, width, height, bm_pad)
25   Display *disp;
26 < int     scrn;
27 < int     depth;
26 > XVisualInfo     *vis;
27 > int     npixbits;
28   char    *data;
29   int     width, height;
30   int     bm_pad;
31   {
32 +        static long     swaptest = 1;
33          register XRASTER        *xr;
34 <        XVisualInfo     ourvinfo;
31 <                                                /* Pick appropriate Visual */
32 <        if (depth == 1) {
33 <                ourvinfo.visual = DefaultVisual(disp,scrn);
34 <        } else if (depth == 8) {
35 <                if (!XMatchVisualInfo(disp,scrn,8,PseudoColor,&ourvinfo))
36 <                        return(NULL);
37 <        } else if (depth > 12) {
38 <                if (!XMatchVisualInfo(disp,scrn,24,TrueColor,&ourvinfo))
39 <                        return(NULL);
40 <        } else
41 <                return(NULL);
34 >
35          if ((xr = (XRASTER *)calloc(1, sizeof(XRASTER))) == NULL)
36                  return(NULL);
37          xr->disp = disp;
38 <        xr->screen = scrn;
39 <        xr->visual = ourvinfo.visual;
40 <        xr->image = XCreateImage(disp,ourvinfo.visual,depth,
41 <                        ZPixmap,0,data,width,height,bm_pad,0);
42 <        xr->gc = XCreateGC(disp, RootWindow(disp,scrn), 0, 0);
43 <        XSetState(disp, xr->gc, BlackPixel(disp,scrn), WhitePixel(disp,scrn),
44 <                        GXcopy, ~0L);
38 >        xr->screen = vis->screen;
39 >        xr->visual = vis->visual;
40 >        if (npixbits == 1)
41 >                xr->image = XCreateImage(disp,vis->visual,1,
42 >                                XYBitmap,0,data,width,height,bm_pad,0);
43 >        else
44 >                xr->image = XCreateImage(disp,vis->visual,vis->depth,
45 >                                ZPixmap,0,data,width,height,bm_pad,0);
46 >        xr->image->bitmap_bit_order = MSBFirst;
47 >        xr->image->bitmap_unit = bm_pad;
48 >        xr->image->byte_order = *(char *)&swaptest ? LSBFirst : MSBFirst;
49 >        if (vis->depth >= 24 && (xr->image->red_mask != 0xff ||
50 >                        xr->image->green_mask != 0xff00 ||
51 >                        xr->image->blue_mask != 0xff0000) &&
52 >                        (xr->image->red_mask != 0xff0000 ||
53 >                        xr->image->green_mask != 0xff00 ||
54 >                        xr->image->blue_mask != 0xff)) {
55 >                xr->image->red_mask = 0xff;
56 >                xr->image->green_mask = 0xff00;
57 >                xr->image->blue_mask = 0xff0000;
58 >        }
59 >        xr->gc = 0;
60          return(xr);
61   }
62  
63  
64   int
65 < init_rcolors(xr, rmap, gmap, bmap)              /* initialize colors */
65 > init_rcolors(xr, cmap)                  /* initialize colors */
66   register XRASTER        *xr;
67 < unsigned char   rmap[256], gmap[256], bmap[256];
67 > BYTE    cmap[][3];
68   {
69          register unsigned char  *p;
70          register int    i;
71  
72 <        if (xr->image->depth != 8 || xr->ncolors != 0)
72 >        if (xr->image->depth > 8 | xr->ncolors != 0)
73                  return(xr->ncolors);
74          xr->pmap = (short *)malloc(256*sizeof(short));
75          if (xr->pmap == NULL)
# Line 75 | Line 83 | unsigned char  rmap[256], gmap[256], bmap[256];
83                          i = xr->image->width*xr->image->height;
84                          i--; p++)
85                  if (xr->pmap[*p] == -1) {
86 <                        xr->cdefs[xr->ncolors].red = rmap[*p] << 8;
87 <                        xr->cdefs[xr->ncolors].green = gmap[*p] << 8;
88 <                        xr->cdefs[xr->ncolors].blue = bmap[*p] << 8;
86 >                        xr->cdefs[xr->ncolors].red = cmap[*p][RED] << 8;
87 >                        xr->cdefs[xr->ncolors].green = cmap[*p][GRN] << 8;
88 >                        xr->cdefs[xr->ncolors].blue = cmap[*p][BLU] << 8;
89                          xr->cdefs[xr->ncolors].pixel = *p;
90                          xr->cdefs[xr->ncolors].flags = DoRed|DoGreen|DoBlue;
91                          xr->pmap[*p] = xr->ncolors++;
# Line 90 | Line 98 | unsigned char  rmap[256], gmap[256], bmap[256];
98   }
99  
100  
101 + Colormap
102 + newcmap(disp, scrn, w, vis)             /* get colormap and fix b & w */
103 + Display *disp;
104 + int     scrn;
105 + Window  w;
106 + Visual  *vis;
107 + {
108 +        XColor  thiscolor;
109 +        unsigned long   *pixels;
110 +        Colormap        cmap;
111 +        int     n;
112 +        register int    i, j;
113 +
114 +        cmap = XCreateColormap(disp, w, vis, AllocNone);
115 +        if (cmap == 0)
116 +                return(0);
117 +        pixels=(unsigned long *)malloc(vis->map_entries*sizeof(unsigned long));
118 +        if (pixels == NULL)
119 +                return(0);
120 +        for (n = vis->map_entries; n > 0; n--)
121 +                if (XAllocColorCells(disp, cmap, 0, NULL, 0, pixels, n) != 0)
122 +                        break;
123 +        if (n == 0)
124 +                return(0);
125 +                                        /* reset black and white */
126 +        for (i = 0; i < n; i++) {
127 +                if (pixels[i] != BlackPixel(disp,scrn)
128 +                                && pixels[i] != WhitePixel(disp,scrn))
129 +                        continue;
130 +                thiscolor.pixel = pixels[i];
131 +                thiscolor.flags = DoRed|DoGreen|DoBlue;
132 +                XQueryColor(disp, DefaultColormap(disp,scrn), &thiscolor);
133 +                XStoreColor(disp, cmap, &thiscolor);
134 +                for (j = i; j+1 < n; j++)
135 +                        pixels[j] = pixels[j+1];
136 +                n--;
137 +                i--;
138 +        }
139 +        XFreeColors(disp, cmap, pixels, n, 0);
140 +        free((char *)pixels);
141 +        return(cmap);
142 + }
143 +
144 +
145   unsigned long *
146   map_rcolors(xr, w)                              /* get and assign pixels */
147   register XRASTER        *xr;
# Line 97 | Line 149 | Window w;
149   {
150          register int    i;
151          register unsigned char  *p;
100 –        int     j;
152  
153 <        if (xr->ncolors == 0 || xr->image->depth != 8)
153 >        if (xr->ncolors == 0 || xr->image->depth > 8)
154                  return(NULL);
155          if (xr->pixels != NULL)
156                  return(xr->pixels);
157          xr->pixels = (unsigned long *)malloc(xr->ncolors*sizeof(unsigned long));
158          if (xr->pixels == NULL)
159                  return(NULL);
160 <        if (xr->visual == DefaultVisual(xr->disp, xr->screen)) {
160 >        if (xr->visual == DefaultVisual(xr->disp, xr->screen))
161                  xr->cmap = DefaultColormap(xr->disp, xr->screen);
162 <                goto gotmap;
163 <        }
164 < getmap:
165 <        xr->cmap = XCreateColormap(xr->disp, w, xr->visual, AllocNone);
115 < gotmap:
116 <        if (XAllocColorCells(xr->disp, xr->cmap, 0,
117 <                        &j, 0, xr->pixels, xr->ncolors) == 0) {
162 >        else
163 >                xr->cmap = newcmap(xr->disp, xr->screen, w, xr->visual);
164 >        while (XAllocColorCells(xr->disp, xr->cmap, 0,
165 >                        NULL, 0, xr->pixels, xr->ncolors) == 0)
166                  if (xr->cmap == DefaultColormap(xr->disp, xr->screen))
167 <                        goto getmap;
168 <                free((char *)xr->pixels);
169 <                xr->pixels = NULL;
170 <                return(NULL);
171 <        }
167 >                        xr->cmap = newcmap(xr->disp, xr->screen, w, xr->visual);
168 >                else {
169 >                        free((char *)xr->pixels);
170 >                        xr->pixels = NULL;
171 >                        return(NULL);
172 >                }
173          for (i = 0; i < xr->ncolors; i++)
174                  if (xr->pmap[xr->pixels[i]] == -1)
175                          break;
# Line 144 | Line 193 | gotmap:
193  
194  
195   Pixmap
196 < make_rpixmap(xr)                        /* make pixmap for raster */
196 > make_rpixmap(xr, w)                     /* make pixmap for raster */
197   register XRASTER        *xr;
198 + Window  w;
199   {
200 +        XWindowAttributes       xwattr;
201          Pixmap  pm;
202  
203          if (xr->pm != 0)
204                  return(xr->pm);
205 <        pm = XCreatePixmap(xr->disp, RootWindow(xr->disp, xr->screen),
206 <                        xr->image->width, xr->image->height, xr->image->depth);
205 >        XGetWindowAttributes(xr->disp, w, &xwattr);
206 >        pm = XCreatePixmap(xr->disp, w,
207 >                        xr->image->width, xr->image->height,
208 >                        xwattr.depth);
209          if (pm == 0)
210                  return(0);
211          put_raster(pm, 0, 0, xr);
# Line 160 | Line 213 | register XRASTER       *xr;
213   }
214  
215  
216 + patch_raster(d, xsrc, ysrc, xdst, ydst, width, height, xr)      /* redraw */
217 + Drawable        d;
218 + int     xsrc, ysrc, xdst, ydst;
219 + int     width, height;
220 + register XRASTER        *xr;
221 + {
222 +        if (xsrc >= xr->image->width || ysrc >= xr->image->height)
223 +                return;
224 +        if (xsrc < 0) {
225 +                xdst -= xsrc; width += xsrc;
226 +                xsrc = 0;
227 +        }
228 +        if (ysrc < 0) {
229 +                ydst -= ysrc; height += ysrc;
230 +                ysrc = 0;
231 +        }
232 +        if (width <= 0 || height <= 0)
233 +                return;
234 +        if (xsrc + width > xr->image->width)
235 +                width = xr->image->width - xsrc;
236 +        if (ysrc + height > xr->image->height)
237 +                height = xr->image->height - ysrc;
238 +
239 +        if (xr->gc == 0) {
240 +                xr->gc = XCreateGC(xr->disp, d, 0, 0);
241 +                XSetState(xr->disp, xr->gc, BlackPixel(xr->disp,xr->screen),
242 +                        WhitePixel(xr->disp,xr->screen), GXcopy, AllPlanes);
243 +        }
244 +        if (xr->pm == 0)
245 +                XPutImage(xr->disp, d, xr->gc, xr->image, xsrc, ysrc,
246 +                                xdst, ydst, width, height);
247 +        else
248 +                XCopyArea(xr->disp, xr->pm, d, xr->gc, xsrc, ysrc,
249 +                                width, height, xdst, ydst);
250 + }
251 +
252 +
253   unmap_rcolors(xr)                       /* free colors */
254   register XRASTER        *xr;
255   {
# Line 193 | Line 283 | register XRASTER       *xr;
283                  free((char *)xr->cdefs);
284          }
285          XDestroyImage(xr->image);
286 <        XFreeGC(xr->disp, xr->gc);
286 >        if (xr->gc != 0)
287 >                XFreeGC(xr->disp, xr->gc);
288          free((char *)xr);
289   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines