![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitpix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libis|
Return to bitpix.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libis |
1.1 root 1: /*
2: * $Source: /u1/X/libis/RCS/bitpix.c,v $
3: * $Header: bitpix.c,v 1.1 86/11/17 14:33:09 swick Rel $
4: */
5:
6: #ifndef lint
7: static char *rcsid_bitpix_c = "$Header: bitpix.c,v 1.1 86/11/17 14:33:09 swick Rel $";
8: #endif lint
9:
10: #include "is-copyright.h"
11:
12: /*
13: *
14: * StoreBitmap Creates a bitmap
15: * FreeBitmap Frees the storage taken by a bitmap
16: * CharBitmap Creates a bitmap from a font character
17: * StorePixmap Creates a pixmap
18: * FreePixmap Frees the storage taken by a pixmap
19: * MakePixmap Create a pixmap from a bitmap
20: * PixmapSave Save a region of the screen
21: * PixmapGet Read a region of the screen
22: *
23: * Copyright (c) 1986, Integrated Solutions, Inc.
24: */
25:
26: #include "Xis.h"
27: #include <errno.h>
28:
29: extern int errno;
30: extern char *malloc();
31:
32: DEVICE *CurrentDevice;
33:
34: PIXMAP *MakePixmap();
35:
36: /*
37: * StoreBitmap
38: *
39: * Store "data" of dimensions ("width, height") in BITMAP data
40: * structure.
41: *
42: * WARNING: Bits are put into "X" order
43: */
44: BITMAP *StoreBitmap(width, height, data)
45: int width, height;
46: char *data;
47: {
48: register BITMAP *bm;
49: register RASTER *r;
50: int size;
51:
52: if ((bm = (BITMAP *) malloc(sizeof (BITMAP))) == NULL) {
53: return (NULL);
54: }
55: bm->width = width;
56: bm->height = height;
57: bm->refcnt = 1;
58:
59: if ((r = (RASTER *) malloc(sizeof(RASTER))) == NULL) {
60: free((caddr_t) bm);
61: return (NULL);
62: }
63: bm->data = (caddr_t) r;
64:
65: size = BitmapSize(width, height);
66: if ((r->address = (short *) malloc(size)) == NULL) {
67: free((RASTER *) bm->data);
68: free((caddr_t) bm);
69: return (NULL);
70: }
71:
72: if (data != NULL) {
73: bcopy((char *)data, r->address, size);
74: SwapShorts((short *) r->address, size);
75: SwapBits((short *) r->address, size);
76: }
77: r->width = ((width+15) >>4) << 1;
78:
79: #ifdef DEBUG
80: if (debug & D_Bitmaps)
81: printf("0x%x = StoreBitmap(width=%d, height=%d, data=0x%x)\n",
82: bm, width, height, data);
83: #endif DEBUG
84:
85: return (bm);
86: }
87:
88: /*
89: * FreeBitmap
90: *
91: * Free bitmap data and bitmap structure.
92: */
93: FreeBitmap(bitmap)
94: register BITMAP *bitmap;
95: {
96:
97: #ifdef DEBUG
98: if (debug & D_Bitmaps)
99: printf("FreeBitmap(bitmap=0x%x)\n", bitmap);
100: #endif DEBUG
101:
102: free (((RASTER *) bitmap->data)->address);
103: free ((caddr_t) bitmap->data);
104: free ((caddr_t) bitmap);
105: }
106:
107: /*
108: * CharBitmap
109: *
110: * Copies a character bitmap from a font
111: */
112: BITMAP *CharBitmap(c, font)
113: unsigned c;
114: register FONT *font;
115: {
116: int width;
117: register BITMAP *bm;
118:
119: #ifdef DEBUG
120: if (debug & D_Bitmaps)
121: printf("CharBitmap(c='%c', font=0x%x)\n", c, font);
122: #endif DEBUG
123:
124: if (c < font->first || c > font->last) {
125: errno = EINVAL;
126: return (NULL);
127: }
128:
129: if (font->fixed)
130: width = font->avg_width;
131: else
132: width = FDATA(font)->widths[c - font->first];
133:
134: if (width == 0) {
135: errno = EINVAL;
136: return (NULL);
137: }
138:
139: bm = (BITMAP *) Xalloc(sizeof (BITMAP));
140: bm->width = width;
141: bm->height = font->height;
142: bm->refcnt = 1;
143: if ((bm->data = (caddr_t)malloc(BitmapSize(width, bm->height))) == NULL) {
144: free((caddr_t) bm);
145: errno = ENOMEM;
146: return (NULL);
147: }
148:
149: CopyText ((caddr_t) &c, 1, font, bm);
150: return (bm);
151: }
152:
153: /*
154: * StorePixmap
155: *
156: * Create a pixmap
157: */
158: PIXMAP *StorePixmap(width, height, format, data)
159: int width, height, format;
160: char *data;
161: {
162: register PIXMAP *pm;
163: register RASTER *r;
164: int size, i;
165:
166: #ifdef DEBUG
167: if (debug & D_Pixmaps)
168: printf("StorePixmap(width=%d, height=%d, format=%d, data=0x%x)\n",
169: width, height, format, data);
170: #endif DEBUG
171:
172: if (format != XYFormat /* 0 */) {
173: return (NULL);
174: }
175: if ((pm = (PIXMAP *) malloc(sizeof(PIXMAP))) == NULL) {
176: return (NULL);
177: }
178: pm->width = width;
179: pm->height = height;
180: if (width == TILE_WIDTH && height == TILE_HEIGHT)
181: pm->tile = CanBeTiled;
182: else
183: pm->tile = CannotBeTiled;
184: pm->kind = XYFORMAT | CurrentDevice->planes;
185: pm->refcnt = 1;
186:
187: if ((r = (RASTER *) malloc(sizeof(RASTER)*CurrentDevice->planes)) == NULL) {
188: free((caddr_t) pm);
189: return (NULL);
190: }
191: pm->data = (caddr_t) r;
192: size = BitmapSize(width, height);
193:
194: for (i=0; i < CurrentDevice->planes; i++, r++) {
195:
196: if ((r->address = (short *) malloc(size)) == NULL) {
197: while (i--)
198: free((caddr_t) ((--r)->address));
199: free((caddr_t) pm->data);
200: free((caddr_t) pm);
201: return (NULL);
202: }
203:
204: if (data != NULL) {
205: bcopy((char *)data, r->address, size);
206: data += size;
207: SwapShorts((short *) r->address, size);
208: SwapBits((short *) r->address, size);
209: }
210:
211: r->width = ((width+15) >>4) << 1;
212: }
213:
214: return (pm);
215: }
216:
217: /* FreePixmap
218: *
219: * Frees the storage consumed by the pixmap.
220: */
221: FreePixmap(pixmap)
222: register PIXMAP *pixmap;
223: {
224: register RASTER* r = (RASTER *)pixmap->data;
225: register int i;
226:
227: #ifdef DEBUG
228: if (debug & D_Pixmaps)
229: printf("FreePixmap(pixmap=0x%x)\n", pixmap);
230: #endif DEBUG
231:
232: for (i=0; i < (pixmap->kind & 0xf); i++, r++)
233: free((caddr_t) r->address);
234: free((caddr_t) pixmap->data);
235: free((caddr_t) pixmap);
236: }
237:
238: /*
239: * MakePixmap
240: *
241: * Make pixmap from bitmap
242: */
243: static PIXMAP constpix[] = {
244: /* width, height, refcnt, tile, kind, *data */
245: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 0},
246: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 1},
247: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 2},
248: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 3},
249: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 4},
250: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 5},
251: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 6},
252: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 7},
253: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 8},
254: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 9},
255: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 10},
256: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 11},
257: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 12},
258: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 13},
259: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 14},
260: {1, 1, 1, CanBeTiled, CONSTANT | 4, (caddr_t) 15},
261: };
262:
263: PIXMAP *MakePixmap(xymask, fore, back)
264: register BITMAP *xymask;
265: int fore, back;
266: {
267: register PIXMAP *pm = NULL;
268: register RASTER* r;
269: register int i, size;
270: #ifdef DEBUG
271: int sfore=fore, sback=back;
272: #endif DEBUG
273:
274: if (xymask == NULL) {
275: pm = &constpix[fore & 0xf];
276: pm->refcnt++;
277: #ifdef DEBUG
278: if (debug & D_Pixmaps)
279: printf("0x%x = MakePixmap(xymask=0x%x, fore=%d, back=%d)\n",
280: pm, xymask, fore, back);
281: #endif DEBUG
282: return (pm);
283: }
284:
285: pm = (PIXMAP *) Xalloc(sizeof(PIXMAP));
286: pm->width = xymask->width;
287: pm->height = xymask->height;
288: pm->refcnt = 1;
289: if (xymask->width == TILE_WIDTH && xymask->height == TILE_HEIGHT)
290: pm->tile = CanBeTiled;
291: else
292: pm->tile = CannotBeTiled;
293: pm->kind = XYFORMAT | CurrentDevice->planes;
294: r = (RASTER *) Xalloc(sizeof(RASTER) * CurrentDevice->planes);
295: pm->data = (caddr_t) r;
296:
297: for (i=0; i < CurrentDevice->planes; i++, r++) {
298:
299: size = BitmapSize(pm->width, pm->height);
300: r->address = (short *) Xalloc(size);
301: r->width = ((pm->width+15) >> 4) << 1;
302:
303: if (fore & 1) {
304: if (back & 1) {
305: /* foreground and background are 1 */
306: /* set to ~0; mask does not matter */
307: register short *d, *limitd;
308: d = r->address;
309: limitd = d + (size>>1);
310: for ( ; d < limitd; )
311: *d++ = ~0;
312: } else {
313: /* foreground is 1 and background is 0 */
314: /* set to mask */
315: bcopy(((RASTER *)(xymask->data))->address, r->address, size);
316: }
317: } else {
318: if (back & 1) {
319: /* foreground is 0 and background is 1 */
320: /* set to inverted mask */
321: register short *s, *d, *limitd;
322: s = ((RASTER *)(xymask->data))->address;
323: d = r->address;
324: limitd = d + (size>>1);
325: for ( ; d < limitd; )
326: *d++ = ~*s++;
327: } else {
328: /* foreground and background are 0 */
329: /* set to 0; mask does not matter */
330: register short *d, *limitd;
331: d = r->address;
332: limitd = d + (size>>1);
333: for ( ; d < limitd; )
334: *d++ = 0;
335: }
336: }
337: fore >>= 1;
338: back >>= 1;
339: }
340:
341: #ifdef DEBUG
342: if (debug & D_Pixmaps)
343: printf("0x%x = MakePixmap(xymask=0x%x, fore=%d, back=%d)\n",
344: pm, xymask, sfore, sback);
345: #endif DEBUG
346:
347: return (pm);
348: }
349:
350: /*
351: * PixmapSave
352: *
353: * Save a region of the screen
354: */
355: PIXMAP *PixmapSave(srcx, srcy, width, height)
356: register int srcx, srcy, width, height;
357: {
358: register PIXMAP *pm = NULL;
359: register RASTER *r;
360: register int i;
361: CLIP bounds;
362:
363: #ifdef DEBUG
364: if (debug & D_Pixmaps)
365: printf("PixmapSave(srcx=%d, srcy=%d, width=%d, height=%d)\n",
366: srcx, srcy, width, height);
367: #endif DEBUG
368:
369: bounds.top = srcy;
370: bounds.left = srcx;
371: bounds.width = width;
372: bounds.height = height;
373: pm = (PIXMAP *) Xalloc(sizeof(PIXMAP));
374: pm->width = width;
375: pm->height = height;
376: pm->refcnt = 1;
377: if (width == TILE_WIDTH && height == TILE_HEIGHT)
378: pm->tile = CanBeTiled;
379: else
380: pm->tile = CannotBeTiled;
381: pm->kind = XYFORMAT | CurrentDevice->planes;
382: r = (RASTER *) Xalloc(sizeof(RASTER) * CurrentDevice->planes);
383: pm->data = (caddr_t) r;
384:
385: for (i=0; i < CurrentDevice->planes; r++, i++) {
386: r->address = (short *) Xalloc(BitmapSize(width, height));
387: r->width = ((width+15) >> 4) << 1;
388: }
389: CheckCursor(bounds);
390: GIP_RasterOp(GIPcopy,
391: &ScreenPixmap, srcx, srcy,
392: pm, 0, 0,
393: (BITMAP *)NULL, 0, 0,
394: width, height,
395: ~0);
396: RestoreCursor();
397: return (pm);
398: }
399:
400: /*
401: * PixmapGet
402: *
403: *
404: */
405: PixmapGet(srcx, srcy, width, height, client, format, swapit)
406: int srcx, srcy, width, height, client, format, swapit;
407: {
408: PIXMAP *pm;
409: register RASTER *r;
410: register int size = BitmapSize(width, height);
411: register int i;
412:
413: #ifdef DEBUG
414: if (debug & D_Pixmaps)
415: printf("PixmapGet(srcx=%d, srcy=%d, width=%d, height=%d, client=%d, format=%d, swapit=%d)\n",
416: srcx, srcy, width, height, client, format, swapit);
417: #endif DEBUG
418:
419: pm = PixmapSave(srcx, srcy, width, height);
420:
421: r = (RASTER *) pm->data;
422: for (i=0; i< CurrentDevice->planes; i++, r++) {
423: SwapBits(r->address, size);
424: if (!swapit) /* our bitmaps need swapping just VAX (un)normal */
425: Swap_shorts((short *) r->address, size >> 1);
426: Write(client, r->address, size);
427: }
428: /* Pad amount written to 32-bit boundary */
429: if ((size*CurrentDevice->planes)%4) {
430: Write(client, r->address, 4 - ((size*CurrentDevice->planes)%4));
431: }
432:
433: FreePixmap(pm);
434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.