![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Actions.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 Actions.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: Actions.c,v 1.1 87/09/11 07:57:01 toddb Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)Actions.c 1.12 2/25/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: /* Actions.c -- parse all X events into widget specific actions. */
30:
31: #include <stdio.h>
32: #include "Xlib.h"
33: #include "Xutil.h"
34: #include "Intrinsic.h"
35: #include <strings.h>
36: #include "Atoms.h"
37:
38: /* Private definitions. */
39:
40: #define NUMBUTTONS 3
41: #define NUMKEYS 256
42: #define HASH(x) (((unsigned long)(x)) % NUMKEYS)
43: #define LF 0x0a
44: #define BSLASH '\\'
45:
46: /* X10 Compatibility sillyness stuff (that should go away ...) */
47:
48: #define MetaMask Mod1Mask
49:
50: typedef enum UpDown {down, up};
51:
52: typedef struct _EventSeqRec {
53: unsigned long eventCode;
54: unsigned long eventType;
55: short modeBits, modeMask;
56: XtActionTokenPtr token;
57: struct _EventSeqRec *next;
58: } EventSeqRec, *EventSeqPtr;
59:
60: typedef struct _TranslationRec {
61: XContext context;
62: EventSeqPtr *eventTable;
63: XtActionsPtr actionTable;
64: } TranslationRec;
65:
66: typedef struct {
67: char *event;
68: XContext context;
69: short mode;
70: unsigned long eventType;
71: }EventKey, *EventKeys;
72:
73: EventKey events[] = {
74: {"Key", NULL, 0, KeyPress},
75: {"Ctrl", NULL, ControlMask, KeyPress},
76: {"Meta", NULL, MetaMask, KeyPress},
77: {"Shift", NULL, ShiftMask, KeyPress},
78: {"BtnDown", NULL, 0, ButtonPress},
79: {"BtnUp", NULL, 0, ButtonRelease},
80: {"PtrMoved", NULL, 0, MotionNotify},
81: {"KeyPress", NULL, 0, KeyPress},
82: {"KeyRelease", NULL, 0, KeyRelease},
83: {"ButtonPress", NULL, 0, ButtonPress},
84: {"ButtonRelease", NULL, 0, ButtonRelease},
85: {"MouseMoved", NULL, 0, MotionNotify},
86: {"MotionNotify", NULL, 0, MotionNotify},
87: {"EnterWindow", NULL, 0, EnterNotify},
88: {"LeaveWindow", NULL, 0, LeaveNotify},
89: {"FocusIn", NULL, 0, FocusIn},
90: {"FocusOut", NULL, 0, FocusOut},
91: {"KeymapNotify", NULL, 0, KeymapNotify},
92: {"Expose", NULL, 0, Expose},
93: {"GraphicsExpose", NULL, 0, GraphicsExpose},
94: {"NoExpose", NULL, 0, NoExpose},
95: {"VisibilityNotify",NULL, 0, VisibilityNotify},
96: {"CreateNotify", NULL, 0, CreateNotify},
97: {"DestroyNotify", NULL, 0, DestroyNotify},
98: {"UnmapNotify", NULL, 0, UnmapNotify},
99: {"MapNotify", NULL, 0, MapNotify},
100: {"MapRequest", NULL, 0, MapRequest},
101: {"ReparentNotify", NULL, 0, ReparentNotify},
102: {"ConfigureNotify", NULL, 0, ConfigureNotify},
103: {"ConfigureRequest",NULL, 0, ConfigureRequest},
104: {"GravityNotify", NULL, 0, GravityNotify},
105: {"ResizeRequest", NULL, 0, ResizeRequest},
106: {"CirculateNotify", NULL, 0, CirculateNotify},
107: {"CirculateRequest",NULL, 0, CirculateRequest},
108: {"PropertyNotify", NULL, 0, PropertyNotify},
109: {"SelectionClear", NULL, 0, SelectionClear},
110: {"SelectionRequest",NULL, 0, SelectionRequest},
111: {"SelectionNotify", NULL, 0, SelectionNotify},
112: {"ColormapNotify", NULL, 0, ColormapNotify},
113: {"ClientMessage", NULL, 0, ClientMessage},
114: { NULL, NULL, NULL, NULL}
115: };
116:
117: static Boolean initialized = FALSE;
118: static Boolean parseError;
119:
120: void ActionsInitialize()
121: {
122: int i;
123: void CvtStringToEventBindings();
124:
125: if (initialized)
126: return;
127: initialized = TRUE;
128:
129: for (i = 0; events[i].event != NULL; i++)
130: events[i].context = XAtomToContext(events[i].event);
131: XrmRegisterTypeConverter(XrmRString, XtREventBindings,
132: CvtStringToEventBindings);
133: }
134:
135: static int StrToNum(s)
136: char *s;
137: {
138: int base = 10;
139: register int val = 0;
140: register int c;
141: if (*s == '0') {
142: s++;
143: if (*s == 'x' || *s == 'X') {
144: base = 16;
145: s++;
146: } else
147: base = 8;
148: }
149: while (*s)
150: switch (c = *s++) {
151: case '0':
152: case '1':
153: case '2':
154: case '3':
155: case '4':
156: case '5':
157: case '6':
158: case '7':
159: val = (val * base) + (c - '0');
160: break;
161: case '8':
162: case '9':
163: if (base < 10)
164: return -1;
165: val = (val * base) + (c - '0');
166: break;
167: case 'a':
168: case 'b':
169: case 'c':
170: case 'd':
171: case 'e':
172: case 'f':
173: if (base != 16)
174: return -1;
175: val = (val * base) + (c - 'a' + 10);
176: break;
177: case 'A':
178: case 'B':
179: case 'C':
180: case 'D':
181: case 'E':
182: case 'F':
183: if (base != 16)
184: return -1;
185: val = (val * base) + (c - 'A' + 10);
186: break;
187: default:
188: return -1;
189: }
190: return val;
191: }
192:
193: static Syntax(str)
194: char *str;
195: {
196: (void) fprintf(stderr,
197: "Event Sequence description error (ignored): %s\n", str);
198: }
199:
200: static EventSeqPtr *NewEventTable()
201: {
202: EventSeqPtr *eventTable;
203: int i;
204:
205: eventTable = (EventSeqPtr *) XtMalloc(sizeof(EventSeqPtr)* NUMKEYS);
206: for (i = 0; i < NUMKEYS; i++)
207: eventTable[i] = (EventSeqPtr) NULL;
208: return eventTable;
209: }
210:
211: static XtActionTokenPtr FindAction(list, modeBits, eventCode, eventType)
212: EventSeqPtr list;
213: short modeBits;
214: register int eventCode, eventType;
215: {
216: register EventSeqPtr ptr;
217:
218: for (ptr = list; ptr != NULL; ptr = ptr->next) {
219: if ((ptr->eventCode == eventCode) &&
220: (ptr->eventType == eventType) &&
221: (ptr->modeBits == (modeBits & ptr->modeMask)))
222: return ptr->token;
223: }
224: return NULL;
225: }
226:
227: static MakeKeyOrButtonEntry(list, modeBits, modeMask, eventCode, eventType, token)
228: EventSeqPtr *list;
229: short modeBits, modeMask;
230: unsigned long eventCode, eventType;
231: XtActionTokenPtr token;
232: {
233: register EventSeqPtr ptr;
234:
235: ptr = (EventSeqPtr) XtMalloc(sizeof(EventSeqRec));
236: ptr->eventCode = eventCode;
237: ptr->eventType = eventType;
238: ptr->modeBits = modeBits;
239: ptr->modeMask = modeMask;
240: ptr->token = token;
241: ptr->next = *list;
242: *list = ptr;
243: }
244:
245: static int ButtonMaskFromString(str)
246: char *str;
247: {
248: switch (StrToNum(str)) {
249: case 1:
250: return Button1Mask;
251: case 2:
252: return Button2Mask;
253: case 3:
254: return Button3Mask;
255: case 4:
256: return Button4Mask;
257: case 5:
258: return Button5Mask;
259: }
260: if (strcmp(str, "left") == 0) return Button1Mask;
261: if (strcmp(str, "middle") == 0) return Button2Mask;
262: if (strcmp(str, "right") == 0) return Button3Mask;
263:
264: return 0;
265: }
266:
267: static int ButtonFromString(str)
268: char *str;
269: {
270: switch (ButtonMaskFromString(str)) {
271: case Button1Mask:
272: return Button1;
273: case Button2Mask:
274: return Button2;
275: case Button3Mask:
276: return Button3;
277: case Button4Mask:
278: return Button4;
279: case Button5Mask:
280: return Button5;
281: }
282:
283: parseError = TRUE;
284: return 0;
285: }
286:
287: /*
288: static StringToToken(table, str, token)
289: XtActionsPtr table;
290: char *str;
291: int *token;
292: {
293: register XtActionsPtr tab = table;
294: while (tab->string) {
295: if (strcmp(tab->string, str) == 0) {
296: *token = tab->value;
297: return TRUE;
298: }
299: tab++;
300: }
301: return FALSE;
302: }
303: */
304:
305: static Boolean ParseChar(s, c)
306: char **s;
307: char *c;
308: {
309: Boolean result = FALSE;
310: register char *ptr;
311:
312: ptr = *s;
313: *c = *ptr++;
314: if (*c == '\\') {
315: result = TRUE;
316: *c = *ptr++;
317: switch (*c) {
318: case 't': *c = '\t'; break;
319: case 'n': *c = '\n'; break;
320: case 'r': *c = '\r'; break;
321: case 'e': *c = '\033'; break;
322: }
323: if (*c >= '0' && *c <= '9') {
324: *c = (*c - '0') * 64 + (ptr[0] - '0') * 8 + ptr[1] - '0';
325: ptr += 2;
326: }
327: }
328: *s = ptr;
329: return result;
330: }
331:
332:
333: static ParseEventSequenceBinding(str, tbl)
334: char *str;
335: EventSeqPtr *tbl;
336: {
337: char str2[500], modeStr[50], typeStr[50], detailStr[50];
338: char *ptr, *ptr2, c;
339: Boolean backSlash;
340: int modeBits, modeMask, i, code;
341: Boolean notFlag, done;
342: XtActionTokenPtr tok, lasttok, firsttok;
343: unsigned long eventType;
344: XContext eventContext;
345:
346: ptr = str;
347: modeStr[0] = 0;
348: typeStr[0] = 0;
349: detailStr[0] = 0;
350: parseError = FALSE;
351: ptr2 = modeStr;
352: while (*ptr != ':') { /* find end of lhs and collect pieces */
353: switch (*ptr) {
354: case 0:
355: case LF:
356: Syntax(str);
357: return;
358:
359: case BSLASH:
360: ptr++;
361: *ptr2++ = *ptr++;
362: break;
363: case '<':
364: *ptr2 = 0;
365: ptr2 = typeStr;
366: ptr++;
367: break;
368: case '>':
369: *ptr2 = 0;
370: ptr2 = detailStr;
371: ptr++;
372: break;
373: default:
374: *ptr2++ = *ptr++;
375: }
376: }
377: *ptr2 = 0;
378: ptr++; /* step over ':' */
379: /* process mode flags */
380: ptr2 = modeStr;
381: notFlag = FALSE;
382: code = 0;
383: modeBits = 0;
384: modeMask = 0;
385: while (*(ptr2)) {
386: switch (*ptr2) {
387: case '~':
388: notFlag = TRUE;
389: break;
390: case 'c':
391: modeMask |= ControlMask;
392: if (notFlag)
393: modeBits &= ~ControlMask;
394: else
395: modeBits |= ControlMask;
396: notFlag = FALSE;
397: break;
398: case 'm':
399: modeMask |= MetaMask;
400: if (notFlag)
401: modeBits &= ~MetaMask;
402: else
403: modeBits |= MetaMask;
404: notFlag = FALSE;
405: break;
406: case 's':
407: modeMask |= ShiftMask;
408: if (notFlag)
409: modeBits &= ~ShiftMask;
410: else
411: modeBits |= ShiftMask;
412: notFlag = FALSE;
413: break;
414: case 'l':
415: modeMask |= LockMask;
416: if (notFlag)
417: modeBits &= ~LockMask;
418: else
419: modeBits |= LockMask;
420: notFlag = FALSE;
421: break;
422: case '1':
423: case '2':
424: case '3':
425: case '4':
426: case '5':
427: str2[0] = *ptr2;
428: str2[1] = '\0';
429: i = ButtonMaskFromString(str2);
430: modeMask |= i;
431: if (notFlag)
432: modeBits &= ~i;
433: else
434: modeBits |= i;
435: break;
436:
437: default:
438: Syntax (str);
439: return;
440:
441: }
442: ptr2++;
443: }
444: if (detailStr[0] >= '0' && detailStr[0] <= '9')
445: code = StrToNum (detailStr);
446: /* check for valid event type and set detail */
447: eventType = 0;
448: eventContext = XAtomToContext(typeStr);
449: for (i = 0; events[i].event != NULL; i++) {
450: if (events[i].context == eventContext) {
451: modeBits |= events[i].mode;
452: modeMask |= events[i].mode;
453: eventType = events[i].eventType;
454: break;
455: }
456: }
457: switch (eventType) {
458: case KeyPress:
459: case KeyRelease:
460: if (detailStr[0] >= '0' && detailStr[0] <= '9')
461: code = StrToNum (detailStr);
462: else code = (detailStr[0] >= 'A' && detailStr[0] <= 'Z') ?
463: (detailStr[0] + 'a' - 'A') : detailStr[0];
464: break;
465: case ButtonPress:
466: code = ButtonFromString (detailStr);
467: break;
468: case ButtonRelease:
469: code = ButtonFromString (detailStr);
470: break;
471: case MotionNotify:
472: code = 0;
473: modeBits |= ButtonMaskFromString(detailStr);
474: modeMask |= ButtonMaskFromString(detailStr);
475: break;
476: case 0:
477: Syntax(str);
478: return;
479: }
480: done = FALSE;
481: lasttok = NULL;
482: firsttok = NULL;
483: /* now process rhs */
484: while (*ptr) {
485: tok = (XtActionTokenPtr) XtMalloc (sizeof (XtActionTokenRec));
486: tok->next = NULL;
487: while (*ptr == ' ' || *ptr == '\t')
488: ptr++;
489: switch (*ptr) {
490: case '\n':
491: case '#':
492: case 0:
493: done = TRUE;
494: XtFree ((char *) tok);
495: break;
496: case '\'':
497: ptr++;
498: (void) ParseChar (&ptr, &c);
499: if (*ptr != '\'') {
500: Syntax (str);
501: return;
502: }
503: tok->type = XttokenChar;
504: tok->value.c = c;
505: ptr++;
506: break;
507: case '"':
508: ptr++;
509: ptr2 = str2;
510: while (1) {
511: backSlash = ParseChar (&ptr, ptr2);
512: if (!backSlash && *ptr2 == '"')
513: break;
514: if (!backSlash && *ptr2 == '\n') {
515: Syntax (str);
516: return;
517: }
518: ptr2++;
519: }
520: *ptr2 = 0;
521: tok->type = XttokenString;
522: tok->value.str =
523: strcpy (XtMalloc ((unsigned) strlen (str2) + 1), str2);
524: break;
525: default:
526: ptr2 = str2;
527: do {
528: (void) ParseChar (&ptr, ptr2);
529: c = *ptr2++;
530: } while (c != ' ' && c != '\t' && c != '\n' && c != 0);
531: *--ptr2 = 0;
532: tok->type = XttokenAction;
533: tok->value.action = XtAtomToAction (str2);
534: }
535: if (!done && tok) {
536: if (lasttok)
537: lasttok->next = tok;
538: else
539: firsttok = tok;
540: lasttok = tok;
541: }
542: }
543: /* set action based on eventType */
544: if (parseError)
545: Syntax(str);
546: else
547: MakeKeyOrButtonEntry (&tbl[HASH(code)], modeBits, modeMask,
548: code, eventType, firsttok);
549:
550: }
551:
552: /*ARGSUSED*/
553: void CvtStringToEventBindings(dpy, fromVal, toVal)
554: Display *dpy;
555: XrmValue fromVal;
556: XrmValue *toVal;
557: {
558: FILE *fid;
559: char str[1024];
560: static EventSeqPtr *eventTable; /* ||| STATIC */
561: extern char *getenv();
562:
563: (void) sprintf (str, "%s/%s", getenv ("HOME"), (char *) fromVal.addr);
564: fid = fopen (str, "r");
565: if (fid == NULL) {
566: (void) strcpy (str, LIBDIR);
567: (void) strcat (str, (char *) fromVal.addr);
568: fid = fopen (str, "r");
569: if (fid == NULL) {
570: (void) fprintf (stderr,
571: " Can't find Event Bindings file: %s, using defaults\n",
572: fromVal.addr);
573: return;
574: }
575: }
576: eventTable = NewEventTable();
577: while (!feof (fid)) {
578: (void) fgets (str, 1020, fid);
579: if (str[0] != '#')
580: ParseEventSequenceBinding(str, eventTable);
581: }
582: (void) fclose(fid);
583: (*toVal).size = sizeof(caddr_t);
584: (*toVal).addr = (caddr_t) &eventTable;
585: }
586:
587: /* Public routines. */
588:
589: XtEventsPtr XtParseEventBindings(stringTable)
590: register char **stringTable;
591: {
592: register int i = 0;
593: register EventSeqPtr *eventTable;
594:
595: eventTable = NewEventTable();
596: while (stringTable[i]) {
597: ParseEventSequenceBinding(stringTable[i], eventTable);
598: i++;
599: }
600: return (XtEventsPtr)eventTable;
601: }
602:
603: caddr_t XtSetActionBindings(dpy, eventTable, actionTable, defaultValue)
604: Display *dpy;
605: XtEventsPtr eventTable;
606: register XtActionsPtr actionTable;
607: caddr_t defaultValue;
608: {
609: register XContext context;
610: register TranslationPtr state;
611:
612: state = (TranslationPtr)XtMalloc(sizeof(TranslationRec));
613: context = XUniqueContext();
614: state->actionTable = actionTable;
615: state->eventTable = (EventSeqPtr *) eventTable;
616: while (actionTable->string) {
617: (void) XSaveContext (
618: dpy, (Window) XtAtomToAction (actionTable->string),
619: context, (caddr_t) actionTable->value);
620: actionTable++;
621: }
622: (void) XSaveContext (dpy, (Window) NULL, context, defaultValue);
623: state->context = context;
624: return (caddr_t) state;
625: }
626:
627: XtActionTokenPtr XtTranslateEvent(event, state)
628: register XEvent *event;
629: TranslationPtr state;
630: {
631: register XtActionTokenPtr result;
632: static XtActionTokenRec temp;
633: static char str[1024]; /* !!! STATIC ||| */
634: register int code;
635: register int modeBits;
636: int n;
637:
638: result = NULL;
639: code = 0;
640: modeBits = 0;
641: switch (event->type) {
642: case KeyPress:
643: case KeyRelease:
644: code = XLookupKeysym(&event->xkey, 0);
645: modeBits = event->xkey.state;
646: break;
647: case ButtonPress:
648: case ButtonRelease:
649: code = event->xbutton.button;
650: modeBits = event->xbutton.state;
651: break;
652: case MotionNotify:
653: modeBits = event->xmotion.state;
654: break;
655: case EnterNotify:
656: case LeaveNotify:
657: modeBits = event->xcrossing.state;
658: break;
659: }
660: result = FindAction (state->eventTable[HASH(code)], modeBits, code, event->type);
661: if (result == NULL &&
662: (event->type == KeyPress || event->type == KeyRelease)) {
663: n = XLookupString((XKeyEvent *)event, str, sizeof(str),
664: (KeySym *)NULL, (XComposeStatus *)NULL);
665: if (n == 0)
666: result = NULL;
667: else {
668: str[n] = 0;
669: temp.value.str = str;
670: temp.type = XttokenString;
671: temp.next = NULL;
672: result = &temp;
673: }
674: }
675: return result;
676: }
677:
678:
679: caddr_t XtInterpretAction(dpy, state, action)
680: Display *dpy;
681: TranslationPtr state;
682: XtAction action;
683: {
684: caddr_t result;
685: if (XFindContext(
686: dpy, (Window) action, state->context, (caddr_t *) &result))
687: (void) XFindContext(dpy, (Window) NULL, state->context,
688: (caddr_t *) &result);
689: return result;
690: }
691:
692:
693: XtAddAction(dpy, context, string, action)
694: Display *dpy;
695: XContext context;
696: char *string;
697: int action;
698: {
699: (void) XSaveContext(dpy, (Window) XAtomToContext(string),
700: context, (caddr_t) action);
701: }
702:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.