![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Boolean.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk|
Return to Boolean.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: Boolean.c,v 1.2 87/09/12 12:41:35 swick Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)Boolean.c 1.8 2/24/87";
4: #endif lint
5:
6: /*
7: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
8: *
9: * All Rights Reserved
10: *
11: * Permission to use, copy, modify, and distribute this software and its
12: * documentation for any purpose and without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and that
14: * both that copyright notice and this permission notice appear in
15: * supporting documentation, and that the name of Digital Equipment
16: * Corporation not be used in advertising or publicity pertaining to
17: * distribution of the software without specific, written prior permission.
18: *
19: *
20: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
21: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
22: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
23: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
24: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
25: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
26: * SOFTWARE.
27: */
28:
29:
30: #include <stdio.h>
31: #include <strings.h>
32: #include "Xlib.h"
33: #include "Intrinsic.h"
34: #include "Boolean.h"
35: #include "Atoms.h"
36:
37: /* Private Definitions */
38:
39: typedef void (*NotifyProc)();
40:
41: typedef struct _WidgetDataRec {
42: Display *dpy; /* widget display connection */
43: Window window; /* widget window */
44: Position x, y; /* location of widget */
45: Dimension borderWidth; /* border width in pixels */
46: Dimension width, height; /* width/height in pixels */
47: int ibw, ibh; /* internal border width/height in pixels */
48: char *text; /* button text */
49: int fgpixel; /* color index for text */
50: int bgpixel; /* color index for background */
51: int brpixel; /* color for border */
52: Boolean highlighted; /* are we highlighted? */
53: Boolean value; /* pointer to value */
54: XFontStruct *fontstruct; /* font for text */
55: Dimension twidth, theight;/* text width/height */
56: XtJustify justify; /* text justification */
57: NotifyProc proc; /* procedure to invoke on value change */
58: caddr_t tag; /* widget client data */
59: XtEventsPtr eventTable; /* Table for Translation Manager */
60: caddr_t state; /* state for Translation Manager */
61: int eventlevels; /* recursion levels of event handling */
62: GC gc; /* current gc */
63: GC onGC; /* GC to use when on */
64: GC offGC; /* GC to use when off */
65: } WidgetDataRec, *WidgetData;
66:
67: extern void Dummy();
68: static WidgetDataRec globaldata;
69: static WidgetDataRec globalinit = {
70:
71: NULL, /* Display dpy; */
72: NULL, /* Window window; */
73: 0,0, /* x,y */
74: 1, /* int borderWidth; */
75: 0, 0, /* int width, height; */
76: 4, 2, /* int ibw, ibh; */
77: NULL, /* char *text; */
78: NULL, /* int fgpixel; */ /* init proc */
79: NULL, /* int bgpixel; */ /* init proc */
80: NULL, /* Pixmap brpixmap; */ /* init proc */
81: FALSE, /* Boolean highlighted; */
82: FALSE, /* Boolean value; */
83: NULL, /* XFontStruct *fontstruct; */ /* init proc */
84: 0, 0, /* int twidth, theight; */
85: XtjustifyCenter, /* justify */
86: Dummy, /* void (*proc) (); */
87: NULL, /* caddr_t tag; */
88: NULL, /* event table pointer */
89: NULL, /* state for Translation Manager */
90: NULL, /* event levels */
91: NULL, /* gc */
92: NULL, /* onGC */
93: NULL, /* offGC */
94: };
95:
96: /* Private Data */
97:
98: static int defaultBorderWidth = 1;
99: static int defaultInternalBorderWidth = 4;
100: static int defaultInternalBorderHeight = 2;
101: static XtJustify defaultJustify = XtjustifyCenter;
102: static NotifyProc defaultFunction = Dummy;
103:
104: static Resource resources[] = {
105: {XtNvalue, XtCValue, XrmRBoolean, sizeof(Boolean),
106: (caddr_t)&globaldata.value, (caddr_t)NULL},
107: {XtNwindow, XtCWindow, XrmRWindow, sizeof(Window),
108: (caddr_t)&globaldata.window, (caddr_t)NULL},
109: {XtNborderWidth, XtCBorderWidth, XrmRInt, sizeof(int),
110: (caddr_t)&globaldata.borderWidth, (caddr_t)&defaultBorderWidth},
111: {XtNwidth, XtCWidth, XrmRInt, sizeof(int),
112: (caddr_t)&globaldata.width, (caddr_t)NULL},
113: {XtNheight, XtCHeight, XrmRInt, sizeof(int),
114: (caddr_t)&globaldata.height, (caddr_t)NULL},
115: {XtNinternalWidth, XtCWidth, XrmRInt, sizeof(int),
116: (caddr_t)&globaldata.ibw, (caddr_t)&defaultInternalBorderWidth},
117: {XtNinternalHeight, XtCHeight, XrmRInt, sizeof(int),
118: (caddr_t)&globaldata.ibh, (caddr_t)&defaultInternalBorderHeight},
119: {XtNlabel, XtCLabel, XrmRString, sizeof(char *),
120: (caddr_t)&globaldata.text, (caddr_t)NULL},
121: {XtNforeground, XtCColor, XrmRPixel, sizeof(int),
122: (caddr_t)&globaldata.fgpixel, (caddr_t)&XtDefaultFGPixel},
123: {XtNbackground, XtCColor, XrmRPixel, sizeof(int),
124: (caddr_t)&globaldata.bgpixel, (caddr_t)&XtDefaultBGPixel},
125: {XtNborder, XtCColor, XrmRPixel, sizeof(int),
126: (caddr_t)&globaldata.brpixel, (caddr_t)&XtDefaultFGPixel},
127: {XtNfont, XtCFont, XrmRFontStruct, sizeof(XFontStruct *),
128: (caddr_t)&globaldata.fontstruct,(caddr_t)NULL},
129: {XtNjustify, XtCJustify, XtRJustify, sizeof(XtJustify),
130: (caddr_t)&globaldata.justify, (caddr_t)&defaultJustify},
131: {XtNfunction, XtCFunction, XtRFunction, sizeof(NotifyProc),
132: (caddr_t)&globaldata.proc, (caddr_t)&defaultFunction},
133: {XtNparameter, XtCParameter, XrmRPointer, sizeof(caddr_t),
134: (caddr_t)&globaldata.tag, (caddr_t)NULL},
135: {XtNeventBindings, XtCEventBindings,XtREventBindings, sizeof(caddr_t),
136: (caddr_t)&globaldata.eventTable,NULL },
137: };
138:
139: static char *defaultEventBindings[] = {
140: "<EnterWindow>: highlight\n",
141: "<LeaveWindow>: unhighlight\n",
142: "<ButtonPress>left: toggle\n",
143: "<ButtonRelease>left: notify\n",
144: NULL
145: };
146:
147: /****************************************************************
148: *
149: * Private Procedures
150: *
151: ****************************************************************/
152:
153: static Boolean initialized = FALSE; /* !!! STATIC !!! */
154:
155: static XContext widgetContext;
156:
157: static void BooleanInitialize (dpy)
158: Display *dpy;
159: {
160: if (initialized)
161: return;
162: initialized = TRUE;
163:
164: widgetContext = XUniqueContext();
165:
166: globalinit.fontstruct = XLoadQueryFont(dpy,"fixed");
167: globalinit.justify = XtjustifyCenter;
168: globalinit.eventTable = XtParseEventBindings(defaultEventBindings);
169: }
170:
171: static void SetTextWidthAndHeight(data)
172: WidgetData data;
173: {
174: data->theight = data->fontstruct->max_bounds.ascent +
175: data->fontstruct->max_bounds.descent;
176: data->twidth = XTextWidth(data->fontstruct, data->text,
177: strlen(data->text));
178: }
179:
180: /*ARGSUSED*/
181: static void Dummy(p)
182: caddr_t p;
183: {
184: (void) printf("dummy notify for Boolean\n");
185: }
186:
187: static void Ignore ()
188: {
189: (void) printf("you are being ignored\n");
190: }
191:
192: /*
193: * Given a display and window, get the widget data.
194: */
195:
196: static WidgetData DataFromWindow(dpy, window)
197: Display *dpy;
198: Window window;
199: {
200: WidgetData result;
201: if (XFindContext(dpy, window, widgetContext, (caddr_t *)&result))
202: return NULL;
203: return result;
204: }
205:
206: /*
207: *
208: * Repaint the widget window
209: *
210: */
211:
212: static void Redisplay (data)
213: WidgetData data;
214: {
215: int textx, texty;
216: Window w = data->window;
217:
218:
219: /*
220: * Calculate Text x,y given window width and text width
221: * to the specified justification
222: */
223:
224: if (data->justify == XtjustifyLeft)
225: textx = 2;
226: else if (data->justify == XtjustifyRight)
227: textx = data->width - data->twidth;
228: else
229: textx = ((data->width - data->twidth) / 2);
230: if (textx < 0) textx = 0;
231: texty = (data->height - data->theight) / 2 +
232: data->fontstruct->max_bounds.ascent;
233:
234: XFillRectangle(data->dpy, w,
235: (data->highlighted ? data->onGC : data->offGC),
236: 0, 0, data->width, data->height);
237:
238: XDrawImageString(
239: data->dpy, w, (((data->value)) ? data->offGC : data->onGC),
240: textx, texty, data->text, strlen(data->text));
241:
242: }
243:
244: extern void Destroy();
245:
246: /*
247: *
248: * Generic widget event handler
249: *
250: */
251:
252: static XtEventReturnCode EventHandler(event, eventdata)
253: XEvent *event;
254: caddr_t eventdata;
255: {
256: WidgetData data = (WidgetData) eventdata;
257: XtActionTokenPtr actionList;
258: NotifyProc proc;
259:
260: data->eventlevels++;
261:
262: switch (event->type) {
263: case ConfigureNotify:
264: data->width = event->xconfigure.width;
265: data->height = event->xconfigure.height;
266: data->borderWidth = event->xconfigure.border_width;
267: break;
268:
269: case DestroyNotify: Destroy(data); break;
270:
271: case Expose:
272: if (event->xexpose.count == 0)
273: Redisplay(data);
274: break;
275:
276: default:
277: actionList = (XtActionTokenPtr)XtTranslateEvent(
278: event, (TranslationPtr) data->state);
279: for (; actionList != NULL; actionList = actionList->next) {
280: if (actionList->type == XttokenAction) {
281: proc = (NotifyProc)XtInterpretAction(
282: data->dpy,
283: (TranslationPtr) data->state,
284: actionList->value.action);
285: (*proc) (data);
286: }
287: }
288: break;
289: }
290:
291: data->eventlevels--;
292: return (XteventHandled);
293: }
294:
295: /*
296: *
297: * Widget hilight event handler
298: *
299: */
300:
301: /*ARGSUSED*/
302: static XtEventReturnCode Highlight(data)
303: WidgetData data;
304: {
305: data->highlighted = TRUE;
306: Redisplay(data);
307: return (XteventHandled);
308: }
309:
310: /*
311: *
312: * Widget un-hilight event handler
313: *
314: */
315:
316: /*ARGSUSED*/
317: static XtEventReturnCode Unhighlight(data)
318: WidgetData data;
319: {
320: data->highlighted = FALSE;
321: Redisplay(data);
322: return (XteventHandled);
323: }
324:
325: static void SetValue(data, newval)
326: WidgetData data;
327: Boolean newval;
328: {
329: if ((data->value) == newval) return;
330:
331: (data->value) = newval;
332: data->gc = (newval ? data->onGC : data->offGC);
333: /*
334: XSetWindowBackground(data->dpy, data->window, data->gc->value.background);
335: */
336: Redisplay(data);
337: }
338:
339: /*
340: *
341: * Widget set value event handler
342: *
343: */
344:
345: /*ARGSUSED*/
346: static XtEventReturnCode On(event, eventdata)
347: XEvent *event;
348: caddr_t eventdata;
349: {
350: WidgetData data = (WidgetData) eventdata;
351:
352: SetValue(data, TRUE);
353: return (XteventHandled);
354: }
355:
356: /*
357: *
358: * Widget un-set value event handler
359: *
360: */
361:
362: /*ARGSUSED*/
363: static XtEventReturnCode Off(event, eventdata)
364: XEvent *event;
365: caddr_t eventdata;
366: {
367: WidgetData data = (WidgetData) eventdata;
368:
369: SetValue(data, FALSE);
370: return (XteventHandled);
371: }
372:
373: /*
374: *
375: * Widget toggle value event handler
376: *
377: */
378:
379: /*ARGSUSED*/
380: static XtEventReturnCode Toggle(data)
381: WidgetData data;
382: {
383: SetValue(data, ! (data->value));
384: return (XteventHandled);
385: }
386:
387: /*
388: * Widget handler to invoke application routine */
389:
390: /*ARGSUSED*/
391: static XtEventReturnCode Notify(data)
392: WidgetData data;
393: {
394: Redisplay(data);
395: XFlush(data->dpy);
396: data->proc(data->tag); /* invoke application proc */
397:
398: return(XteventHandled);
399: }
400:
401:
402: /*
403: *
404: * Destroy the widget
405: *
406: */
407:
408: static void Destroy(data)
409: WidgetData data;
410: {
411: (void) XDeleteContext(data->dpy, data->window, widgetContext);
412: XtClearEventHandlers(data->dpy, data->window);
413: XtFree ((char*)data->text);
414: XtFree ((char *) data);
415: }
416:
417: /****************************************************************
418: *
419: * Public Procedures
420: *
421: ****************************************************************/
422:
423: Window XtBooleanCreate(dpy, parent, args, argCount)
424: Display *dpy;
425: Window parent;
426: ArgList args;
427: int argCount;
428: {
429: WidgetData data;
430: XrmNameList names;
431: XrmClassList classes;
432: Position x, y;
433: unsigned int depth;
434: Drawable root;
435: unsigned long valuemask;
436: XSetWindowAttributes wvals;
437: XGCValues values;
438:
439: static XtActionsRec actionsTable[] = {
440: {"toggle", (caddr_t)Toggle},
441: {"highlight", (caddr_t)Highlight},
442: {"unhighlight", (caddr_t)Unhighlight},
443: {"notify", (caddr_t)Notify},
444: {"on", (caddr_t)On},
445: {"off", (caddr_t)Off},
446: {NULL, NULL}
447: };
448:
449:
450: if (!initialized)
451: BooleanInitialize(dpy);
452:
453: data = (WidgetData) XtMalloc (sizeof(WidgetDataRec));
454:
455: /* Set Default Values */
456: globaldata = globalinit;
457: globaldata.dpy = dpy;
458: XtGetResources(dpy, resources, XtNumber(resources), args, argCount, parent,
459: "boolean", "Boolean", &names, &classes);
460: *data = globaldata;
461:
462: data->state = XtSetActionBindings(
463: data->dpy,
464: data->eventTable, actionsTable, (caddr_t)Ignore);
465:
466: if (data->text == NULL)
467: data->text = XrmNameToAtom(names[XrmNameListLength(names) - 1]);
468: data->text = strcpy( XtMalloc ((unsigned) strlen(data->text) + 1),
469: data->text);
470:
471: /* obtain text dimensions and calculate the window size */
472: SetTextWidthAndHeight(data);
473: if (data->width == 0) data->width = data->twidth + 2*data->ibw;
474: if (data->height == 0) data->height = data->theight + 2*data->ibh;
475:
476: wvals.background_pixel = data->bgpixel;
477: wvals.border_pixel = data->brpixel;
478: wvals.bit_gravity = CenterGravity;
479:
480: valuemask = CWBackPixel | CWBorderPixel | CWBitGravity;
481:
482: if (data->window != NULL) {
483: /* set global data from window parameters */
484: if (
485: XGetGeometry(
486: data->dpy, data->window, &root,
487: &x, &y, &(data->width), &(data->height),
488: &(data->borderWidth), &depth)
489: ) {
490: XReparentWindow(data->dpy, data->window, parent, data->x,data->y);
491: XChangeWindowAttributes(data->dpy, data->window, valuemask, &wvals);
492: } else
493: data->window = NULL;
494: }
495: if (data->window == NULL)
496: data->window = XCreateWindow(data->dpy, parent, data->x, data->y,
497: data->width, data->height, data->borderWidth,
498: 0, (unsigned) InputOutput, (Visual *) CopyFromParent,
499: valuemask, &wvals);
500:
501: values.foreground = data->fgpixel;
502: values.background = data->bgpixel;
503: values.font = data->fontstruct->fid;
504: valuemask = GCForeground | GCBackground | GCFont;
505: data->onGC = XtGetGC(data->dpy, widgetContext, data->window,
506: valuemask, &values);
507: values.foreground = data->bgpixel;
508: values.background = data->fgpixel;
509: data->offGC = XtGetGC(data->dpy, widgetContext, data->window,
510: valuemask, &values);
511:
512: XtSetNameAndClass(data->dpy, data->window, names, classes);
513: XrmFreeNameList(names);
514: XrmFreeClassList(classes);
515:
516: (void)XSaveContext(data->dpy, data->window, widgetContext, (caddr_t)data);
517:
518: /* set handler for expose, resize, and message events */
519: XtSetEventHandler (data->dpy, data->window, (XtEventHandler) EventHandler,
520: StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask
521: | EnterWindowMask | LeaveWindowMask, (caddr_t)data);
522:
523: return (data->window);
524: }
525:
526: /*
527: * Set specified arguments in widget
528: */
529:
530: void XtBooleanSetValues (dpy, window, args, argCount)
531: Display *dpy;
532: Window window;
533: ArgList args;
534: int argCount;
535: {
536: WidgetData data;
537: data = DataFromWindow(dpy, window);
538: if (data == NULL) return;
539:
540: globaldata = *data;
541: XtSetValues(resources, XtNumber(resources), args, argCount);
542:
543: (globaldata.value) = ((globaldata.value) ? TRUE : FALSE);
544:
545: if (strcmp (data->text, globaldata.text)
546: || data->fontstruct != globaldata.fontstruct) {
547: XtGeometryReturnCode reply;
548: WindowBox reqbox, replybox;
549:
550: globaldata.text = strcpy(
551: XtMalloc ((unsigned) strlen(globaldata.text) + 1),
552: globaldata.text);
553: XtFree ((char *) data->text);
554:
555: /* obtain text dimensions and calculate the window size */
556: SetTextWidthAndHeight(&globaldata);
557: reqbox.width = (int) globaldata.twidth + 2*globaldata.ibw;
558: reqbox.height = (int) globaldata.theight + 2*globaldata.ibh;
559: reply = XtMakeGeometryRequest(
560: globaldata.dpy, globaldata.window,
561: XtgeometryResize, &reqbox, &replybox);
562: if (reply == XtgeometryAlmost) {
563: reqbox = replybox;
564: (void) XtMakeGeometryRequest(
565: globaldata.dpy, globaldata.window,
566: XtgeometryResize, &reqbox, &replybox);
567: }
568: }
569:
570: *data = globaldata;
571: Redisplay (data);
572: }
573:
574: /*
575: * Get specified arguments from widget
576: */
577:
578: void XtBooleanGetValues (dpy, window, args, argCount)
579: Display *dpy;
580: Window window;
581: ArgList args;
582: int argCount;
583: {
584: WidgetData data;
585: data = DataFromWindow(dpy, window);
586: if (data == NULL) return;
587:
588: globaldata = *data;
589: XtGetValues(resources, XtNumber(resources), args, argCount);
590: }
591:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.