![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkbind.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkbind.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkBind.c --
3: *
4: * This file provides procedures that associate Tcl commands
5: * with X events or sequences of X events.
6: *
7: * Copyright 1989-1991 Regents of the University of California
8: * Permission to use, copy, modify, and distribute this
9: * software and its documentation for any purpose and without
10: * fee is hereby granted, provided that the above copyright
11: * notice appear in all copies. The University of California
12: * makes no representations about the suitability of this
13: * software for any purpose. It is provided "as is" without
14: * express or implied warranty.
15: */
16:
17: #ifndef lint
18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkBind.c,v 1.48 92/08/10 16:55:24 ouster Exp $ SPRITE (Berkeley)";
19: #endif /* not lint */
20:
21: #include "tkconfig.h"
22: #include "tkint.h"
23:
24: /*
25: * The structure below represents a binding table. A binding table
26: * represents a domain in which event bindings may occur. It includes
27: * a space of objects relative to which events occur (usually windows,
28: * but not always), a history of recent events in the domain, and
29: * a set of mappings that associate particular Tcl commands with sequences
30: * of events in the domain. Multiple binding tables may exist at once,
31: * either because there are multiple applications open, or because there
32: * are multiple domains within an application with separate event
33: * bindings for each (for example, each canvas widget has a separate
34: * binding table for associating events with the items in the canvas).
35: */
36:
37: #define EVENT_BUFFER_SIZE 10
38: typedef struct BindingTable {
39: XEvent eventRing[EVENT_BUFFER_SIZE];/* Circular queue of recent events
40: * (higher indices are for more recent
41: * events). */
42: int detailRing[EVENT_BUFFER_SIZE]; /* "Detail" information (keySym or
43: * button or 0) for each entry in
44: * eventRing. */
45: int curEvent; /* Index in eventRing of most recent
46: * event. Newer events have higher
47: * indices. */
48: Tcl_HashTable patternTable; /* Used to map from an event to a list
49: * of patterns that may match that
50: * event. Keys are PatternTableKey
51: * structs, values are (PatSeq *). */
52: Tcl_HashTable objectTable; /* Used to map from an object to a list
53: * of patterns associated with that
54: * object. Keys are ClientData,
55: * values are (PatSeq *). */
56: Tcl_Interp *interp; /* Interpreter in which commands are
57: * executed. */
58: } BindingTable;
59:
60: /*
61: * Structures of the following form are used as keys in the patternTable
62: * for a binding table:
63: */
64:
65: typedef struct PatternTableKey {
66: ClientData object; /* Identifies object (or class of objects)
67: * relative to which event occurred. For
68: * example, in the widget binding table for
69: * an application this is the path name of
70: * a widget, or a widget class, or "all". */
71: int type; /* Type of event (from X). */
72: int detail; /* Additional information, such as
73: * keysym or button, or 0 if nothing
74: * additional.*/
75: } PatternTableKey;
76:
77: /*
78: * The following structure defines a pattern, which is matched
79: * against X events as part of the process of converting X events
80: * into Tcl commands.
81: */
82:
83: typedef struct Pattern {
84: int eventType; /* Type of X event, e.g. ButtonPress. */
85: int needMods; /* Mask of modifiers that must be
86: * present (0 means no modifiers are
87: * required). */
88: int hateMods; /* Mask of modifiers that must not be
89: * present (0 means any modifiers are
90: * OK). */
91: int detail; /* Additional information that must
92: * match event. Normally this is 0,
93: * meaning no additional information
94: * must match. For KeyPress and
95: * KeyRelease events, a keySym may
96: * be specified to select a
97: * particular keystroke (0 means any
98: * keystrokes). For button events,
99: * specifies a particular button (0
100: * means any buttons are OK). */
101: } Pattern;
102:
103: /*
104: * The structure below defines a pattern sequence, which consists
105: * of one or more patterns. In order to trigger, a pattern
106: * sequence must match the most recent X events (first pattern
107: * to most recent event, next pattern to next event, and so on).
108: */
109:
110: typedef struct PatSeq {
111: int numPats; /* Number of patterns in sequence
112: * (usually 1). */
113: char *command; /* Command to invoke when this
114: * pattern sequence matches (malloc-ed). */
115: int flags; /* Miscellaneous flag values; see
116: * below for definitions. */
117: struct PatSeq *nextSeqPtr;
118: /* Next in list of all pattern
119: * sequences that have the same
120: * initial pattern. NULL means
121: * end of list. */
122: Tcl_HashEntry *hPtr; /* Pointer to hash table entry for
123: * the initial pattern. This is the
124: * head of the list of which nextSeqPtr
125: * forms a part. */
126: ClientData object; /* Identifies object with which event is
127: * associated (e.g. window). */
128: struct PatSeq *nextObjPtr;
129: /* Next in list of all pattern
130: * sequences for the same object
131: * (NULL for end of list). Needed to
132: * implement Tk_DeleteAllBindings. */
133: Pattern pats[1]; /* Array of "numPats" patterns. Only
134: * one element is declared here but
135: * in actuality enough space will be
136: * allocated for "numPats" patterns.
137: * To match, pats[0] must match event
138: * n, pats[1] must match event n-1,
139: * etc. */
140: } PatSeq;
141:
142: /*
143: * Flag values for PatSeq structures:
144: *
145: * PAT_NEARBY 1 means that all of the events matching
146: * this sequence must occur with nearby X
147: * and Y mouse coordinates and close in time.
148: * This is typically used to restrict multiple
149: * button presses.
150: * PAT_PERCENTS 1 means that the command for this pattern
151: * requires percent substitution. 0 means there
152: * are no percents in the command.
153: */
154:
155: #define PAT_NEARBY 1
156: #define PAT_PERCENTS 2
157:
158: /*
159: * Constants that define how close together two events must be
160: * in milliseconds or pixels to meet the PAT_NEARBY constraint:
161: */
162:
163: #define NEARBY_PIXELS 5
164: #define NEARBY_MS 500
165:
166: /*
167: * The data structure and hash table below are used to map from
168: * textual keysym names to keysym numbers. This structure is
169: * present here because the corresponding X procedures are
170: * ridiculously slow.
171: */
172:
173: typedef struct {
174: char *name; /* Name of keysym. */
175: KeySym value; /* Numeric identifier for keysym. */
176: } KeySymInfo;
177: KeySymInfo keyArray[] = {
178: #ifndef lint
179: #include "ks_names.h"
180: #endif
181: (char *) NULL, 0
182: };
183: static Tcl_HashTable keySymTable; /* Hashed form of above structure. */
184:
185: static int initialized = 0;
186:
187: /*
188: * A hash table is kept to map from the string names of event
189: * modifiers to information about those modifiers. The structure
190: * for storing this information, and the hash table built at
191: * initialization time, are defined below.
192: */
193:
194: typedef struct {
195: char *name; /* Name of modifier. */
196: int mask; /* Button/modifier mask value, * such as Button1Mask. */
197: int flags; /* Various flags; see below for
198: * definitions. */
199: } ModInfo;
200:
201: /*
202: * Flags for ModInfo structures:
203: *
204: * DOUBLE - Non-zero means duplicate this event,
205: * e.g. for double-clicks.
206: * TRIPLE - Non-zero means triplicate this event,
207: * e.g. for triple-clicks.
208: * ANY - Non-zero means that this event allows
209: * any unspecified modifiers.
210: */
211:
212: #define DOUBLE 1
213: #define TRIPLE 2
214: #define ANY 4
215:
216: static ModInfo modArray[] = {
217: "Control", ControlMask, 0,
218: "Shift", ShiftMask, 0,
219: "Lock", LockMask, 0,
220: "B1", Button1Mask, 0,
221: "Button1", Button1Mask, 0,
222: "B2", Button2Mask, 0,
223: "Button2", Button2Mask, 0,
224: "B3", Button3Mask, 0,
225: "Button3", Button3Mask, 0,
226: "B4", Button4Mask, 0,
227: "Button4", Button4Mask, 0,
228: "B5", Button5Mask, 0,
229: "Button5", Button5Mask, 0,
230: "Mod1", Mod1Mask, 0,
231: "M1", Mod1Mask, 0,
232: "Meta", Mod1Mask, 0,
233: "M", Mod1Mask, 0,
234: "Mod2", Mod2Mask, 0,
235: "M2", Mod2Mask, 0,
236: "Alt", Mod2Mask, 0,
237: "Mod3", Mod3Mask, 0,
238: "M3", Mod3Mask, 0,
239: "Mod4", Mod4Mask, 0,
240: "M4", Mod4Mask, 0,
241: "Mod5", Mod5Mask, 0,
242: "M5", Mod5Mask, 0,
243: "Double", 0, DOUBLE,
244: "Triple", 0, TRIPLE,
245: "Any", 0, ANY,
246: NULL, 0, 0};
247: static Tcl_HashTable modTable;
248:
249: /*
250: * This module also keeps a hash table mapping from event names
251: * to information about those events. The structure, an array
252: * to use to initialize the hash table, and the hash table are
253: * all defined below.
254: */
255:
256: typedef struct {
257: char *name; /* Name of event. */
258: int type; /* Event type for X, such as
259: * ButtonPress. */
260: int eventMask; /* Mask bits (for XSelectInput)
261: * for this event type. */
262: } EventInfo;
263:
264: /*
265: * Note: some of the masks below are an OR-ed combination of
266: * several masks. This is necessary because X doesn't report
267: * up events unless you also ask for down events. Also, X
268: * doesn't report button state in motion events unless you've
269: * asked about button events.
270: */
271:
272: static EventInfo eventArray[] = {
273: "Motion", MotionNotify,
274: ButtonPressMask|PointerMotionMask,
275: "Button", ButtonPress, ButtonPressMask,
276: "ButtonPress", ButtonPress, ButtonPressMask,
277: "ButtonRelease", ButtonRelease,
278: ButtonPressMask|ButtonReleaseMask,
279: "Colormap", ColormapNotify, ColormapChangeMask,
280: "Enter", EnterNotify, EnterWindowMask,
281: "Leave", LeaveNotify, LeaveWindowMask,
282: "Expose", Expose, ExposureMask,
283: "FocusIn", FocusIn, FocusChangeMask,
284: "FocusOut", FocusOut, FocusChangeMask,
285: "Keymap", KeymapNotify, KeymapStateMask,
286: "Key", KeyPress, KeyPressMask,
287: "KeyPress", KeyPress, KeyPressMask,
288: "KeyRelease", KeyRelease,
289: KeyPressMask|KeyReleaseMask,
290: "Property", PropertyNotify, PropertyChangeMask,
291: "ResizeRequest", ResizeRequest, ResizeRedirectMask,
292: "Circulate", CirculateNotify, StructureNotifyMask,
293: "Configure", ConfigureNotify, StructureNotifyMask,
294: "Destroy", DestroyNotify, StructureNotifyMask,
295: "Gravity", GravityNotify, StructureNotifyMask,
296: "Map", MapNotify, StructureNotifyMask,
297: "Reparent", ReparentNotify, StructureNotifyMask,
298: "Unmap", UnmapNotify, StructureNotifyMask,
299: "Visibility", VisibilityNotify, VisibilityChangeMask,
300: "CirculateRequest", CirculateRequest, SubstructureRedirectMask,
301: "ConfigureRequest", ConfigureRequest, SubstructureRedirectMask,
302: "MapRequest", MapRequest, SubstructureRedirectMask,
303: (char *) NULL, 0, 0};
304: static Tcl_HashTable eventTable;
305:
306: /*
307: * The defines and table below are used to classify events into
308: * various groups. The reason for this is that logically identical
309: * fields (e.g. "state") appear at different places in different
310: * types of events. The classification masks can be used to figure
311: * out quickly where to extract information from events.
312: */
313:
314: #define KEY_BUTTON_MOTION 0x1
315: #define CROSSING 0x2
316: #define FOCUS 0x4
317: #define EXPOSE 0x8
318: #define VISIBILITY 0x10
319: #define CREATE 0x20
320: #define MAP 0x40
321: #define REPARENT 0x80
322: #define CONFIG 0x100
323: #define CONFIG_REQ 0x200
324: #define RESIZE_REQ 0x400
325: #define GRAVITY 0x800
326: #define PROP 0x0100
327: #define SEL_CLEAR 0x2000
328: #define SEL_REQ 0x4000
329: #define SEL_NOTIFY 0x8000
330: #define COLORMAP 0x10000
331: #define MAPPING 0x20000
332:
333: static int flagArray[LASTEvent] = {
334: /* Not used */ 0,
335: /* Not used */ 0,
336: /* KeyPress */ KEY_BUTTON_MOTION,
337: /* KeyRelease */ KEY_BUTTON_MOTION,
338: /* ButtonPress */ KEY_BUTTON_MOTION,
339: /* ButtonRelease */ KEY_BUTTON_MOTION,
340: /* MotionNotify */ KEY_BUTTON_MOTION,
341: /* EnterNotify */ CROSSING,
342: /* LeaveNotify */ CROSSING,
343: /* FocusIn */ FOCUS,
344: /* FocusOut */ FOCUS,
345: /* KeymapNotify */ 0,
346: /* Expose */ EXPOSE,
347: /* GraphicsExpose */ EXPOSE,
348: /* NoExpose */ 0,
349: /* VisibilityNotify */ VISIBILITY,
350: /* CreateNotify */ CREATE,
351: /* DestroyNotify */ 0,
352: /* UnmapNotify */ 0,
353: /* MapNotify */ MAP,
354: /* MapRequest */ 0,
355: /* ReparentNotify */ REPARENT,
356: /* ConfigureNotify */ CONFIG,
357: /* ConfigureRequest */ CONFIG_REQ,
358: /* GravityNotify */ 0,
359: /* ResizeRequest */ RESIZE_REQ,
360: /* CirculateNotify */ 0,
361: /* CirculateRequest */ 0,
362: /* PropertyNotify */ PROP,
363: /* SelectionClear */ SEL_CLEAR,
364: /* SelectionRequest */ SEL_REQ,
365: /* SelectionNotify */ SEL_NOTIFY,
366: /* ColormapNotify */ COLORMAP,
367: /* ClientMessage */ 0,
368: /* MappingNotify */ MAPPING
369: };
370:
371: /*
372: * Forward declarations for procedures defined later in this
373: * file:
374: */
375:
376: static char * ExpandPercents _ANSI_ARGS_((char *before,
377: XEvent *eventPtr, KeySym keySym, char *after,
378: int afterSize));
379: static PatSeq * FindSequence _ANSI_ARGS_((Tcl_Interp *interp,
380: BindingTable *bindPtr, ClientData object,
381: char *eventString, int create,
382: unsigned long *maskPtr));
383: static char * GetField _ANSI_ARGS_((char *p, char *copy, int size));
384: static KeySym GetKeySym _ANSI_ARGS_((TkDisplay *dispPtr,
385: XEvent *eventPtr));
386: static PatSeq * MatchPatterns _ANSI_ARGS_((BindingTable *bindPtr,
387: PatSeq *psPtr));
388:
389: /*
390: *--------------------------------------------------------------
391: *
392: * Tk_CreateBindingTable --
393: *
394: * Set up a new domain in which event bindings may be created.
395: *
396: * Results:
397: * The return value is a token for the new table, which must
398: * be passed to procedures like Tk_CreatBinding.
399: *
400: * Side effects:
401: * Memory is allocated for the new table.
402: *
403: *--------------------------------------------------------------
404: */
405:
406: Tk_BindingTable
407: Tk_CreateBindingTable(interp)
408: Tcl_Interp *interp; /* Interpreter to associate with the binding
409: * table: commands are executed in this
410: * interpreter. */
411: {
412: register BindingTable *bindPtr;
413: int i;
414:
415: /*
416: * If this is the first time a binding table has been created,
417: * initialize the global data structures.
418: */
419:
420: if (!initialized) {
421: register KeySymInfo *kPtr;
422: register Tcl_HashEntry *hPtr;
423: register ModInfo *modPtr;
424: register EventInfo *eiPtr;
425: int dummy;
426:
427: initialized = 1;
428:
429: Tcl_InitHashTable(&keySymTable, TCL_STRING_KEYS);
430: for (kPtr = keyArray; kPtr->name != NULL; kPtr++) {
431: hPtr = Tcl_CreateHashEntry(&keySymTable, kPtr->name, &dummy);
432: Tcl_SetHashValue(hPtr, kPtr->value);
433: }
434:
435: Tcl_InitHashTable(&modTable, TCL_STRING_KEYS);
436: for (modPtr = modArray; modPtr->name != NULL; modPtr++) {
437: hPtr = Tcl_CreateHashEntry(&modTable, modPtr->name, &dummy);
438: Tcl_SetHashValue(hPtr, modPtr);
439: }
440:
441: Tcl_InitHashTable(&eventTable, TCL_STRING_KEYS);
442: for (eiPtr = eventArray; eiPtr->name != NULL; eiPtr++) {
443: hPtr = Tcl_CreateHashEntry(&eventTable, eiPtr->name, &dummy);
444: Tcl_SetHashValue(hPtr, eiPtr);
445: }
446: }
447:
448: /*
449: * Create and initialize a new binding table.
450: */
451:
452: bindPtr = (BindingTable *) ckalloc(sizeof(BindingTable));
453: for (i = 0; i < EVENT_BUFFER_SIZE; i++) {
454: bindPtr->eventRing[i].type = -1;
455: }
456: bindPtr->curEvent = 0;
457: Tcl_InitHashTable(&bindPtr->patternTable,
458: sizeof(PatternTableKey)/sizeof(int));
459: Tcl_InitHashTable(&bindPtr->objectTable, TCL_ONE_WORD_KEYS);
460: bindPtr->interp = interp;
461: return (Tk_BindingTable) bindPtr;
462: }
463:
464: /*
465: *--------------------------------------------------------------
466: *
467: * Tk_DeleteBindingTable --
468: *
469: * Destroy a binding table and free up all its memory.
470: * The caller should not use bindingTable again after
471: * this procedure returns.
472: *
473: * Results:
474: * None.
475: *
476: * Side effects:
477: * Memory is freed.
478: *
479: *--------------------------------------------------------------
480: */
481:
482: void
483: Tk_DeleteBindingTable(bindingTable)
484: Tk_BindingTable bindingTable; /* Token for the binding table to
485: * destroy. */
486: {
487: BindingTable *bindPtr = (BindingTable *) bindingTable;
488: PatSeq *psPtr, *nextPtr;
489: Tcl_HashEntry *hPtr;
490: Tcl_HashSearch search;
491:
492: /*
493: * Find and delete all of the patterns associated with the binding
494: * table.
495: */
496:
497: for (hPtr = Tcl_FirstHashEntry(&bindPtr->patternTable, &search);
498: hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
499: for (psPtr = (PatSeq *) Tcl_GetHashValue(hPtr);
500: psPtr != NULL; psPtr = nextPtr) {
501: nextPtr = psPtr->nextSeqPtr;
502: Tk_EventuallyFree((ClientData) psPtr->command,
503: (Tk_FreeProc *) free);
504: ckfree((char *) psPtr);
505: }
506: }
507:
508: /*
509: * Clean up the rest of the information associated with the
510: * binding table.
511: */
512:
513: Tcl_DeleteHashTable(&bindPtr->patternTable);
514: Tcl_DeleteHashTable(&bindPtr->objectTable);
515: ckfree((char *) bindPtr);
516: }
517:
518: /*
519: *--------------------------------------------------------------
520: *
521: * Tk_CreateBinding --
522: *
523: * Add a binding to a binding table, so that future calls to
524: * Tk_BindEvent may execute the command in the binding.
525: *
526: * Results:
527: * The return value is 0 if an error occurred while setting
528: * up the binding. In this case, an error message will be
529: * left in interp->result. If all went well then the return
530: * value is a mask of the event types that must be made
531: * available to Tk_BindEvent in order to properly detect when
532: * this binding triggers. This value can be used to determine
533: * what events to select for in a window, for example.
534: *
535: * Side effects:
536: * The new binding may cause future calls to Tk_BindEvent to
537: * behave differently than they did previously.
538: *
539: *--------------------------------------------------------------
540: */
541:
542: unsigned long
543: Tk_CreateBinding(interp, bindingTable, object, eventString, command, append)
544: Tcl_Interp *interp; /* Used for error reporting. */
545: Tk_BindingTable bindingTable; /* Table in which to create binding. */
546: ClientData object; /* Token for object with which binding
547: * is associated. */
548: char *eventString; /* String describing event sequence
549: * that triggers binding. */
550: char *command; /* Contains Tcl command to execute
551: * when binding triggers. */
552: int append; /* 0 means replace any existing
553: * binding for eventString; 1 means
554: * append to that binding. */
555: {
556: BindingTable *bindPtr = (BindingTable *) bindingTable;
557: register PatSeq *psPtr;
558: unsigned long eventMask;
559:
560: psPtr = FindSequence(interp, bindPtr, object, eventString, 1, &eventMask);
561: if (psPtr == NULL) {
562: return 0;
563: }
564: if (append && (psPtr->command != NULL)) {
565: int length;
566: char *new;
567:
568: length = strlen(psPtr->command) + strlen(command) + 3;
569: new = (char *) ckalloc((unsigned) length);
570: sprintf(new, "%s; %s", psPtr->command, command);
571: Tk_EventuallyFree((ClientData) psPtr->command, (Tk_FreeProc *) free);
572: psPtr->command = new;
573: } else {
574: if (psPtr->command != NULL) {
575: Tk_EventuallyFree((ClientData) psPtr->command,
576: (Tk_FreeProc *) free);
577: }
578: psPtr->command = (char *) ckalloc((unsigned) (strlen(command) + 1));
579: strcpy(psPtr->command, command);
580: }
581:
582: /*
583: * See if the command contains percents and thereby requires
584: * percent substitution.
585: */
586:
587: if (strchr(psPtr->command, '%') != NULL) {
588: psPtr->flags |= PAT_PERCENTS;
589: }
590: return eventMask;
591: }
592:
593: /*
594: *--------------------------------------------------------------
595: *
596: * Tk_DeleteBinding --
597: *
598: * Remove an event binding from a binding table.
599: *
600: * Results:
601: * The result is a standard Tcl return value. If an error
602: * occurs then interp->result will contain an error message.
603: *
604: * Side effects:
605: * The binding given by object and eventString is removed
606: * from bindingTable.
607: *
608: *--------------------------------------------------------------
609: */
610:
611: int
612: Tk_DeleteBinding(interp, bindingTable, object, eventString)
613: Tcl_Interp *interp; /* Used for error reporting. */
614: Tk_BindingTable bindingTable; /* Table in which to delete binding. */
615: ClientData object; /* Token for object with which binding
616: * is associated. */
617: char *eventString; /* String describing event sequence
618: * that triggers binding. */
619: {
620: BindingTable *bindPtr = (BindingTable *) bindingTable;
621: register PatSeq *psPtr, *prevPtr;
622: unsigned long eventMask;
623: Tcl_HashEntry *hPtr;
624:
625: psPtr = FindSequence(interp, bindPtr, object, eventString, 0, &eventMask);
626: if (psPtr == NULL) {
627: Tcl_ResetResult(interp);
628: return TCL_OK;
629: }
630:
631: /*
632: * Unlink the binding from the list for its object, then from the
633: * list for its pattern.
634: */
635:
636: hPtr = Tcl_FindHashEntry(&bindPtr->objectTable, (char *) object);
637: if (hPtr == NULL) {
638: panic("Tk_DeleteBinding couldn't find object table entry");
639: }
640: prevPtr = (PatSeq *) Tcl_GetHashValue(hPtr);
641: if (prevPtr == psPtr) {
642: Tcl_SetHashValue(hPtr, psPtr->nextObjPtr);
643: } else {
644: for ( ; ; prevPtr = prevPtr->nextObjPtr) {
645: if (prevPtr == NULL) {
646: panic("Tk_DeleteBinding couldn't find on object list");
647: }
648: if (prevPtr->nextObjPtr == psPtr) {
649: prevPtr->nextObjPtr = psPtr->nextObjPtr;
650: break;
651: }
652: }
653: }
654: prevPtr = (PatSeq *) Tcl_GetHashValue(psPtr->hPtr);
655: if (prevPtr == psPtr) {
656: if (psPtr->nextSeqPtr == NULL) {
657: Tcl_DeleteHashEntry(psPtr->hPtr);
658: } else {
659: Tcl_SetHashValue(psPtr->hPtr, psPtr->nextSeqPtr);
660: }
661: } else {
662: for ( ; ; prevPtr = prevPtr->nextSeqPtr) {
663: if (prevPtr == NULL) {
664: panic("Tk_DeleteBinding couldn't find on hash chain");
665: }
666: if (prevPtr->nextSeqPtr == psPtr) {
667: prevPtr->nextSeqPtr = psPtr->nextSeqPtr;
668: break;
669: }
670: }
671: }
672: Tk_EventuallyFree((ClientData) psPtr->command, (Tk_FreeProc *) free);
673: ckfree((char *) psPtr);
674: return TCL_OK;
675: }
676:
677: /*
678: *--------------------------------------------------------------
679: *
680: * Tk_GetBinding --
681: *
682: * Return the command associated with a given event string.
683: *
684: * Results:
685: * The return value is a pointer to the command string
686: * associated with eventString for object in the domain
687: * given by bindingTable. If there is no binding for
688: * eventString, or if eventString is improperly formed,
689: * then NULL is returned and an error message is left in
690: * interp->result. The return value is semi-static: it
691: * will persist until the binding is changed or deleted.
692: *
693: * Side effects:
694: * None.
695: *
696: *--------------------------------------------------------------
697: */
698:
699: char *
700: Tk_GetBinding(interp, bindingTable, object, eventString)
701: Tcl_Interp *interp; /* Interpreter for error reporting. */
702: Tk_BindingTable bindingTable; /* Table in which to look for
703: * binding. */
704: ClientData object; /* Token for object with which binding
705: * is associated. */
706: char *eventString; /* String describing event sequence
707: * that triggers binding. */
708: {
709: BindingTable *bindPtr = (BindingTable *) bindingTable;
710: register PatSeq *psPtr;
711: unsigned long eventMask;
712:
713: psPtr = FindSequence(interp, bindPtr, object, eventString, 0, &eventMask);
714: if (psPtr == NULL) {
715: return NULL;
716: }
717: return psPtr->command;
718: }
719:
720: /*
721: *--------------------------------------------------------------
722: *
723: * Tk_GetAllBindings --
724: *
725: * Return a list of event strings for all the bindings
726: * associated with a given object.
727: *
728: * Results:
729: * There is no return value. Interp->result is modified to
730: * hold a Tcl list with one entry for each binding associated
731: * with object in bindingTable. Each entry in the list
732: * contains the event string associated with one binding.
733: *
734: * Side effects:
735: * None.
736: *
737: *--------------------------------------------------------------
738: */
739:
740: void
741: Tk_GetAllBindings(interp, bindingTable, object)
742: Tcl_Interp *interp; /* Interpreter for error reporting. */
743: Tk_BindingTable bindingTable; /* Table in which to look for
744: * bindings. */
745: ClientData object; /* Token for object. */
746:
747: {
748: BindingTable *bindPtr = (BindingTable *) bindingTable;
749: register PatSeq *psPtr;
750: register Pattern *patPtr;
751: Tcl_HashEntry *hPtr;
752: char string[200*EVENT_BUFFER_SIZE];
753: register char *p;
754: int patsLeft, needMods;
755: register ModInfo *modPtr;
756:
757: hPtr = Tcl_FindHashEntry(&bindPtr->objectTable, (char *) object);
758: if (hPtr == NULL) {
759: return;
760: }
761: for (psPtr = (PatSeq *) Tcl_GetHashValue(hPtr); psPtr != NULL;
762: psPtr = psPtr->nextObjPtr) {
763:
764: p = string;
765:
766: /*
767: * For each binding, output information about each of the
768: * patterns in its sequence. The order of the patterns in
769: * the sequence is backwards from the order in which they
770: * must be output.
771: */
772:
773: for (patsLeft = psPtr->numPats,
774: patPtr = &psPtr->pats[psPtr->numPats - 1];
775: patsLeft > 0; patsLeft--, patPtr--) {
776:
777: /*
778: * Check for simple case of an ASCII character.
779: */
780:
781: if ((patPtr->eventType == KeyPress)
782: && (patPtr->needMods == 0)
783: && (patPtr->hateMods == ~ShiftMask)
784: && isascii(patPtr->detail) && isprint(patPtr->detail)
785: && (patPtr->detail != '<')
786: && (patPtr->detail != ' ')) {
787:
788: *p = patPtr->detail;
789: p++;
790: continue;
791: }
792:
793: /*
794: * It's a more general event specification. First check
795: * for "Double" or "Triple", then "Any", then modifiers,
796: * the event type, then keysym or button detail.
797: */
798:
799: *p = '<';
800: p++;
801: if ((patsLeft > 1) && (memcmp((char *) patPtr,
802: (char *) (patPtr-1), sizeof(Pattern)) == 0)) {
803: patsLeft--;
804: patPtr--;
805: if ((patsLeft > 1) && (memcmp((char *) patPtr,
806: (char *) (patPtr-1), sizeof(Pattern)) == 0)) {
807: patsLeft--;
808: patPtr--;
809: strcpy(p, "Triple-");
810: } else {
811: strcpy(p, "Double-");
812: }
813: p += strlen(p);
814: }
815:
816: if (patPtr->hateMods == 0) {
817: strcpy(p, "Any-");
818: p += strlen(p);
819: }
820:
821: for (needMods = patPtr->needMods, modPtr = modArray;
822: needMods != 0; modPtr++) {
823: if (modPtr->mask & needMods) {
824: needMods &= ~modPtr->mask;
825: strcpy(p, modPtr->name);
826: p += strlen(p);
827: *p = '-';
828: p++;
829: }
830: }
831:
832: if ((patPtr->eventType != KeyPress)
833: || (patPtr->detail == 0)) {
834: register EventInfo *eiPtr;
835:
836: for (eiPtr = eventArray; eiPtr->name != NULL; eiPtr++) {
837: if (eiPtr->type == patPtr->eventType) {
838: strcpy(p, eiPtr->name);
839: p += strlen(p);
840: if (patPtr->detail != 0) {
841: *p = '-';
842: p++;
843: }
844: break;
845: }
846: }
847: }
848:
849: if (patPtr->detail != 0) {
850: if ((patPtr->eventType == KeyPress)
851: || (patPtr->eventType == KeyRelease)) {
852: register KeySymInfo *kPtr;
853:
854: for (kPtr = keyArray; kPtr->name != NULL; kPtr++) {
855: if (patPtr->detail == (int) kPtr->value) {
856: sprintf(p, "%.100s", kPtr->name);
857: p += strlen(p);
858: break;
859: }
860: }
861: } else {
862: sprintf(p, "%d", patPtr->detail);
863: p += strlen(p);
864: }
865: }
866: *p = '>';
867: p++;
868: }
869: *p = 0;
870: if ((p - string) >= sizeof(string)) {
871: panic("Tk_GetAllBindings overflowed buffer");
872: }
873: Tcl_AppendElement(interp, string, 0);
874: }
875: }
876:
877: /*
878: *--------------------------------------------------------------
879: *
880: * Tk_DeleteAllBindings --
881: *
882: * Remove all bindings associated with a given object in a
883: * given binding table.
884: *
885: * Results:
886: * All bindings associated with object are removed from
887: * bindingTable.
888: *
889: * Side effects:
890: * None.
891: *
892: *--------------------------------------------------------------
893: */
894:
895: void
896: Tk_DeleteAllBindings(bindingTable, object)
897: Tk_BindingTable bindingTable; /* Table in which to delete
898: * bindings. */
899: ClientData object; /* Token for object. */
900: {
901: BindingTable *bindPtr = (BindingTable *) bindingTable;
902: register PatSeq *psPtr, *prevPtr;
903: PatSeq *nextPtr;
904: Tcl_HashEntry *hPtr;
905:
906: hPtr = Tcl_FindHashEntry(&bindPtr->objectTable, (char *) object);
907: if (hPtr == NULL) {
908: return;
909: }
910: for (psPtr = (PatSeq *) Tcl_GetHashValue(hPtr); psPtr != NULL;
911: psPtr = nextPtr) {
912: nextPtr = psPtr->nextObjPtr;
913:
914: /*
915: * Be sure to remove each binding from its hash chain in the
916: * pattern table. If this is the last pattern in the chain,
917: * then delete the hash entry too.
918: */
919:
920: prevPtr = (PatSeq *) Tcl_GetHashValue(psPtr->hPtr);
921: if (prevPtr == psPtr) {
922: if (psPtr->nextSeqPtr == NULL) {
923: Tcl_DeleteHashEntry(psPtr->hPtr);
924: } else {
925: Tcl_SetHashValue(psPtr->hPtr, psPtr->nextSeqPtr);
926: }
927: } else {
928: for ( ; ; prevPtr = prevPtr->nextSeqPtr) {
929: if (prevPtr == NULL) {
930: panic("Tk_DeleteAllBindings couldn't find on hash chain");
931: }
932: if (prevPtr->nextSeqPtr == psPtr) {
933: prevPtr->nextSeqPtr = psPtr->nextSeqPtr;
934: break;
935: }
936: }
937: }
938: Tk_EventuallyFree((ClientData) psPtr->command, (Tk_FreeProc *) free);
939: ckfree((char *) psPtr);
940: }
941: Tcl_DeleteHashEntry(hPtr);
942: }
943:
944: /*
945: *--------------------------------------------------------------
946: *
947: * Tk_BindEvent --
948: *
949: * This procedure is invoked to process an X event. The
950: * event is added to those recorded for the binding table.
951: * Then each of the objects at *objectPtr is checked in
952: * order to see if it has a binding that matches the recent
953: * events. If so, that binding is invoked and the rest of
954: * objects are skipped.
955: *
956: * Results:
957: * None.
958: *
959: * Side effects:
960: * Depends on the command associated with the matching
961: * binding.
962: *
963: *--------------------------------------------------------------
964: */
965:
966: void
967: Tk_BindEvent(bindingTable, eventPtr, tkwin, numObjects, objectPtr)
968: Tk_BindingTable bindingTable; /* Table in which to look for
969: * bindings. */
970: XEvent *eventPtr; /* What actually happened. */
971: Tk_Window tkwin; /* Window on display where event
972: * occurred (needed in order to
973: * locate display information). */
974: int numObjects; /* Number of objects at *objectPtr. */
975: ClientData *objectPtr; /* Array of one or more objects
976: * to check for a matching binding. */
977: {
978: BindingTable *bindPtr = (BindingTable *) bindingTable;
979: TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
980: XEvent *ringPtr;
981: PatSeq *matchPtr;
982: PatternTableKey key;
983: Tcl_HashEntry *hPtr;
984: int detail;
985:
986: /*
987: * Add the new event to the ring of saved events for the
988: * binding table. Consecutive MotionNotify events get combined:
989: * if both the new event and the previous event are MotionNotify,
990: * then put the new event *on top* of the previous event.
991: */
992:
993: if ((eventPtr->type != MotionNotify)
994: || (bindPtr->eventRing[bindPtr->curEvent].type != MotionNotify)) {
995: bindPtr->curEvent++;
996: if (bindPtr->curEvent >= EVENT_BUFFER_SIZE) {
997: bindPtr->curEvent = 0;
998: }
999: }
1000: ringPtr = &bindPtr->eventRing[bindPtr->curEvent];
1001: memcpy((VOID *) ringPtr, (VOID *) eventPtr, sizeof(XEvent));
1002: detail = 0;
1003: bindPtr->detailRing[bindPtr->curEvent] = 0;
1004: if ((ringPtr->type == KeyPress) || (ringPtr->type == KeyRelease)) {
1005: detail = (int) GetKeySym(dispPtr, ringPtr);
1006: if (detail == NoSymbol) {
1007: detail = 0;
1008: }
1009: } else if ((ringPtr->type == ButtonPress)
1010: || (ringPtr->type == ButtonRelease)) {
1011: detail = ringPtr->xbutton.button;
1012: }
1013: bindPtr->detailRing[bindPtr->curEvent] = detail;
1014:
1015: /*
1016: * Loop over all the objects, matching the new event against
1017: * each in turn.
1018: */
1019:
1020: for ( ; numObjects > 0; numObjects--, objectPtr++) {
1021:
1022: /*
1023: * Match the new event against those recorded in the
1024: * pattern table, saving the longest matching pattern.
1025: * For events with details (button and key events) first
1026: * look for a binding for the specific key or button.
1027: * If none is found, then look for a binding for all
1028: * keys or buttons (detail of 0).
1029: */
1030:
1031: matchPtr = NULL;
1032: key.object = *objectPtr;
1033: key.type = ringPtr->type;
1034: key.detail = detail;
1035: hPtr = Tcl_FindHashEntry(&bindPtr->patternTable, (char *) &key);
1036: if (hPtr != NULL) {
1037: matchPtr = MatchPatterns(bindPtr,
1038: (PatSeq *) Tcl_GetHashValue(hPtr));
1039: }
1040: if ((detail != 0) && (matchPtr == NULL)) {
1041: key.detail = 0;
1042: hPtr = Tcl_FindHashEntry(&bindPtr->patternTable, (char *) &key);
1043: if (hPtr != NULL) {
1044: matchPtr = MatchPatterns(bindPtr,
1045: (PatSeq *) Tcl_GetHashValue(hPtr));
1046: }
1047: }
1048:
1049: if (matchPtr != NULL) {
1050:
1051: /*
1052: * %-substitution can increase the length of the command.
1053: * This code handles three cases: (a) no substitution;
1054: * (b) substitution results in short command (use space
1055: * on stack); and (c) substitution results in long
1056: * command (malloc it).
1057: */
1058:
1059: #define STATIC_SPACE 200
1060: char shortSpace[STATIC_SPACE];
1061: int result;
1062:
1063: if (matchPtr->flags & PAT_PERCENTS) {
1064: char *p;
1065: p = ExpandPercents(matchPtr->command, eventPtr,
1066: (KeySym) detail, shortSpace, STATIC_SPACE);
1067: result = Tcl_GlobalEval(bindPtr->interp, p);
1068: if (p != shortSpace) {
1069: ckfree(p);
1070: }
1071: } else {
1072: /*
1073: * The code below is tricky in order allow the binding to
1074: * be modified or deleted as part of the command that the
1075: * binding invokes. Must make sure that the actual command
1076: * string isn't freed until the command completes, and must
1077: * copy the address of this string into a local variable
1078: * in case it's modified by the command.
1079: */
1080:
1081: char *cmd = matchPtr->command;
1082:
1083: Tk_Preserve((ClientData) cmd);
1084: result = Tcl_GlobalEval(bindPtr->interp, cmd);
1085: Tk_Release((ClientData) cmd);
1086: }
1087: if (result != TCL_OK) {
1088: Tcl_AddErrorInfo(bindPtr->interp,
1089: "\n (command bound to event)");
1090: TkBindError(bindPtr->interp);
1091: }
1092: return;
1093: }
1094: }
1095: }
1096:
1097: /*
1098: *----------------------------------------------------------------------
1099: *
1100: * FindSequence --
1101: *
1102: * Find the entry in a binding table that corresponds to a
1103: * particular pattern string, and return a pointer to that
1104: * entry.
1105: *
1106: * Results:
1107: * The return value is normally a pointer to the PatSeq
1108: * in patternTable that corresponds to eventString. If an error
1109: * was found while parsing eventString, or if "create" is 0 and
1110: * no pattern sequence previously existed, then NULL is returned
1111: * and interp->result contains a message describing the problem.
1112: * If no pattern sequence previously existed for eventString, then
1113: * a new one is created with a NULL command field. In a successful
1114: * return, *maskPtr is filled in with a mask of the event types
1115: * on which the pattern sequence depends.
1116: *
1117: * Side effects:
1118: * A new pattern sequence may be created.
1119: *
1120: *----------------------------------------------------------------------
1121: */
1122:
1123: static PatSeq *
1124: FindSequence(interp, bindPtr, object, eventString, create, maskPtr)
1125: Tcl_Interp *interp; /* Interpreter to use for error
1126: * reporting. */
1127: BindingTable *bindPtr; /* Table to use for lookup. */
1128: ClientData object; /* Token for object(s) with which binding
1129: * is associated. */
1130: char *eventString; /* String description of pattern to
1131: * match on. See user documentation
1132: * for details. */
1133: int create; /* 0 means don't create the entry if
1134: * it doesn't already exist. Non-zero
1135: * means create. */
1136: unsigned long *maskPtr; /* *maskPtr is filled in with the event
1137: * types on which this pattern sequence
1138: * depends. */
1139:
1140: {
1141: Pattern pats[EVENT_BUFFER_SIZE];
1142: int numPats;
1143: register char *p;
1144: register Pattern *patPtr;
1145: register PatSeq *psPtr;
1146: register Tcl_HashEntry *hPtr;
1147: #define FIELD_SIZE 20
1148: char field[FIELD_SIZE];
1149: int flags, any, count, new, sequenceSize;
1150: unsigned long eventMask;
1151: PatternTableKey key;
1152:
1153: /*
1154: *-------------------------------------------------------------
1155: * Step 1: parse the pattern string to produce an array
1156: * of Patterns. The array is generated backwards, so
1157: * that the lowest-indexed pattern corresponds to the last
1158: * event that must occur.
1159: *-------------------------------------------------------------
1160: */
1161:
1162: p = eventString;
1163: flags = 0;
1164: eventMask = 0;
1165: for (numPats = 0, patPtr = &pats[EVENT_BUFFER_SIZE-1];
1166: numPats < EVENT_BUFFER_SIZE;
1167: numPats++, patPtr--) {
1168: patPtr->eventType = -1;
1169: patPtr->needMods = 0;
1170: patPtr->hateMods = ~0;
1171: patPtr->detail = 0;
1172: while (isspace(*p)) {
1173: p++;
1174: }
1175: if (*p == '\0') {
1176: break;
1177: }
1178:
1179: /*
1180: * Handle simple ASCII characters. Note: the shift
1181: * modifier is ignored in this case (it's really part
1182: * of the character, rather than a "modifier").
1183: */
1184:
1185: if (*p != '<') {
1186: char string[2];
1187:
1188: patPtr->eventType = KeyPress;
1189: eventMask |= KeyPressMask;
1190: string[0] = *p;
1191: string[1] = 0;
1192: hPtr = Tcl_FindHashEntry(&keySymTable, string);
1193: if (hPtr != NULL) {
1194: patPtr->detail = (int) Tcl_GetHashValue(hPtr);
1195: } else {
1196: if (isprint(*p)) {
1197: patPtr->detail = *p;
1198: } else {
1199: sprintf(interp->result,
1200: "bad ASCII character 0x%x", *p);
1201: return NULL;
1202: }
1203: }
1204: patPtr->hateMods = ~ShiftMask;
1205: p++;
1206: continue;
1207: }
1208:
1209: /*
1210: * A fancier event description. Must consist of
1211: * 1. open angle bracket.
1212: * 2. any number of modifiers, each followed by spaces
1213: * or dashes.
1214: * 3. an optional event name.
1215: * 4. an option button or keysym name. Either this or
1216: * item 3 *must* be present; if both are present
1217: * then they are separated by spaces or dashes.
1218: * 5. a close angle bracket.
1219: */
1220:
1221: any = 0;
1222: count = 1;
1223: p++;
1224: while (1) {
1225: register ModInfo *modPtr;
1226: p = GetField(p, field, FIELD_SIZE);
1227: hPtr = Tcl_FindHashEntry(&modTable, field);
1228: if (hPtr == NULL) {
1229: break;
1230: }
1231: modPtr = (ModInfo *) Tcl_GetHashValue(hPtr);
1232: patPtr->needMods |= modPtr->mask;
1233: if (modPtr->flags & (DOUBLE|TRIPLE)) {
1234: flags |= PAT_NEARBY;
1235: if (modPtr->flags & DOUBLE) {
1236: count = 2;
1237: } else {
1238: count = 3;
1239: }
1240: }
1241: if (modPtr->flags & ANY) {
1242: any = 1;
1243: }
1244: while ((*p == '-') || isspace(*p)) {
1245: p++;
1246: }
1247: }
1248: if (any) {
1249: patPtr->hateMods = 0;
1250: } else {
1251: patPtr->hateMods = ~patPtr->needMods;
1252: }
1253: hPtr = Tcl_FindHashEntry(&eventTable, field);
1254: if (hPtr != NULL) {
1255: register EventInfo *eiPtr;
1256: eiPtr = (EventInfo *) Tcl_GetHashValue(hPtr);
1257: patPtr->eventType = eiPtr->type;
1258: eventMask |= eiPtr->eventMask;
1259: while ((*p == '-') || isspace(*p)) {
1260: p++;
1261: }
1262: p = GetField(p, field, FIELD_SIZE);
1263: }
1264: if (*field != '\0') {
1265: if ((*field >= '1') && (*field <= '5') && (field[1] == '\0')) {
1266: static int masks[] = {~0, ~Button1Mask, ~Button2Mask,
1267: ~Button3Mask, ~Button4Mask, ~Button5Mask};
1268:
1269: if (patPtr->eventType == -1) {
1270: patPtr->eventType = ButtonPress;
1271: eventMask |= ButtonPressMask;
1272: } else if ((patPtr->eventType == KeyPress)
1273: || (patPtr->eventType == KeyRelease)) {
1274: goto getKeysym;
1275: } else if ((patPtr->eventType != ButtonPress)
1276: && (patPtr->eventType != ButtonRelease)) {
1277: Tcl_AppendResult(interp, "specified button \"", field,
1278: "\" for non-button event", (char *) NULL);
1279: return NULL;
1280: }
1281: patPtr->detail = (*field - '0');
1282:
1283: /*
1284: * Ignore this button as a modifier: its state is already
1285: * fixed.
1286: */
1287:
1288: patPtr->needMods &= masks[patPtr->detail];
1289: patPtr->hateMods &= masks[patPtr->detail];
1290: } else {
1291: getKeysym:
1292: hPtr = Tcl_FindHashEntry(&keySymTable, (char *) field);
1293: if (hPtr == NULL) {
1294: Tcl_AppendResult(interp, "bad event type or keysym \"",
1295: field, "\"", (char *) NULL);
1296: return NULL;
1297: }
1298: if (patPtr->eventType == -1) {
1299: patPtr->eventType = KeyPress;
1300: eventMask |= KeyPressMask;
1301: } else if ((patPtr->eventType != KeyPress)
1302: && (patPtr->eventType != KeyRelease)) {
1303: Tcl_AppendResult(interp, "specified keysym \"", field,
1304: "\" for non-key event", (char *) NULL);
1305: return NULL;
1306: }
1307: patPtr->detail = (int) Tcl_GetHashValue(hPtr);
1308:
1309: /*
1310: * Don't get upset about the shift modifier with keys:
1311: * if the key doesn't permit the shift modifier then
1312: * that will already be factored in when translating
1313: * from keycode to keysym in Tk_BindEvent. If the keysym
1314: * has both a shifted and unshifted form, we want to allow
1315: * the shifted form to be specified explicitly, though.
1316: */
1317:
1318: patPtr->hateMods &= ~ShiftMask;
1319: }
1320: } else if (patPtr->eventType == -1) {
1321: interp->result = "no event type or button # or keysym";
1322: return NULL;
1323: }
1324: while ((*p == '-') || isspace(*p)) {
1325: p++;
1326: }
1327: if (*p != '>') {
1328: interp->result = "missing \">\" in binding";
1329: return NULL;
1330: }
1331: p++;
1332:
1333: /*
1334: * Replicate events for DOUBLE and TRIPLE.
1335: */
1336:
1337: if ((count > 1) && (numPats < EVENT_BUFFER_SIZE-1)) {
1338: patPtr[-1] = patPtr[0];
1339: patPtr--;
1340: numPats++;
1341: if ((count == 3) && (numPats < EVENT_BUFFER_SIZE-1)) {
1342: patPtr[-1] = patPtr[0];
1343: patPtr--;
1344: numPats++;
1345: }
1346: }
1347: }
1348:
1349: /*
1350: *-------------------------------------------------------------
1351: * Step 2: find the sequence in the binding table if it exists,
1352: * and add a new sequence to the table if it doesn't.
1353: *-------------------------------------------------------------
1354: */
1355:
1356: if (numPats == 0) {
1357: interp->result = "no events specified in binding";
1358: return NULL;
1359: }
1360: patPtr = &pats[EVENT_BUFFER_SIZE-numPats];
1361: key.object = object;
1362: key.type = patPtr->eventType;
1363: key.detail = patPtr->detail;
1364: hPtr = Tcl_CreateHashEntry(&bindPtr->patternTable, (char *) &key, &new);
1365: sequenceSize = numPats*sizeof(Pattern);
1366: if (!new) {
1367: for (psPtr = (PatSeq *) Tcl_GetHashValue(hPtr); psPtr != NULL;
1368: psPtr = psPtr->nextSeqPtr) {
1369: if ((numPats == psPtr->numPats)
1370: && ((flags & PAT_NEARBY) == (psPtr->flags & PAT_NEARBY))
1371: && (memcmp((char *) patPtr, (char *) psPtr->pats,
1372: sequenceSize) == 0)) {
1373: *maskPtr = eventMask; /*don't forget to pass back the mask*/
1374: goto done;
1375: }
1376: }
1377: }
1378: if (!create) {
1379: if (new) {
1380: Tcl_DeleteHashEntry(hPtr);
1381: }
1382: Tcl_AppendResult(interp, "no binding exists for \"",
1383: eventString, "\"", (char *) NULL);
1384: return NULL;
1385: }
1386: psPtr = (PatSeq *) ckalloc((unsigned) (sizeof(PatSeq)
1387: + (numPats-1)*sizeof(Pattern)));
1388: psPtr->numPats = numPats;
1389: psPtr->command = NULL;
1390: psPtr->flags = flags;
1391: psPtr->nextSeqPtr = (PatSeq *) Tcl_GetHashValue(hPtr);
1392: psPtr->hPtr = hPtr;
1393: Tcl_SetHashValue(hPtr, psPtr);
1394:
1395: /*
1396: * Link the pattern into the list associated with the object.
1397: */
1398:
1399: psPtr->object = object;
1400: hPtr = Tcl_CreateHashEntry(&bindPtr->objectTable, (char *) object, &new);
1401: if (new) {
1402: psPtr->nextObjPtr = NULL;
1403: } else {
1404: psPtr->nextObjPtr = (PatSeq *) Tcl_GetHashValue(hPtr);
1405: }
1406: Tcl_SetHashValue(hPtr, psPtr);
1407:
1408: memcpy((VOID *) psPtr->pats, (VOID *) patPtr, sequenceSize);
1409:
1410: done:
1411: *maskPtr = eventMask;
1412: return psPtr;
1413: }
1414:
1415: /*
1416: *----------------------------------------------------------------------
1417: *
1418: * GetField --
1419: *
1420: * Used to parse pattern descriptions. Copies up to
1421: * size characters from p to copy, stopping at end of
1422: * string, space, "-", ">", or whenever size is
1423: * exceeded.
1424: *
1425: * Results:
1426: * The return value is a pointer to the character just
1427: * after the last one copied (usually "-" or space or
1428: * ">", but could be anything if size was exceeded).
1429: * Also places NULL-terminated string (up to size
1430: * character, including NULL), at copy.
1431: *
1432: * Side effects:
1433: * None.
1434: *
1435: *----------------------------------------------------------------------
1436: */
1437:
1438: static char *
1439: GetField(p, copy, size)
1440: register char *p; /* Pointer to part of pattern. */
1441: register char *copy; /* Place to copy field. */
1442: int size; /* Maximum number of characters to
1443: * copy. */
1444: {
1445: while ((*p != '\0') && !isspace(*p) && (*p != '>')
1446: && (*p != '-') && (size > 1)) {
1447: *copy = *p;
1448: p++;
1449: copy++;
1450: size--;
1451: }
1452: *copy = '\0';
1453: return p;
1454: }
1455:
1456: /*
1457: *----------------------------------------------------------------------
1458: *
1459: * GetKeySym --
1460: *
1461: * Given an X KeyPress or KeyRelease event, map the
1462: * keycode in the event into a KeySym.
1463: *
1464: * Results:
1465: * The return value is the KeySym corresponding to
1466: * eventPtr, or NoSymbol if no matching Keysym could be
1467: * found.
1468: *
1469: * Side effects:
1470: * In the first call for a given display, keycode-to-
1471: * KeySym maps get loaded.
1472: *
1473: *----------------------------------------------------------------------
1474: */
1475:
1476: static KeySym
1477: GetKeySym(dispPtr, eventPtr)
1478: register TkDisplay *dispPtr; /* Display in which to
1479: * map keycode. */
1480: register XEvent *eventPtr; /* Description of X event. */
1481: {
1482: KeySym *symPtr;
1483: KeySym sym;
1484:
1485: /*
1486: * Read the key mapping information from the server if
1487: * we don't have it already.
1488: */
1489:
1490: if (dispPtr->symsPerCode == 0) {
1491: Display *dpy = dispPtr->display;
1492:
1493: #ifdef IS_LINUX
1494: XDisplayKeycodes(dpy, &dispPtr->firstKeycode, &dispPtr->lastKeycode);
1495: #else
1496: dispPtr->firstKeycode =
1497: dpy->min_keycode;
1498: dispPtr->lastKeycode =
1499: dpy->max_keycode;
1500: #endif
1501: dispPtr->keySyms = XGetKeyboardMapping(dpy,
1502: dispPtr->firstKeycode, dispPtr->lastKeycode + 1
1503: - dispPtr->firstKeycode, &dispPtr->symsPerCode);
1504: }
1505:
1506: /*
1507: * Compute the lower-case KeySym for this keycode. May
1508: * have to convert an upper-case KeySym to a lower-case
1509: * one if the list only has a single element.
1510: */
1511:
1512: if ((eventPtr->xkey.keycode < dispPtr->firstKeycode)
1513: || (eventPtr->xkey.keycode > dispPtr->lastKeycode)) {
1514: return NoSymbol;
1515: }
1516: symPtr = &dispPtr->keySyms[(eventPtr->xkey.keycode
1517: - dispPtr->firstKeycode) * dispPtr->symsPerCode];
1518: sym = *symPtr;
1519: if ((dispPtr->symsPerCode == 1) || (symPtr[1] == NoSymbol)) {
1520: if ((sym >= XK_A) && (sym <= XK_Z)) {
1521: sym += (XK_a - XK_A);
1522: } else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) {
1523: sym += (XK_agrave - XK_Agrave);
1524: } else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) {
1525: sym += (XK_oslash - XK_Ooblique);
1526: }
1527: }
1528:
1529: /*
1530: * See whether the key is shifted or caps-locked. If so,
1531: * use an upper-case equivalent if provided, or compute
1532: * one (for caps-lock, just compute upper-case: don't
1533: * use shifted KeySym since that would shift non-alphabetic
1534: * keys).
1535: */
1536:
1537: if (eventPtr->xkey.state & ShiftMask) {
1538: if ((dispPtr->symsPerCode > 1) && (symPtr[1] != NoSymbol)) {
1539: return symPtr[1];
1540: }
1541: shiftToUpper:
1542: if ((sym >= XK_a) && (sym <= XK_z)) {
1543: sym += (XK_A - XK_a);
1544: } else if ((sym >= XK_agrave) && (sym <= XK_adiaeresis)) {
1545: sym += (XK_Agrave - XK_agrave);
1546: } else if ((sym >= XK_oslash) && (sym <= XK_thorn)) {
1547: sym += (XK_Ooblique - XK_oslash);
1548: }
1549: return sym;
1550: }
1551: if (eventPtr->xkey.state & LockMask) {
1552: goto shiftToUpper;
1553: }
1554: return sym;
1555: }
1556:
1557: /*
1558: *----------------------------------------------------------------------
1559: *
1560: * MatchPatterns --
1561: *
1562: * Given a list of pattern sequences and a list of
1563: * recent events, return a pattern sequence that matches
1564: * the event list.
1565: *
1566: * Results:
1567: * The return value is NULL if no pattern matches the
1568: * recent events from bindPtr. If one or more patterns
1569: * matches, then the longest (or most specific) matching
1570: * pattern is returned.
1571: *
1572: * Side effects:
1573: * None.
1574: *
1575: *----------------------------------------------------------------------
1576: */
1577:
1578: static PatSeq *
1579: MatchPatterns(bindPtr, psPtr)
1580: BindingTable *bindPtr; /* Information about binding table, such
1581: * as ring of recent events. */
1582: register PatSeq *psPtr; /* List of pattern sequences. */
1583: {
1584: register PatSeq *bestPtr = NULL;
1585:
1586: /*
1587: * Iterate over all the pattern sequences.
1588: */
1589:
1590: for ( ; psPtr != NULL; psPtr = psPtr->nextSeqPtr) {
1591: register XEvent *eventPtr;
1592: register Pattern *patPtr;
1593: Window window;
1594: int *detailPtr;
1595: int patCount, ringCount, flags, state;
1596:
1597: /*
1598: * Iterate over all the patterns in a sequence to be
1599: * sure that they all match.
1600: */
1601:
1602: eventPtr = &bindPtr->eventRing[bindPtr->curEvent];
1603: detailPtr = &bindPtr->detailRing[bindPtr->curEvent];
1604: window = eventPtr->xany.window;
1605: patPtr = psPtr->pats;
1606: patCount = psPtr->numPats;
1607: ringCount = EVENT_BUFFER_SIZE;
1608: while (patCount > 0) {
1609: if (ringCount <= 0) {
1610: goto nextSequence;
1611: }
1612: if (eventPtr->xany.window != window) {
1613: goto nextSequence;
1614: }
1615: if (eventPtr->xany.type != patPtr->eventType) {
1616: /*
1617: * If the event is a mouse motion, button release,
1618: * or key release event, and it didn't match
1619: * the pattern, then just skip the event and try
1620: * the next event against the same pattern.
1621: */
1622:
1623: if ((eventPtr->xany.type == MotionNotify)
1624: || (eventPtr->xany.type == ButtonRelease)
1625: || (eventPtr->xany.type == KeyRelease)
1626: || (eventPtr->xany.type == NoExpose)
1627: || (eventPtr->xany.type == GraphicsExpose)) {
1628: goto nextEvent;
1629: }
1630: goto nextSequence;
1631: }
1632:
1633: flags = flagArray[eventPtr->type];
1634: if (flags & KEY_BUTTON_MOTION) {
1635: state = eventPtr->xkey.state;
1636: } else if (flags & CROSSING) {
1637: state = eventPtr->xcrossing.state;
1638: } else {
1639: state = 0;
1640: }
1641: if ((state & patPtr->needMods)
1642: != patPtr->needMods) {
1643: goto nextSequence;
1644: }
1645: if ((state & patPtr->hateMods) != 0) {
1646: goto nextSequence;
1647: }
1648: if ((patPtr->detail != 0)
1649: && (patPtr->detail != *detailPtr)) {
1650: goto nextSequence;
1651: }
1652: if (psPtr->flags & PAT_NEARBY) {
1653: register XEvent *firstPtr;
1654:
1655: firstPtr = &bindPtr->eventRing[bindPtr->curEvent];
1656: if ((firstPtr->xkey.x_root
1657: < (eventPtr->xkey.x_root - NEARBY_PIXELS))
1658: || (firstPtr->xkey.x_root
1659: > (eventPtr->xkey.x_root + NEARBY_PIXELS))
1660: || (firstPtr->xkey.y_root
1661: < (eventPtr->xkey.y_root - NEARBY_PIXELS))
1662: || (firstPtr->xkey.y_root
1663: > (eventPtr->xkey.y_root + NEARBY_PIXELS))
1664: || (firstPtr->xkey.time
1665: > (eventPtr->xkey.time + NEARBY_MS))) {
1666: goto nextSequence;
1667: }
1668: }
1669: patPtr++;
1670: patCount--;
1671: nextEvent:
1672: if (eventPtr == bindPtr->eventRing) {
1673: eventPtr = &bindPtr->eventRing[EVENT_BUFFER_SIZE-1];
1674: detailPtr = &bindPtr->detailRing[EVENT_BUFFER_SIZE-1];
1675: } else {
1676: eventPtr--;
1677: detailPtr--;
1678: }
1679: ringCount--;
1680: }
1681:
1682: /*
1683: * This sequence matches. If we've already got another match,
1684: * pick whichever is most specific. Detail is most important,
1685: * then needMods, then hateMods.
1686: */
1687:
1688: if (bestPtr != NULL) {
1689: register Pattern *patPtr2;
1690: int i;
1691:
1692: if (psPtr->numPats != bestPtr->numPats) {
1693: if (bestPtr->numPats > psPtr->numPats) {
1694: goto nextSequence;
1695: } else {
1696: goto newBest;
1697: }
1698: }
1699: for (i = 0, patPtr = psPtr->pats, patPtr2 = bestPtr->pats;
1700: i < psPtr->numPats; i++,patPtr++, patPtr2++) {
1701: if (patPtr->detail != patPtr2->detail) {
1702: if (patPtr->detail == 0) {
1703: goto nextSequence;
1704: } else {
1705: goto newBest;
1706: }
1707: }
1708: if (patPtr->needMods != patPtr2->needMods) {
1709: if ((patPtr->needMods & patPtr2->needMods)
1710: == patPtr->needMods) {
1711: goto nextSequence;
1712: } else {
1713: goto newBest;
1714: }
1715: }
1716: if (patPtr->hateMods != patPtr2->hateMods) {
1717: if ((patPtr->hateMods & patPtr2->hateMods)
1718: == patPtr2->hateMods) {
1719: goto newBest;
1720: } else {
1721: goto nextSequence;
1722: }
1723: }
1724: }
1725: goto nextSequence; /* Tie goes to newest pattern. */
1726: }
1727: newBest:
1728: bestPtr = psPtr;
1729:
1730: nextSequence: continue;
1731: }
1732: return bestPtr;
1733: }
1734:
1735: /*
1736: *--------------------------------------------------------------
1737: *
1738: * ExpandPercents --
1739: *
1740: * Given a command and an event, produce a new command
1741: * by replacing % constructs in the original command
1742: * with information from the X event.
1743: *
1744: * Results:
1745: * The return result is a pointer to the new %-substituted
1746: * command. If the command fits in the space at after, then
1747: * the return value is after. If the command is too large
1748: * to fit at after, then the return value is a pointer to
1749: * a malloc-ed buffer holding the command; in this case it
1750: * is the caller's responsibility to free up the buffer when
1751: * finished with it.
1752: *
1753: * Side effects:
1754: * None.
1755: *
1756: *--------------------------------------------------------------
1757: */
1758:
1759: static char *
1760: ExpandPercents(before, eventPtr, keySym, after, afterSize)
1761: register char *before; /* Command containing percent
1762: * expressions to be replaced. */
1763: register XEvent *eventPtr; /* X event containing information
1764: * to be used in % replacements. */
1765: KeySym keySym; /* KeySym: only relevant for
1766: * KeyPress and KeyRelease events). */
1767: char *after; /* Place to generate new expanded
1768: * command. Must contain at least
1769: * "afterSize" bytes of space. */
1770: int afterSize; /* Number of bytes of space available at
1771: * after. */
1772: {
1773: register char *buffer; /* Pointer to buffer currently being used
1774: * as destination. */
1775: register char *dst; /* Pointer to next place to store character
1776: * in substituted string. */
1777: int spaceLeft; /* Indicates how many more non-null bytes
1778: * may be stored at *dst before space
1779: * runs out. */
1780: int spaceNeeded, cvtFlags; /* Used to substitute string as proper Tcl
1781: * list element. */
1782: int number, flags;
1783: #define NUM_SIZE 40
1784: register char *string;
1785: char numStorage[NUM_SIZE+1];
1786:
1787: if (eventPtr->type < LASTEvent) {
1788: flags = flagArray[eventPtr->type];
1789: } else {
1790: flags = 0;
1791: }
1792: dst = buffer = after;
1793: spaceLeft = afterSize - 1;
1794: while (*before != 0) {
1795: if (*before != '%') {
1796:
1797: /*
1798: * Expand the destination string if necessary.
1799: */
1800:
1801: if (spaceLeft <= 0) {
1802: char *newSpace;
1803:
1804: newSpace = (char *) ckalloc((unsigned) (2*afterSize));
1805: memcpy((VOID *) newSpace, (VOID *) buffer, afterSize);
1806: afterSize *= 2;
1807: dst = newSpace + (dst - buffer);
1808: if (buffer != after) {
1809: ckfree(buffer);
1810: }
1811: buffer = newSpace;
1812: spaceLeft = afterSize - (dst-buffer) - 1;
1813: }
1814: *dst = *before;
1815: dst++;
1816: before++;
1817: spaceLeft--;
1818: continue;
1819: }
1820:
1821: number = 0;
1822: string = "??";
1823: switch (before[1]) {
1824: case '#':
1825: number = eventPtr->xany.serial;
1826: goto doNumber;
1827: case 'a':
1828: number = (int) eventPtr->xconfigure.above;
1829: goto doNumber;
1830: case 'b':
1831: number = eventPtr->xbutton.button;
1832: goto doNumber;
1833: case 'c':
1834: if (flags & EXPOSE) {
1835: number = eventPtr->xexpose.count;
1836: } else if (flags & MAPPING) {
1837: number = eventPtr->xmapping.count;
1838: }
1839: goto doNumber;
1840: case 'd':
1841: if (flags & (CROSSING|FOCUS)) {
1842: switch (eventPtr->xcrossing.detail) {
1843: case NotifyAncestor:
1844: string = "NotifyAncestor";
1845: break;
1846: case NotifyVirtual:
1847: string = "NotifyVirtual";
1848: break;
1849: case NotifyInferior:
1850: string = "NotifyInferior";
1851: break;
1852: case NotifyNonlinear:
1853: string = "NotifyNonlinear";
1854: break;
1855: case NotifyNonlinearVirtual:
1856: string = "NotifyNonlinearVirtual";
1857: break;
1858: case NotifyPointer:
1859: string = "NotifyPointer";
1860: break;
1861: case NotifyPointerRoot:
1862: string = "NotifyPointerRoot";
1863: break;
1864: case NotifyDetailNone:
1865: string = "NotifyDetailNone";
1866: break;
1867: }
1868: } else if (flags & CONFIG_REQ) {
1869: switch (eventPtr->xconfigurerequest.detail) {
1870: case Above:
1871: string = "Above";
1872: break;
1873: case Below:
1874: string = "Below";
1875: break;
1876: case TopIf:
1877: string = "TopIf";
1878: break;
1879: case BottomIf:
1880: string = "BottomIf";
1881: break;
1882: case Opposite:
1883: string = "Opposite";
1884: break;
1885: }
1886: }
1887: goto doString;
1888: case 'f':
1889: number = eventPtr->xcrossing.focus;
1890: goto doNumber;
1891: case 'h':
1892: if (flags & EXPOSE) {
1893: number = eventPtr->xexpose.height;
1894: } else if (flags & (CONFIG|CONFIG_REQ)) {
1895: number = eventPtr->xconfigure.height;
1896: } else if (flags & RESIZE_REQ) {
1897: number = eventPtr->xresizerequest.height;
1898: }
1899: goto doNumber;
1900: case 'k':
1901: number = eventPtr->xkey.keycode;
1902: goto doNumber;
1903: case 'm':
1904: if (flags & CROSSING) {
1905: number = eventPtr->xcrossing.mode;
1906: } else if (flags & FOCUS) {
1907: number = eventPtr->xfocus.mode;
1908: }
1909: switch (number) {
1910: case NotifyNormal:
1911: string = "NotifyNormal";
1912: break;
1913: case NotifyGrab:
1914: string = "NotifyGrab";
1915: break;
1916: case NotifyUngrab:
1917: string = "NotifyUngrab";
1918: break;
1919: case NotifyWhileGrabbed:
1920: string = "NotifyWhileGrabbed";
1921: break;
1922: }
1923: goto doString;
1924: case 'o':
1925: if (flags & CREATE) {
1926: number = eventPtr->xcreatewindow.override_redirect;
1927: } else if (flags & MAP) {
1928: number = eventPtr->xmap.override_redirect;
1929: } else if (flags & REPARENT) {
1930: number = eventPtr->xreparent.override_redirect;
1931: } else if (flags & CONFIG) {
1932: number = eventPtr->xconfigure.override_redirect;
1933: }
1934: goto doNumber;
1935: case 'p':
1936: switch (eventPtr->xcirculate.place) {
1937: case PlaceOnTop:
1938: string = "PlaceOnTop";
1939: break;
1940: case PlaceOnBottom:
1941: string = "PlaceOnBottom";
1942: break;
1943: }
1944: goto doString;
1945: case 's':
1946: if (flags & KEY_BUTTON_MOTION) {
1947: number = eventPtr->xkey.state;
1948: } else if (flags & CROSSING) {
1949: number = eventPtr->xcrossing.state;
1950: } else if (flags & VISIBILITY) {
1951: switch (eventPtr->xvisibility.state) {
1952: case VisibilityUnobscured:
1953: string = "VisibilityUnobscured";
1954: break;
1955: case VisibilityPartiallyObscured:
1956: string = "VisibilityPartiallyObscured";
1957: break;
1958: case VisibilityFullyObscured:
1959: string = "VisibilityFullyObscured";
1960: break;
1961: }
1962: goto doString;
1963: }
1964: goto doNumber;
1965: case 't':
1966: if (flags & (KEY_BUTTON_MOTION|PROP|SEL_CLEAR)) {
1967: number = (int) eventPtr->xkey.time;
1968: } else if (flags & SEL_REQ) {
1969: number = (int) eventPtr->xselectionrequest.time;
1970: } else if (flags & SEL_NOTIFY) {
1971: number = (int) eventPtr->xselection.time;
1972: }
1973: goto doNumber;
1974: case 'v':
1975: number = eventPtr->xconfigurerequest.value_mask;
1976: goto doNumber;
1977: case 'w':
1978: if (flags & EXPOSE) {
1979: number = eventPtr->xexpose.width;
1980: } else if (flags & (CONFIG|CONFIG_REQ)) {
1981: number = eventPtr->xconfigure.width;
1982: } else if (flags & RESIZE_REQ) {
1983: number = eventPtr->xresizerequest.width;
1984: }
1985: goto doNumber;
1986: case 'x':
1987: if (flags & KEY_BUTTON_MOTION) {
1988: number = eventPtr->xkey.x;
1989: } else if (flags & EXPOSE) {
1990: number = eventPtr->xexpose.x;
1991: } else if (flags & (CREATE|CONFIG|GRAVITY|CONFIG_REQ)) {
1992: number = eventPtr->xcreatewindow.x;
1993: } else if (flags & REPARENT) {
1994: number = eventPtr->xreparent.x;
1995: } else if (flags & CROSSING) {
1996: number = eventPtr->xcrossing.x;
1997: }
1998: goto doNumber;
1999: case 'y':
2000: if (flags & KEY_BUTTON_MOTION) {
2001: number = eventPtr->xkey.y;
2002: } else if (flags & EXPOSE) {
2003: number = eventPtr->xexpose.y;
2004: } else if (flags & (CREATE|CONFIG|GRAVITY|CONFIG_REQ)) {
2005: number = eventPtr->xcreatewindow.y;
2006: } else if (flags & REPARENT) {
2007: number = eventPtr->xreparent.y;
2008: } else if (flags & CROSSING) {
2009: number = eventPtr->xcrossing.y;
2010:
2011: }
2012: goto doNumber;
2013: case 'A':
2014: if ((eventPtr->type == KeyPress)
2015: || (eventPtr->type == KeyRelease)) {
2016: int numChars;
2017:
2018: numChars = XLookupString(&eventPtr->xkey, numStorage,
2019: NUM_SIZE, (KeySym *) NULL,
2020: (XComposeStatus *) NULL);
2021: numStorage[numChars] = '\0';
2022: string = numStorage;
2023: }
2024: goto doString;
2025: case 'B':
2026: number = eventPtr->xcreatewindow.border_width;
2027: goto doNumber;
2028: case 'D':
2029: number = (int) eventPtr->xany.display;
2030: goto doNumber;
2031: case 'E':
2032: number = (int) eventPtr->xany.send_event;
2033: goto doNumber;
2034: case 'K':
2035: if ((eventPtr->type == KeyPress)
2036: || (eventPtr->type == KeyRelease)) {
2037: register KeySymInfo *kPtr;
2038:
2039: for (kPtr = keyArray; kPtr->name != NULL; kPtr++) {
2040: if (kPtr->value == keySym) {
2041: string = kPtr->name;
2042: break;
2043: }
2044: }
2045: }
2046: goto doString;
2047: case 'N':
2048: number = (int) keySym;
2049: goto doNumber;
2050: case 'R':
2051: number = (int) eventPtr->xkey.root;
2052: goto doNumber;
2053: case 'S':
2054: number = (int) eventPtr->xkey.subwindow;
2055: goto doNumber;
2056: case 'T':
2057: number = eventPtr->type;
2058: goto doNumber;
2059: case 'W': {
2060: TkWindow *winPtr;
2061:
2062: if (XFindContext(eventPtr->xany.display, eventPtr->xany.window,
2063: tkWindowContext, (void *) &winPtr) == 0) {
2064: string = winPtr->pathName;
2065: } else {
2066: string = "??";
2067: }
2068: goto doString;
2069: }
2070: case 'X':
2071: number = eventPtr->xkey.x_root;
2072: goto doNumber;
2073: case 'Y':
2074: number = eventPtr->xkey.y_root;
2075: goto doNumber;
2076: default:
2077: numStorage[0] = before[1];
2078: numStorage[1] = '\0';
2079: string = numStorage;
2080: goto doString;
2081: }
2082:
2083: doNumber:
2084: sprintf(numStorage, "%d", number);
2085: string = numStorage;
2086:
2087: doString:
2088: spaceNeeded = Tcl_ScanElement(string, &cvtFlags);
2089: if (spaceNeeded >= spaceLeft) {
2090: char *newSpace;
2091:
2092: newSpace = (char *) ckalloc((unsigned)
2093: (afterSize + spaceNeeded + 50));
2094: memcpy((VOID *) newSpace, (VOID *) buffer, afterSize);
2095: afterSize += spaceNeeded + 50;
2096: dst = newSpace + (dst - buffer);
2097: if (buffer != after) {
2098: ckfree(buffer);
2099: }
2100: buffer = newSpace;
2101: spaceLeft = afterSize - (dst-buffer) - 1;
2102: }
2103: spaceNeeded = Tcl_ConvertElement(string, dst,
2104: cvtFlags | TCL_DONT_USE_BRACES);
2105: dst += spaceNeeded;
2106: spaceLeft -= spaceNeeded;
2107: before += 2;
2108: }
2109: *dst = '\0';
2110: return buffer;
2111: }
2112:
2113: /*
2114: *----------------------------------------------------------------------
2115: *
2116: * TkBindError --
2117: *
2118: * This procedure is invoked to handle errors that occur in Tcl
2119: * commands that are invoked in "background" (e.g. from event or
2120: * timer bindings).
2121: *
2122: * Results:
2123: * None.
2124: *
2125: * Side effects:
2126: * The command "tkerror" is invoked to process the error, passing
2127: * it the error message. If that fails, then an error message
2128: * is output on stderr.
2129: *
2130: *----------------------------------------------------------------------
2131: */
2132:
2133: void
2134: TkBindError(interp)
2135: Tcl_Interp *interp; /* Interpreter in which an error has
2136: * occurred. */
2137: {
2138: char *argv[2];
2139: char *command;
2140: char *error;
2141: char *errorInfo, *tmp;
2142: int result;
2143:
2144: error = (char *) ckalloc((unsigned) (strlen(interp->result) + 1));
2145: strcpy(error, interp->result);
2146: tmp = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
2147: if (tmp == NULL) {
2148: errorInfo = error;
2149: } else {
2150: errorInfo = (char *) ckalloc((unsigned) (strlen(tmp) + 1));
2151: strcpy(errorInfo, tmp);
2152: }
2153: argv[0] = "tkerror";
2154: argv[1] = error;
2155: command = Tcl_Merge(2, argv);
2156: result = Tcl_GlobalEval(interp, command);
2157: if (result != TCL_OK) {
2158: if (strcmp(interp->result, "\"tkerror\" is an invalid command name or ambiguous abbreviation") == 0) {
2159: fprintf(stderr, "%s\n", errorInfo);
2160: } else {
2161: fprintf(stderr, "tkerror failed to handle background error.\n");
2162: fprintf(stderr, " Original error: %s\n", error);
2163: fprintf(stderr, " Error in tkerror: %s\n", interp->result);
2164: }
2165: }
2166: Tcl_ResetResult(interp);
2167: ckfree(command);
2168: ckfree(error);
2169: if (errorInfo != error) {
2170: ckfree(errorInfo);
2171: }
2172: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.