![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nest.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 / libnest|
Return to nest.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libnest |
1.1 root 1: #include <X/mit-copyright.h>
2:
3: /* Copyright Massachusetts Institute of Technology 1986 */
4:
5: #include <sys/types.h>
6: #include "../Xlib/Xlib.h"
7: #undef CURSOR
8: #include "../Xlib/Xkeyboard.h"
9: #include <stdio.h>
10: #include <errno.h>
11: #include "../X/vsinput.h"
12: #include "../X/Xdev.h"
13:
14: extern int errno, XFlush();
15: char *Xalloc(), *Xrealloc(), *strcpy();
16:
17: #define Xpixmap(p) ((Pixmap) p->data)
18: #define Xbitmap(b) ((Bitmap) b->data)
19: #define Xfinf(f) ((FontInfo *) f->data)
20: #define Xfont(f) (Xfinf(f)->id)
21: #define Xcursor(c) ((Cursor) c->data)
22: #define npix(p) (((p) << pixshift) | basepix)
23: #define opix(p) (((p) &~ basepix) >> pixshift)
24: #define nmask(m) ((m) << pixshift)
25:
26: static Window w, t, ot, tt;
27: static int extrapix;
28: static int pixplanes = 0;
29: static int pixshift = 0;
30: static int basepix = 0;
31: static int screen_height, screen_width;
32: static int tilex = 0;
33: static int tiley = 0;
34: static CLIP tileclip = {0, 0, 0, 0};
35: static vsCursor mouse = {0, 0};
36: static vsBox mbox = {0, 0, 0, 0};
37: static int cursor_x, cursor_y;
38: static DEVICE *dev;
39:
40: /*ARGSUSED*/
41: ProcessInput (ev)
42: vsEvent ev;
43: {
44: }
45:
46: /*ARGSUSED*/
47: OpenDisplay (display)
48: char *display; /* display number */
49: {
50: OpaqueFrame frame;
51: char def[32];
52: char *option;
53: Color cdef;
54:
55: if (XOpenDisplay((char *) NULL) == NULL) {
56: errno = EINVAL;
57: return(-1);
58: }
59: if (option = XGetDefault("X", "BorderWidth"))
60: frame.bdrwidth = atoi(option);
61: else
62: frame.bdrwidth = 0;
63: if (frame.bdrwidth && DisplayCells() > 2 &&
64: (option = XGetDefault("X", "Border")) &&
65: XParseColor(option, &cdef) &&
66: XGetHardwareColor(&cdef))
67: frame.border = XMakeTile(cdef.pixel);
68: else
69: frame.border = BlackPixmap;
70: frame.background = NULL;
71: frame.x = 0;
72: frame.y = 0;
73: sprintf(def, "=%dx%d+0+0",
74: DisplayWidth() - (frame.bdrwidth << 1),
75: DisplayHeight() - (frame.bdrwidth << 1));
76: w = XCreate("X", "X", "", def, &frame, 50, 50);
77: screen_height = frame.height;
78: screen_width = frame.width;
79: XMapWindow(w);
80: XSelectInput(w, KeyPressed|KeyReleased|ButtonPressed|ButtonReleased|
81: MouseMoved|EnterWindow|LeaveWindow);
82: t = XCreateTransparency(w, 0, 0, screen_width, screen_height);
83: ot = XCreateTransparency(w, 0, 0, screen_width, screen_height);
84: XTileAbsolute(ot);
85: tt = XCreateTransparency(ot, 0, 0, screen_width, screen_height);
86: XMapWindow(t);
87: XMapWindow(tt);
88: XMapWindow(ot);
89: return(dpyno());
90: }
91:
92: InputReader ()
93: {
94: XEvent xev;
95: vsEvent ev;
96: int nstate;
97: static int state = 0;
98: vsCursor ms;
99:
100: XPending();
101: while (QLength()) {
102: XNextEvent(&xev);
103: switch (xev.type) {
104: case EnterWindow:
105: if (xev.subwindow)
106: continue;
107: case MouseMoved:
108: ms.x = ((XMouseMovedEvent *) (&xev))->x - cursor_x;
109: ms.y = ((XMouseMovedEvent *) (&xev))->y - cursor_y;
110: if ((ms.x != mouse.x || ms.y != mouse.y) &&
111: ms.x >= 0 && ms.x < screen_width &&
112: ms.y >= 0 && ms.y < screen_height) {
113: mouse = ms;
114: if (ms.y >= mbox.bottom || ms.y < mbox.top ||
115: ms.x >= mbox.right || ms.x < mbox.left) {
116: mbox.bottom = 0;
117: Deal_with_movement();
118: }
119: }
120: if (xev.type != EnterWindow)
121: continue;
122: ev.vse_time = ((XKeyOrButtonEvent *) (&xev))->time;
123: nstate = ((XEnterWindowEvent *) (&xev))->detail & ~ValueMask;
124: nstate ^= state;
125: ev.vse_direction = VSE_KBTUP;
126: ButtonTransition(&ev, nstate & state);
127: KeyTransition(&ev, nstate & state);
128: ev.vse_direction = VSE_KBTDOWN;
129: KeyTransition(&ev, nstate & ~state);
130: ButtonTransition(&ev, nstate & ~state);
131: continue;
132: case LeaveWindow:
133: state = ((XLeaveWindowEvent *) (&xev))->detail & ~ValueMask;
134: continue;
135: }
136: ev.vse_x = mouse.x;
137: ev.vse_y = mouse.y;
138: ev.vse_time = ((XKeyOrButtonEvent *) (&xev))->time;
139: ev.vse_key = ((XKeyOrButtonEvent *) (&xev))->detail & ValueMask;
140: switch (xev.type) {
141: case KeyPressed:
142: ev.vse_device = VSE_DKB;
143: ev.vse_direction = VSE_KBTDOWN;
144: break;
145: case KeyReleased:
146: ev.vse_device = VSE_DKB;
147: ev.vse_direction = VSE_KBTUP;
148: break;
149: case ButtonPressed:
150: ev.vse_device = VSE_MOUSE;
151: ev.vse_direction = VSE_KBTDOWN;
152: ev.vse_key = 2 - ev.vse_key;
153: break;
154: case ButtonReleased:
155: ev.vse_device = VSE_MOUSE;
156: ev.vse_direction = VSE_KBTUP;
157: ev.vse_key = 2 - ev.vse_key;
158: break;
159: }
160: Deal_with_input(&ev);
161: }
162: }
163:
164: KeyTransition (ev, bits)
165: register vsEvent *ev;
166: register int bits;
167: {
168: ev->vse_device = VSE_DKB;
169: if (bits & ControlMask) {
170: ev->vse_x = mouse.x;
171: ev->vse_y = mouse.y;
172: ev->vse_key = KC_CTRL;
173: Deal_with_input(ev);
174: }
175: if (bits & MetaMask) {
176: ev->vse_x = mouse.x;
177: ev->vse_y = mouse.y;
178: ev->vse_key = KC_META;
179: Deal_with_input(ev);
180: }
181: if (bits & ShiftMask) {
182: ev->vse_x = mouse.x;
183: ev->vse_y = mouse.y;
184: ev->vse_key = KC_SHIFT;
185: Deal_with_input(ev);
186: }
187: if (bits & ShiftLockMask) {
188: ev->vse_x = mouse.x;
189: ev->vse_y = mouse.y;
190: ev->vse_key = KC_LOCK;
191: Deal_with_input(ev);
192: }
193: }
194:
195: ButtonTransition (ev, bits)
196: register vsEvent *ev;
197: register int bits;
198: {
199: ev->vse_device = VSE_MOUSE;
200: if (bits & LeftMask) {
201: ev->vse_x = mouse.x;
202: ev->vse_y = mouse.y;
203: ev->vse_key = 2 - LeftButton;
204: Deal_with_input(ev);
205: }
206: if (bits & MiddleMask) {
207: ev->vse_x = mouse.x;
208: ev->vse_y = mouse.y;
209: ev->vse_key = 2 - MiddleButton;
210: Deal_with_input(ev);
211: }
212: if (bits & RightMask) {
213: ev->vse_x = mouse.x;
214: ev->vse_y = mouse.y;
215: ev->vse_key = 2 - RightButton;
216: Deal_with_input(ev);
217: }
218: }
219:
220: InitDisplay (info)
221: DEVICE *info; /* device data */
222: {
223: char *option;
224: int planes;
225: static vsEventQueue queue = {NULL, 0, 0, 0};
226:
227: dev = info;
228: info->id = XDEV_XNEST;
229: info->width = screen_width;
230: info->height = screen_height;
231: info->planes = DisplayPlanes();
232: info->entries = 0;
233: pixplanes = 0;
234: if (DisplayCells() > 2 &&
235: (option = XGetDefault("X", "CellExponent")) &&
236: (pixplanes = atoi(option)) &&
237: XGetColorCells(0, 1, 0, &planes, &extrapix)) {
238: while (pixplanes &&
239: !XGetColorCells(1, 1, pixplanes, &planes, &basepix))
240: pixplanes--;
241: if (pixplanes) {
242: info->entries = 1 << pixplanes;
243: while (!(planes & 1)) {
244: pixshift++;
245: planes >>= 1;
246: }
247: } else
248: XFreeColors(&extrapix, 1, 0);
249: }
250: info->mouse = &mouse;
251: info->mbox = &mbox;
252: info->queue = &queue;
253: Define_input_handler(InputReader);
254: Define_block_handler(XFlush);
255: return(0);
256: }
257:
258: DisplayDead ()
259: {
260: return(0);
261: }
262:
263: InitMouse ()
264: {
265: }
266:
267: caddr_t AllocateSpace (bytes)
268: int bytes; /* number of bytes to allocate */
269: {
270: static char *buf = NULL;
271: static int buflen = 0;
272:
273: if (bytes > buflen) {
274: free(buf);
275: buf = Xalloc((bytes + 0xff) &~ 0xff);
276: }
277: return(buf);
278: }
279:
280: PixFill (srcpix, xymask, dstx, dsty, width, height, clips, clipcount,
281: func, zmask)
282: int srcpix; /* source pixel */
283: BITMAP *xymask; /* source mask or NULL */
284: int dstx, dsty; /* destination */
285: int width, height;
286: register CLIP *clips; /* clipping rectangles */
287: int clipcount; /* count of rectangles */
288: int func; /* GX display function */
289: int zmask; /* plane mask */
290: {
291: srcpix = npix(srcpix);
292: zmask = nmask(zmask);
293: for (; --clipcount >= 0; clips++) {
294: SetClip(clips);
295: XPixFill(t, dstx - clips->left, dsty - clips->top, width, height,
296: srcpix, xymask ? Xbitmap(xymask) : NULL, func, zmask);
297: }
298: }
299:
300: TileFill (tile, xoff, yoff, xymask, dstx, dsty, width, height,
301: clips, clipcount, func, zmask)
302: PIXMAP *tile; /* source tile */
303: int xoff, yoff; /* tile origin */
304: BITMAP *xymask; /* source mask or NULL */
305: int dstx, dsty; /* destination */
306: int width, height;
307: register CLIP *clips; /* clipping rectangles */
308: int clipcount; /* count of rectangles */
309: int func; /* GX display function */
310: int zmask; /* plane mask */
311: {
312: zmask = nmask(zmask);
313: SetTileOrigin(tile, xoff, yoff);
314: for (; --clipcount >= 0; clips++) {
315: SetTileClip(clips);
316: XTileFill(tt, dstx - clips->left, dsty - clips->top, width, height,
317: Xpixmap(tile), xymask ? Xbitmap(xymask) : NULL,
318: func, zmask);
319: }
320: }
321:
322: int StippleFill (srcpix, xoff, yoff, stipmask, dstx, dsty, width, height,
323: clips, clipcount, func, zmask)
324: int srcpix; /* source pixel */
325: int xoff, yoff; /* stipple origin */
326: BITMAP *stipmask; /* stipple mask */
327: int dstx, dsty; /* destination */
328: int width, height;
329: CLIP *clips; /* clipping rectangles */
330: int clipcount;
331: int func; /* GX display function */
332: int zmask; /* plane mask */
333: {
334: return (1);
335: }
336: PixmapPut (src, srcx, srcy, width, height, dstx, dsty, clips, clipcount,
337: func, zmask)
338: PIXMAP *src; /* source */
339: int srcx, srcy; /* region of source */
340: int width, height;
341: int dstx, dsty; /* destination */
342: register CLIP *clips; /* clipping rectangles */
343: int clipcount; /* count of rectangles */
344: int func; /* GX display function */
345: int zmask; /* plane mask */
346: {
347: zmask = nmask(zmask);
348: for (; --clipcount >= 0; clips++) {
349: SetClip(clips);
350: XPixmapPut(t, srcx, srcy, dstx - clips->left, dsty - clips->top,
351: width, height, Xpixmap(src), func, zmask);
352: }
353: }
354:
355: PixmapBitsPut (width, height, format, data, xymask, dstx, dsty,
356: clips, clipcount, func, zmask)
357: int width; /* source width */
358: int height; /* source height */
359: int format; /* 0: XY-format, 1: Z-format */
360: char *data; /* source data */
361: BITMAP *xymask; /* source mask or NULL */
362: int dstx, dsty; /* destination */
363: register CLIP *clips; /* clipping rectangles */
364: int clipcount; /* count of rectangles */
365: int func; /* GX display function */
366: int zmask; /* plane mask */
367: {
368: ToPixmap(width, height, format, data);
369: zmask = nmask(zmask);
370: for (; --clipcount >= 0; clips++) {
371: SetClip(clips);
372: if (format == XYFormat)
373: XPixmapBitsPutXY(t, dstx - clips->left, dsty - clips->top,
374: width, height, data,
375: xymask ? Xbitmap(xymask) : NULL, func, zmask);
376: else {
377: XPixmapBitsPutZ(t, dstx - clips->left, dsty - clips->top,
378: width, height, data,
379: xymask ? Xbitmap(xymask) : NULL, func, zmask);
380: }
381: }
382: }
383:
384: BitmapBitsPut (width, height, data, fore, back, xymask, dstx, dsty,
385: clips, clipcount, func, zmask)
386: int width; /* source width */
387: int height; /* source height */
388: char *data; /* source data */
389: int fore; /* foreground source pixel */
390: int back; /* background source pixel */
391: BITMAP *xymask; /* source mask or NULL */
392: int dstx, dsty; /* destination */
393: register CLIP *clips; /* clipping rectangles */
394: int clipcount; /* count of rectangles */
395: int func; /* GX display function */
396: int zmask; /* plane mask */
397: {
398: fore = npix(fore);
399: back = npix(back);
400: zmask = nmask(zmask);
401: for (; --clipcount >= 0; clips++) {
402: SetClip(clips);
403: XBitmapBitsPut(t, dstx - clips->left, dsty - clips->top,
404: width, height, data, fore, back,
405: xymask ? Xbitmap(xymask) : NULL, func, zmask);
406: }
407: }
408:
409: CopyArea (srcx, srcy, width, height, dstx, dsty, clips, clipcount, func, zmask)
410: int srcx, srcy; /* source */
411: int width, height;
412: int dstx, dsty; /* destination */
413: register CLIP *clips; /* clipping rectangles */
414: int clipcount; /* count of rectangles */
415: int func; /* GX display function */
416: int zmask; /* plane mask */
417: {
418: int dstr, dstb, left, top;
419:
420: dstr = dstx + width;
421: dstb = dsty + height;
422: srcx -= dstx;
423: srcy -= dsty;
424: for (; --clipcount >= 0; clips++) {
425: left = clips->left;
426: if (left < dstx)
427: left = dstx;
428: width = clips->left + clips->width;
429: if (width > dstr)
430: width = dstr;
431: width -= left;
432: top = clips->top;
433: if (top < dsty)
434: top = dsty;
435: height = clips->top + clips->height;
436: if (height > dstb)
437: height = dstb;
438: height -= top;
439: if (width > 0 && height > 0)
440: XCopyArea(w, srcx + left, srcy + top, left, top,
441: width, height, func, zmask);
442: }
443: }
444:
445: PrintText (string, strlen, font, fore, back, charpad, spacepad, dstx, dsty,
446: clips, clipcount, func, zmask)
447: char *string; /* character string */
448: int strlen; /* string length */
449: FONT *font; /* source font */
450: int fore; /* foreground source pixel */
451: int back; /* background source pixel */
452: int charpad; /* inter-character pad */
453: int spacepad; /* space-character pad */
454: int dstx, dsty; /* destination */
455: register CLIP *clips; /* clipping rectangles */
456: int clipcount; /* count of rectangles */
457: int func; /* GX display function */
458: int zmask; /* plane mask */
459: {
460: fore = npix(fore);
461: back = npix(back);
462: zmask = nmask(zmask);
463: for (; --clipcount >= 0; clips++) {
464: SetClip(clips);
465: XTextPad(t, dstx - clips->left, dsty - clips->top, string, strlen,
466: Xfont(font), charpad, spacepad, fore, back, func, zmask);
467: }
468: }
469:
470: PrintTextMask (string, strlen, font, srcpix, charpad, spacepad, dstx, dsty,
471: clips, clipcount, func, zmask)
472: char *string; /* character string */
473: int strlen; /* string length */
474: FONT *font; /* font mask */
475: int srcpix; /* source pixel */
476: int charpad; /* inter-character pad */
477: int spacepad; /* space-character pad */
478: int dstx, dsty; /* destination */
479: register CLIP *clips; /* clipping rectangles */
480: int clipcount; /* count of rectangles */
481: int func; /* GX display function */
482: int zmask; /* plane mask */
483: {
484: srcpix = npix(srcpix);
485: zmask = nmask(zmask);
486: for (; --clipcount >= 0; clips++) {
487: SetClip(clips);
488: XTextMaskPad(t, dstx - clips->left, dsty - clips->top, string,
489: strlen, Xfont(font), charpad, spacepad, srcpix,
490: func, zmask);
491: }
492: }
493:
494: DrawCurve (verts, vertcount, xbase, ybase, srcpix, altpix, mode,
495: bwidth, bheight, pat, patlen, patmul, clips, clipcount, func, zmask)
496: Vertex *verts; /* vertexes */
497: int vertcount; /* vertex count */
498: int xbase, ybase; /* draw origin */
499: int srcpix; /* source pixel *
500: int altpix; /* alternate source pixel */
501: int mode; /* 0: solid, 1: dashed, 2: patterned */
502: int bwidth; /* brush width */
503: int bheight; /* brush height */
504: int pat; /* pattern */
505: int patlen; /* pattern length */
506: int patmul; /* pattern repeat count */
507: register CLIP *clips; /* clipping rectangles */
508: int clipcount; /* count of rectangles */
509: int func; /* GX display function */
510: int zmask; /* plane mask */
511: {
512: srcpix = npix(srcpix);
513: altpix = npix(altpix);
514: zmask = nmask(zmask);
515: for (; --clipcount >= 0; clips++) {
516: SetClip(clips);
517: PathOffsets(verts, vertcount,
518: xbase - clips->left, ybase - clips->top);
519: xbase = clips->left;
520: ybase = clips->top;
521: switch (mode) {
522: case DrawSolidLine:
523: XDraw(t, verts, vertcount, bwidth, bheight, srcpix,
524: func, zmask);
525: break;
526: case DrawDashedLine:
527: XDrawDashed(t, verts, vertcount, bwidth, bheight, srcpix,
528: XMakePattern(pat, patlen, patmul), func, zmask);
529: break;
530: case DrawPatternedLine:
531: XDrawPatterned(t, verts, vertcount, bwidth, bheight, srcpix,
532: altpix, XMakePattern(pat, patlen, patmul),
533: func, zmask);
534: break;
535: }
536: }
537: }
538:
539: DrawFilled (verts, vertcount, xbase, ybase, srcpix, tile, xoff, yoff,
540: clips, clipcount, func, zmask)
541: Vertex *verts; /* vertexes */
542: int vertcount; /* vertex count */
543: int xbase, ybase; /* draw origin */
544: int srcpix; /* source pixel */
545: PIXMAP *tile; /* optional tile or NULL */
546: int xoff, yoff; /* tile origin */
547: register CLIP *clips; /* clipping rectangles */
548: int clipcount; /* count of rectangles */
549: int func; /* GX display function */
550: int zmask; /* plane mask */
551: {
552: if (tile)
553: SetTileOrigin(tile, xoff, yoff);
554: else
555: srcpix = npix(srcpix);
556: zmask = nmask(zmask);
557: for (; --clipcount >= 0; clips++) {
558: PathOffsets(verts, vertcount,
559: xbase - clips->left, ybase - clips->top);
560: xbase = clips->left;
561: ybase = clips->top;
562: if (tile) {
563: SetTileClip(clips);
564: XDrawTiled(tt, verts, vertcount, Xpixmap(tile), func, zmask);
565: } else {
566: SetClip(clips);
567: XDrawFilled(t, verts, vertcount, srcpix, func, zmask);
568: }
569: }
570: }
571:
572: PathOffsets (verts, vertcount, xoff, yoff)
573: register Vertex *verts;
574: register int vertcount, xoff, yoff;
575: {
576: for (; --vertcount >= 0; verts++) {
577: if (!(verts->flags & VertexRelative)) {
578: verts->x += xoff;
579: verts->y += yoff;
580: }
581: }
582: }
583:
584: SetClip (clip)
585: register CLIP *clip;
586: {
587: static CLIP normclip = {0, 0, 0, 0};
588:
589: if (clip->left != normclip.left || clip->top != normclip.top ||
590: clip->width != normclip.width || clip->height != normclip.height) {
591: XConfigureWindow(t, clip->left, clip->top,
592: clip->width, clip->height);
593: normclip = *clip;
594: }
595: }
596:
597: SetTileClip (clip)
598: register CLIP *clip;
599: {
600: if (clip->left != tileclip.left || clip->top != tileclip.top ||
601: clip->width != tileclip.width || clip->height != tileclip.height) {
602: XConfigureWindow(tt, clip->left - tilex, clip->top - tiley,
603: clip->width, clip->height);
604: tileclip = *clip;
605: }
606: }
607:
608: SetTileOrigin (tile, xoff, yoff)
609: register PIXMAP *tile;
610: register int xoff, yoff;
611: {
612: if (tile->width) {
613: xoff %= tile->width;
614: if (xoff)
615: xoff -= tile->width;
616: yoff %= tile->height;
617: if (yoff)
618: yoff -= tile->height;
619: if (xoff != tilex || yoff != tiley) {
620: XConfigureWindow(ot, xoff, yoff,
621: screen_width - xoff, screen_height - yoff);
622: tileclip.left += (xoff - tilex);
623: tileclip.top += (yoff - tiley);
624: tilex = xoff;
625: tiley = yoff;
626: }
627: }
628: }
629:
630: PIXMAP *PixmapSave (srcx, srcy, width, height)
631: int srcx, srcy; /* source */
632: int width, height;
633: {
634: Pixmap pix;
635: PIXMAP *pm;
636:
637: pix = XPixmapSave(w, srcx, srcy, width, height);
638: if (pix == NULL)
639: return(NULL);
640: pm = (PIXMAP *) Xalloc (sizeof (PIXMAP));
641: pm->width = width;
642: pm->height = height;
643: pm->refcnt = 1;
644: pm->data = (caddr_t) pix;
645: IsTile(pm);
646: return(pm);
647: }
648:
649: PixmapGet (srcx, srcy, width, height, client, format, swapit)
650: int srcx, srcy; /* source */
651: int width, height;
652: int client; /* file desc to write to */
653: int format; /* 0: XY-format, 1: Z-format */
654: int swapit; /* 1: swap shorts */
655: {
656: int count;
657: caddr_t data;
658:
659: if (format == XYFormat) {
660: count = (XYPixmapSize(width, height, dev->planes) + 3) & ~3;
661: data = Xalloc(count);
662: if (XPixmapGetXY(w, srcx, srcy, width, height, data) == NULL)
663: return;
664: } else {
665: if (dev->planes > 8)
666: count = WZPixmapSize(width, height);
667: else {
668: count = BZPixmapSize(width, height);
669: swapit = 0;
670: }
671: count = (count + 3) & ~3;
672: data = Xalloc(count);
673: if (XPixmapGetZ(w, srcx, srcy, width, height, data) == NULL)
674: return;
675: }
676: FromPixmap(width, height, format, data);
677: if (swapit)
678: Swap_shorts(data, count >> 1);
679: Write(client, data, count);
680: free(data);
681: }
682:
683: ResolveColor (red, green, blue)
684: unsigned short *red, *green, *blue; /* update in place */
685: {
686: Color def;
687:
688: if (dev->entries) {
689: def.pixel = extrapix;
690: def.red = *red;
691: def.green = *green;
692: def.blue = *blue;
693: XStoreColor(&def);
694: XQueryColor(&def);
695: *red = def.red;
696: *green = def.green;
697: *blue = def.blue;
698: }
699: }
700:
701: StoreColors (count, entries)
702: int count; /* number of entries */
703: register ColorDef *entries;
704: {
705: register Color *ptr;
706: register int n;
707: static Color *ents = NULL;
708: static entcnt = 0;
709:
710: if (count > entcnt) {
711: free ((caddr_t) ents);
712: ents = (Color *) Xalloc(count * sizeof(Color));
713: entcnt = count;
714: }
715: for (ptr = ents, n = count; --n >= 0; entries++, ptr++) {
716: ptr->pixel = npix(entries->pixel);
717: ptr->red = entries->red;
718: ptr->green = entries->green;
719: ptr->blue = entries->blue;
720: }
721: XStoreColors(count, ents);
722: }
723:
724: FONT *GetFont (name)
725: char *name; /* font or file name */
726: {
727: register FontInfo *info;
728: register FONT *fd;
729: char *fname;
730:
731: info = XOpenFont(name);
732: if (info == NULL) {
733: errno = EINVAL;
734: return(NULL);
735: }
736: fd = (FONT *) Xalloc(sizeof(FONT));
737: fname = Xalloc(strlen(name) + 1);
738: strcpy(fname, name);
739: fd->name = fname;
740: fd->first = info->firstchar;
741: fd->last = info->lastchar;
742: fd->space = ' ';
743: fd->height = info->height;
744: fd->avg_width = info->width;
745: fd->fixed = info->fixedwidth;
746: fd->base = info->baseline;
747: fd->refcnt = 1;
748: fd->data = (caddr_t) info;
749: return(fd);
750: }
751:
752: FreeFont (font)
753: FONT *font;
754: {
755: XCloseFont(Xfinf(font));
756: free(font->name);
757: free((caddr_t) font);
758: }
759:
760: CharWidth (c, font)
761: unsigned c; /* character */
762: register FONT *font; /* font */
763: {
764: if (c < font->first || c > font->last)
765: return(0);
766: else if (font->fixed)
767: return(font->avg_width);
768: else
769: return(Xfinf(font)->widths[c - font->first]);
770: }
771:
772: TextWidth (string, strlen, spacepad, font)
773: char *string; /* character string */
774: int strlen; /* string length */
775: int spacepad; /* space-character pad */
776: register FONT *font; /* font */
777: {
778: register u_char *strptr = (u_char *) string;
779: short c;
780: register short *widths;
781: int width = 0;
782:
783: if (font->fixed) {
784: width = strlen * font->avg_width;
785: if (spacepad) {
786: while (--strlen >= 0)
787: if (*strptr++ == font->space)
788: width += spacepad;
789: }
790: } else {
791: widths = Xfinf(font)->widths;
792: while (--strlen >= 0) {
793: c = *strptr++;
794: if (c >= font->first && c <= font->last) {
795: if (c == font->space)
796: width += spacepad;
797: width += widths[c - font->first];
798: }
799: }
800: }
801: return (width);
802: }
803:
804: BITMAP *StoreBitmap (width, height, data)
805: int width; /* bitmap width */
806: int height; /* bitmap height */
807: char *data; /* bitmap data */
808: {
809: Bitmap bitmap;
810: register BITMAP *bm;
811:
812: bitmap = XStoreBitmap(width, height, data);
813: if (bitmap == NULL)
814: return(NULL);
815: bm = (BITMAP *) Xalloc(sizeof(BITMAP));
816: bm->width = width;
817: bm->height = height;
818: bm->refcnt = 1;
819: bm->data = (caddr_t) bitmap;
820: return(bm);
821: }
822:
823: FreeBitmap (bitmap)
824: BITMAP *bitmap;
825: {
826: XFreeBitmap(Xbitmap(bitmap));
827: free((caddr_t) bitmap);
828: }
829:
830: BITMAP *CharBitmap (c, font)
831: unsigned c; /* character */
832: register FONT *font; /* font */
833: {
834: Bitmap bitmap;
835: register BITMAP *bm;
836:
837: bitmap = XCharBitmap(Xfont(font), (int) c);
838: if (bitmap == NULL)
839: return(NULL);
840: bm = (BITMAP *) Xalloc(sizeof(BITMAP));
841: bm->width = CharWidth(c, font);
842: bm->height = Xfinf(font)->height;
843: bm->refcnt = 1;
844: bm->data = (caddr_t) bitmap;
845: return(bm);
846: }
847:
848: PIXMAP *StorePixmap (width, height, format, data)
849: int width; /* pixmap width */
850: int height; /* pixmap height */
851: int format; /* 0: XY-format, 1: Z-format */
852: char *data; /* pixmap data */
853: {
854: Pixmap pix;
855: register PIXMAP *pm;
856:
857: ToPixmap(width, height, format, data);
858: if (format == XYFormat)
859: pix = XStorePixmapXY(width, height, data);
860: else
861: pix = XStorePixmapZ(width, height, data);
862: if (pix == NULL)
863: return(NULL);
864: pm = (PIXMAP *) Xalloc (sizeof (PIXMAP));
865: pm->width = width;
866: pm->height = height;
867: pm->refcnt = 1;
868: pm->data = (caddr_t) pix;
869: IsTile(pm);
870: return(pm);
871: }
872:
873: FreePixmap (pixmap)
874: PIXMAP *pixmap;
875: {
876: XFreePixmap(Xpixmap(pixmap));
877: free((caddr_t) pixmap);
878: }
879:
880: ToPixmap (width, height, format, data)
881: int width, height, format;
882: char *data;
883: {
884: register int n;
885: int shift;
886: register u_short *sptr;
887: register u_char *cptr;
888: register char *ptr;
889:
890: if (dev->entries == 0)
891: return;
892: if (format == XYFormat) {
893: n = BitmapSize(width, height);
894: if (pixshift) {
895: ptr = data + XYPixmapSize(width, height, dev->planes);
896: shift = XYPixmapSize(width, height, pixplanes);
897: bcopy(ptr - shift,
898: ptr - (shift + XYPixmapSize(width, height, pixshift)),
899: shift);
900: for (shift = 0, ptr -= n;
901: shift < pixshift;
902: shift++, ptr -= n) {
903: if (basepix & (1 << shift))
904: AllOnes(ptr, width, height);
905: else
906: bzero(ptr, n);
907: }
908: }
909: for (shift = dev->planes, ptr = data;
910: --shift >= pixshift + pixplanes;
911: ptr += n) {
912: if (basepix & (1 << shift))
913: AllOnes(ptr, width, height);
914: }
915: } else if (dev->planes > 8) {
916: for (n = WZPixmapSize(width, height) >> 1, sptr = (u_short *) data;
917: --n >= 0;
918: sptr++)
919: *sptr = npix(*sptr);
920: } else {
921: for (n = BZPixmapSize(width, height), cptr = (u_char *) data;
922: --n >= 0;
923: cptr++)
924: *cptr = npix(*cptr);
925: }
926: }
927:
928: AllOnes (data, width, height)
929: register char *data;
930: int width, height;
931: {
932: register int n, cnt;
933: register char *ptr;
934:
935: n = BitmapSize(width, 1);
936: for (ptr = data, cnt = n; --cnt >= 0; )
937: *ptr++ = ~0;
938: for (ptr = data + n, cnt = height; --cnt > 0; ptr += n)
939: bcopy(data, ptr, n);
940: }
941:
942: FromPixmap (width, height, format, data)
943: int width, height, format;
944: register char *data;
945: {
946: register int n;
947: register u_short *sptr;
948: register u_char *cptr;
949: register char *ptr;
950: int cnt, shift;
951:
952: if (dev->entries == 0)
953: return;
954: if (format == XYFormat) {
955: if (pixshift) {
956: cnt = BitmapSize(width, height);
957: shift = XYPixmapSize(width, height, pixshift);
958: for (ptr = data + XYPixmapSize(width, height, dev->planes) - cnt,
959: n = pixshift;
960: --n >= 0;
961: ptr -= cnt)
962: bcopy(ptr - shift, ptr, cnt);
963: }
964: bzero(data, XYPixmapSize(width, height, dev->planes - pixplanes));
965: } else if (dev->planes > 8) {
966: for (n = WZPixmapSize(width, height) >> 1, sptr = (u_short *) data;
967: --n >= 0;
968: sptr++)
969: *sptr = opix(*sptr);
970: } else {
971: for (n = BZPixmapSize(width, height), cptr = (u_char *) data;
972: --n >= 0;
973: cptr++)
974: *cptr = opix(*cptr);
975: }
976: }
977:
978: PIXMAP *MakePixmap (xymask, fore, back)
979: BITMAP *xymask; /* mask or NULL */
980: int fore; /* foreground pixel */
981: int back; /* background pixel */
982: {
983: Pixmap pix;
984: register PIXMAP *pm;
985:
986: pix = XMakePixmap(xymask ? Xbitmap(xymask) : NULL,
987: npix(fore), npix(back));
988: if (pix == NULL)
989: return(NULL);
990: pm = (PIXMAP *) Xalloc (sizeof (PIXMAP));
991: pm->refcnt = 1;
992: pm->data = (caddr_t) pix;
993: if (xymask) {
994: pm->width = xymask->width;
995: pm->height = xymask->height;
996: IsTile(pm);
997: } else {
998: pm->width = 0;
999: pm->height = 0;
1000: pm->tile = 1;
1001: }
1002: return(pm);
1003: }
1004:
1005: IsTile (pm)
1006: PIXMAP *pm;
1007: {
1008: int width, height;
1009:
1010: XQueryTileShape(pm->width, pm->height, &width, &height);
1011: if (pm->width == width && pm->height == height)
1012: pm->tile = 1;
1013: else
1014: pm->tile = 0;
1015: }
1016:
1017: QueryShape (shape, width, height)
1018: int shape; /* 0: cursor, 1: tile, 2: brush */
1019: short *width, *height; /* update in place */
1020: {
1021: int rwidth, rheight;
1022:
1023: switch (shape) {
1024: case CursorShape:
1025: XQueryCursorShape(*width, *height, &rwidth, &rheight);
1026: break;
1027: case TileShape:
1028: XQueryTileShape(*width, *height, &rwidth, &rheight);
1029: break;
1030: case BrushShape:
1031: XQueryBrushShape(*width, *height, &rwidth, &rheight);
1032: break;
1033: }
1034: *width = rwidth;
1035: *height = rheight;
1036: }
1037:
1038: CURSOR *StoreCursor (func, image, fore, back, mask, xoff, yoff)
1039: int func; /* GX display function */
1040: BITMAP *image; /* cursor image */
1041: int fore; /* foreground pixel */
1042: int back; /* background pixel */
1043: BITMAP *mask; /* cursor mask or NULL */
1044: int xoff, yoff; /* tip */
1045: {
1046: Cursor cursor;
1047: register CURSOR *cr;
1048: int width, height;
1049:
1050: cursor = XStoreCursor(Xbitmap(image), mask ? Xbitmap(mask) : NULL,
1051: xoff, yoff, npix(fore), npix(back), func);
1052: if (cursor == NULL)
1053: return(NULL);
1054: XQueryCursorShape(image->width, image->height, &width, &height);
1055: cr = (CURSOR *) Xalloc(sizeof(CURSOR));
1056: cr->width = width;
1057: cr->height = height;
1058: cr->xoff = xoff;
1059: cr->yoff = yoff;
1060: cr->xmin = xoff;
1061: cr->ymin = yoff;
1062: cr->xmax = screen_width - (width - xoff);
1063: cr->ymax = screen_height - (height - yoff);
1064: cr->refcnt = 1;
1065: cr->data = (caddr_t) cursor;
1066: return(cr);
1067: }
1068:
1069: FreeCursor (cursor)
1070: CURSOR *cursor;
1071: {
1072: XFreeCursor(Xcursor(cursor));
1073: free((caddr_t) cursor);
1074: }
1075:
1076: LoadCursor (cursor)
1077: CURSOR *cursor;
1078: {
1079: if (cursor->xoff != cursor_x || cursor->yoff != cursor_y) {
1080: XCondWarpMouse(w, mouse.x + cursor->xoff, mouse.y + cursor->yoff,
1081: w, mouse.x + cursor_x, mouse.y + cursor_y, 1, 1);
1082: cursor_x = cursor->xoff;
1083: cursor_y = cursor->yoff;
1084: }
1085: XDefineCursor(w, Xcursor(cursor));
1086: }
1087:
1088: /*ARGSUSED*/
1089: SetMouseCharacteristics (threshold, acceleration)
1090: int threshold, acceleration;
1091: {
1092: }
1093:
1094: SetCursorPosition (pos)
1095: vsCursor *pos;
1096: {
1097: XCondWarpMouse(w, pos->x + cursor_x, pos->y + cursor_y, w, 0, 0, 0, 0);
1098: mouse = *pos;
1099: }
1100:
1101: /*ARGSUSED*/
1102: SetAutoRepeat (onoff)
1103: int onoff; /* 0: off, 1: on */
1104: {
1105: }
1106:
1107: /*ARGSUSED*/
1108: SetKeyClick (volume)
1109: int volume; /* 0: off, 1-8: on */
1110: {
1111: }
1112:
1113: SoundBell (volume)
1114: int volume; /* 0-7 */
1115: {
1116: XFeep(volume);
1117: }
1118:
1119: /*ARGSUSED*/
1120: SetLockLED (onoff)
1121: int onoff; /* 0: off, 1: on */
1122: {
1123: }
1124:
1125: SetVideo (onoff)
1126: int onoff; /* 0: off, 1: on */
1127: {
1128: return(onoff - 1);
1129: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.