diff options
Diffstat (limited to 'generic/tkEvent.c')
| -rw-r--r-- | generic/tkEvent.c | 2008 |
1 files changed, 1327 insertions, 681 deletions
diff --git a/generic/tkEvent.c b/generic/tkEvent.c index 2b4943f..03e7283 100644 --- a/generic/tkEvent.c +++ b/generic/tkEvent.c @@ -1,69 +1,67 @@ -/* +/* * tkEvent.c -- * - * This file provides basic low-level facilities for managing - * X events in Tk. + * This file provides basic low-level facilities for managing X events in + * Tk. * * Copyright (c) 1990-1994 The Regents of the University of California. * Copyright (c) 1994-1995 Sun Microsystems, Inc. * Copyright (c) 1998-2000 Ajuba Solutions. + * Copyright (c) 2004 George Peter Staplin * - * See the file "license.terms" for information on usage and redistribution - * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ -#include "tkPort.h" #include "tkInt.h" -#include <signal.h> /* - * There's a potential problem if a handler is deleted while it's - * current (i.e. its procedure is executing), since Tk_HandleEvent - * will need to read the handler's "nextPtr" field when the procedure - * returns. To handle this problem, structures of the type below - * indicate the next handler to be processed for any (recursively - * nested) dispatches in progress. The nextHandler fields get - * updated if the handlers pointed to are deleted. Tk_HandleEvent - * also needs to know if the entire window gets deleted; the winPtr - * field is set to zero if that particular window gets deleted. + * There's a potential problem if a handler is deleted while it's current + * (i.e. its function is executing), since Tk_HandleEvent will need to read + * the handler's "nextPtr" field when the function returns. To handle this + * problem, structures of the type below indicate the next handler to be + * processed for any (recursively nested) dispatches in progress. The + * nextHandler fields get updated if the handlers pointed to are deleted. + * Tk_HandleEvent also needs to know if the entire window gets deleted; the + * winPtr field is set to zero if that particular window gets deleted. */ typedef struct InProgress { - XEvent *eventPtr; /* Event currently being handled. */ - TkWindow *winPtr; /* Window for event. Gets set to None if - * window is deleted while event is being - * handled. */ - TkEventHandler *nextHandler; /* Next handler in search. */ - struct InProgress *nextPtr; /* Next higher nested search. */ + XEvent *eventPtr; /* Event currently being handled. */ + TkWindow *winPtr; /* Window for event. Gets set to None if + * window is deleted while event is being + * handled. */ + TkEventHandler *nextHandler;/* Next handler in search. */ + struct InProgress *nextPtr; /* Next higher nested search. */ } InProgress; /* - * For each call to Tk_CreateGenericHandler, an instance of the following - * structure will be created. All of the active handlers are linked into a - * list. + * For each call to Tk_CreateGenericHandler or Tk_CreateClientMessageHandler, + * an instance of the following structure will be created. All of the active + * handlers are linked into a list. */ typedef struct GenericHandler { - Tk_GenericProc *proc; /* Procedure to dispatch on all X events. */ - ClientData clientData; /* Client data to pass to procedure. */ - int deleteFlag; /* Flag to set when this handler is deleted. */ + Tk_GenericProc *proc; /* Function to dispatch on all X events. */ + ClientData clientData; /* Client data to pass to function. */ + int deleteFlag; /* Flag to set when this handler is + * deleted. */ struct GenericHandler *nextPtr; /* Next handler in list of all generic * handlers, or NULL for end of list. */ } GenericHandler; /* - * There's a potential problem if Tk_HandleEvent is entered recursively. - * A handler cannot be deleted physically until we have returned from - * calling it. Otherwise, we're looking at unallocated memory in advancing to - * its `next' entry. We deal with the problem by using the `delete flag' and + * There's a potential problem if Tk_HandleEvent is entered recursively. A + * handler cannot be deleted physically until we have returned from calling + * it. Otherwise, we're looking at unallocated memory in advancing to its + * `next' entry. We deal with the problem by using the `delete flag' and * deleting handlers only when it's known that there's no handler active. - * */ /* - * The following structure is used for queueing X-style events on the - * Tcl event queue. + * The following structure is used for queueing X-style events on the Tcl + * event queue. */ typedef struct TkWindowEvent { @@ -75,7 +73,7 @@ typedef struct TkWindowEvent { * Array of event masks corresponding to each X event: */ -static unsigned long eventMasks[TK_LASTEVENT] = { +static unsigned long realEventMasks[MappingNotify+1] = { 0, 0, KeyPressMask, /* KeyPress */ @@ -113,106 +111,694 @@ static unsigned long eventMasks[TK_LASTEVENT] = { 0, /* SelectionNotify */ ColormapChangeMask, /* ColormapNotify */ 0, /* ClientMessage */ - 0, /* Mapping Notify */ + 0 /* Mapping Notify */ +}; + +static unsigned long virtualEventMasks[TK_LASTEVENT-VirtualEvent] = { VirtualEventMask, /* VirtualEvents */ ActivateMask, /* ActivateNotify */ ActivateMask, /* DeactivateNotify */ MouseWheelMask /* MouseWheelEvent */ }; +/* + * For each exit handler created with a call to TkCreateExitHandler or + * TkCreateThreadExitHandler there is a structure of the following type: + */ + +typedef struct ExitHandler { + Tcl_ExitProc *proc; /* Function to call when process exits. */ + ClientData clientData; /* One word of information to pass to proc. */ + struct ExitHandler *nextPtr;/* Next in list of all exit handlers for this + * application, or NULL for end of list. */ +} ExitHandler; /* - * The structure below is used to store Data for the Event module that - * must be kept thread-local. The "dataKey" is used to fetch the - * thread-specific storage for the current thread. + * The structure below is used to store Data for the Event module that must be + * kept thread-local. The "dataKey" is used to fetch the thread-specific + * storage for the current thread. */ typedef struct ThreadSpecificData { - int handlersActive; /* The following variable has a non-zero - * value when a handler is active. */ - InProgress *pendingPtr; /* Topmost search in progress, or - * NULL if none. */ + int handlersActive; /* The following variable has a non-zero value + * when a handler is active. */ + InProgress *pendingPtr; /* Topmost search in progress, or NULL if + * none. */ + + /* + * List of generic handler records. + */ + + GenericHandler *genericList;/* First handler in the list, or NULL. */ + GenericHandler *lastGenericPtr; + /* Last handler in list. */ - GenericHandler *genericList; /* First handler in the list, or NULL. */ - GenericHandler *lastGenericPtr; /* Last handler in list. */ + /* + * List of client message handler records. + */ - GenericHandler *cmList; /* First handler in the list, or NULL. */ + GenericHandler *cmList; /* First handler in the list, or NULL. */ GenericHandler *lastCmPtr; /* Last handler in list. */ /* - * If someone has called Tk_RestrictEvents, the information below - * keeps track of it. + * If someone has called Tk_RestrictEvents, the information below keeps + * track of it. */ Tk_RestrictProc *restrictProc; - /* Procedure to call. NULL means no + /* Function to call. NULL means no * restrictProc is currently in effect. */ ClientData restrictArg; /* Argument to pass to restrictProc. */ + ExitHandler *firstExitPtr; /* First in list of all exit handlers for this + * thread. */ + int inExit; /* True when this thread is exiting. This is + * used as a hack to decide to close the + * standard channels. */ } ThreadSpecificData; static Tcl_ThreadDataKey dataKey; /* - * Prototypes for procedures that are only referenced locally within - * this file. + * There are both per-process and per-thread exit handlers. The first list is + * controlled by a mutex. The other is in thread local storage. + */ + +static ExitHandler *firstExitPtr = NULL; + /* First in list of all exit handlers for + * application. */ +TCL_DECLARE_MUTEX(exitMutex) + +/* + * Prototypes for functions that are only referenced locally within this file. + */ + +static void CleanUpTkEvent(XEvent *eventPtr); +static void DelayedMotionProc(ClientData clientData); +static int GetButtonMask(unsigned int Button); +static unsigned long GetEventMaskFromXEvent(XEvent *eventPtr); +static TkWindow * GetTkWindowFromXEvent(XEvent *eventPtr); +static void InvokeClientMessageHandlers(ThreadSpecificData *tsdPtr, + Tk_Window tkwin, XEvent *eventPtr); +static int InvokeFocusHandlers(TkWindow **winPtrPtr, + unsigned long mask, XEvent *eventPtr); +static int InvokeGenericHandlers(ThreadSpecificData *tsdPtr, + XEvent *eventPtr); +static int InvokeMouseHandlers(TkWindow *winPtr, + unsigned long mask, XEvent *eventPtr); +static Window ParentXId(Display *display, Window w); +static int RefreshKeyboardMappingIfNeeded(XEvent *eventPtr); +static int TkXErrorHandler(ClientData clientData, + XErrorEvent *errEventPtr); +static void UpdateButtonEventState(XEvent *eventPtr); +static int WindowEventProc(Tcl_Event *evPtr, int flags); +#ifdef TK_USE_INPUT_METHODS +static void CreateXIC(TkWindow *winPtr); +#endif /* TK_USE_INPUT_METHODS */ + +/* + *---------------------------------------------------------------------- + * + * InvokeFocusHandlers -- + * + * Call focus-related code to look at FocusIn, FocusOut, Enter, and Leave + * events; depending on its return value, ignore the event. + * + * Results: + * 0 further processing can be done on the event. + * 1 we are done with the event passed. + * + * Side effects: + * The *winPtrPtr in the caller may be changed to the TkWindow for the + * window with focus. + * + *---------------------------------------------------------------------- + */ + +static int +InvokeFocusHandlers( + TkWindow **winPtrPtr, + unsigned long mask, + XEvent *eventPtr) +{ + if ((mask & (FocusChangeMask|EnterWindowMask|LeaveWindowMask)) + && (TkFocusFilterEvent(*winPtrPtr, eventPtr) == 0)) { + return 1; + } + + /* + * MouseWheel events are not focus specific on Mac OS X. + */ + +#ifdef MAC_OSX_TK +#define FOCUS_DIRECTED_EVENT_MASK (KeyPressMask|KeyReleaseMask) +#else +#define FOCUS_DIRECTED_EVENT_MASK (KeyPressMask|KeyReleaseMask|MouseWheelMask) +#endif + + if (mask & FOCUS_DIRECTED_EVENT_MASK) { + (*winPtrPtr)->dispPtr->lastEventTime = eventPtr->xkey.time; + *winPtrPtr = TkFocusKeyEvent(*winPtrPtr, eventPtr); + if (*winPtrPtr == NULL) { + return 1; + } + } + + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * InvokeMouseHandlers -- + * + * Call a grab-related function to do special processing on pointer + * events. + * + * Results: + * 0 further processing can be done on the event. + * 1 we are done with the event passed. + * + * Side effects: + * New events may be queued from TkPointerEvent and grabs may be added + * and/or removed. The eventPtr may be changed by TkPointerEvent in some + * cases. + * + *---------------------------------------------------------------------- + */ + +static int +InvokeMouseHandlers( + TkWindow *winPtr, + unsigned long mask, + XEvent *eventPtr) +{ + if (mask & (ButtonPressMask|ButtonReleaseMask|PointerMotionMask + |EnterWindowMask|LeaveWindowMask)) { + + if (mask & (ButtonPressMask|ButtonReleaseMask)) { + winPtr->dispPtr->lastEventTime = eventPtr->xbutton.time; + } else if (mask & PointerMotionMask) { + winPtr->dispPtr->lastEventTime = eventPtr->xmotion.time; + } else { + winPtr->dispPtr->lastEventTime = eventPtr->xcrossing.time; + } + + if (TkPointerEvent(eventPtr, winPtr) == 0) { + /* + * The event should be ignored to make grab work correctly (as the + * comment for TkPointerEvent states). + */ + + return 1; + } + } + + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * CreateXIC -- + * + * Create the X input context for our winPtr. + * XIM is only ever enabled on Unix. + * + *---------------------------------------------------------------------- + */ + +#if defined(TK_USE_INPUT_METHODS) +static void +CreateXIC( + TkWindow *winPtr) +{ + TkDisplay *dispPtr = winPtr->dispPtr; + long im_event_mask = 0L; + const char *preedit_attname = NULL; + XVaNestedList preedit_attlist = NULL; + + if (dispPtr->inputStyle & XIMPreeditPosition) { + XPoint spot = {0, 0}; + + preedit_attname = XNPreeditAttributes; + preedit_attlist = XVaCreateNestedList(0, + XNSpotLocation, &spot, + XNFontSet, dispPtr->inputXfs, + NULL); + } + + winPtr->inputContext = XCreateIC(dispPtr->inputMethod, + XNInputStyle, dispPtr->inputStyle, + XNClientWindow, winPtr->window, + XNFocusWindow, winPtr->window, + preedit_attname, preedit_attlist, + NULL); + + if (preedit_attlist) { + XFree(preedit_attlist); + } + + + if (winPtr->inputContext == NULL) { + /* XCreateIC failed. */ + return; + } + + /* + * Adjust the window's event mask if the IM requires it. + */ + XGetICValues(winPtr->inputContext, XNFilterEvents, &im_event_mask, NULL); + if ((winPtr->atts.event_mask & im_event_mask) != im_event_mask) { + winPtr->atts.event_mask |= im_event_mask; + XSelectInput(winPtr->display, winPtr->window, winPtr->atts.event_mask); + } +} +#endif + +/* + *---------------------------------------------------------------------- + * + * GetTkWindowFromXEvent -- + * + * Attempt to find which TkWindow is associated with an event. If it + * fails we attempt to get the TkWindow from the parent for a property + * notification. + * + * Results: + * The TkWindow associated with the event or NULL. + * + * Side effects: + * TkSelPropProc may influence selection on windows not known to Tk. + * + *---------------------------------------------------------------------- + */ + +static TkWindow * +GetTkWindowFromXEvent( + XEvent *eventPtr) +{ + TkWindow *winPtr; + Window parentXId, handlerWindow = eventPtr->xany.window; + + if ((eventPtr->xany.type == StructureNotifyMask) + && (eventPtr->xmap.event != eventPtr->xmap.window)) { + handlerWindow = eventPtr->xmap.event; + } + + winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, handlerWindow); + + if (winPtr == NULL) { + /* + * There isn't a TkWindow structure for this window. However, if the + * event is a PropertyNotify event then call the selection manager (it + * deals beneath-the-table with certain properties). Also, if the + * window's parent is a Tk window that has the TK_PROP_PROPCHANGE flag + * set, then we must propagate the PropertyNotify event up to the + * parent. + */ + + if (eventPtr->type != PropertyNotify) { + return NULL; + } + TkSelPropProc(eventPtr); + parentXId = ParentXId(eventPtr->xany.display, handlerWindow); + if (parentXId == None) { + return NULL; + } + winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, parentXId); + if (winPtr == NULL) { + return NULL; + } + if (!(winPtr->flags & TK_PROP_PROPCHANGE)) { + return NULL; + } + } + return winPtr; +} + +/* + *---------------------------------------------------------------------- + * + * GetEventMaskFromXEvent -- + * + * The event type is looked up in our eventMasks tables, and may be + * changed to a different mask depending on the state of the event and + * window members. + * + * Results: + * The mask for the event. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static unsigned long +GetEventMaskFromXEvent( + XEvent *eventPtr) +{ + unsigned long mask; + + /* + * Get the event mask from the correct table. Note that there are two + * tables here because that means we no longer need this code to rely on + * the exact value of VirtualEvent, which has caused us problems in the + * past when X11 changed the value of LASTEvent. [Bug ???] + */ + + if (eventPtr->xany.type <= MappingNotify) { + mask = realEventMasks[eventPtr->xany.type]; + } else if (eventPtr->xany.type >= VirtualEvent + && eventPtr->xany.type<TK_LASTEVENT) { + mask = virtualEventMasks[eventPtr->xany.type - VirtualEvent]; + } else { + mask = 0; + } + + /* + * Events selected by StructureNotify require special handling. They look + * the same as those selected by SubstructureNotify. The only difference + * is whether the "event" and "window" fields are the same. Compare the + * two fields and convert StructureNotify to SubstructureNotify if + * necessary. + */ + + if (mask == StructureNotifyMask) { + if (eventPtr->xmap.event != eventPtr->xmap.window) { + mask = SubstructureNotifyMask; + } + } + return mask; +} + +/* + *---------------------------------------------------------------------- + * + * RefreshKeyboardMappingIfNeeded -- + * + * If the event is a MappingNotify event, find its display and refresh + * the keyboard mapping information for the display. + * + * Results: + * 0 if the event was not a MappingNotify event + * 1 if the event was a MappingNotify event + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +RefreshKeyboardMappingIfNeeded( + XEvent *eventPtr) +{ + TkDisplay *dispPtr; + + if (eventPtr->type == MappingNotify) { + dispPtr = TkGetDisplay(eventPtr->xmapping.display); + if (dispPtr != NULL) { + XRefreshKeyboardMapping(&eventPtr->xmapping); + dispPtr->bindInfoStale = 1; + } + return 1; + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * GetButtonMask -- + * + * Return the proper Button${n}Mask for the button. + * + * Results: + * A button mask. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +GetButtonMask( + unsigned int button) +{ + switch (button) { + case 1: + return Button1Mask; + case 2: + return Button2Mask; + case 3: + return Button3Mask; + case 4: + return Button4Mask; + case 5: + return Button5Mask; + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * UpdateButtonEventState -- + * + * Update the button event state in our TkDisplay using the XEvent + * passed. We also may modify the the XEvent passed to fit some aspects + * of our TkDisplay. + * + * Results: + * None. + * + * Side effects: + * The TkDisplay's private button state may be modified. The eventPtr's + * state may be updated to reflect masks stored in our TkDisplay that the + * event doesn't contain. The eventPtr may also be modified to not + * contain a button state for the window in which it was not pressed in. + * + *---------------------------------------------------------------------- */ -static void DelayedMotionProc _ANSI_ARGS_((ClientData clientData)); -static int WindowEventProc _ANSI_ARGS_((Tcl_Event *evPtr, - int flags)); -static int TkXErrorHandler _ANSI_ARGS_((ClientData clientData, - XErrorEvent *errEventPtr)); +static void +UpdateButtonEventState( + XEvent *eventPtr) +{ + TkDisplay *dispPtr; + int allButtonsMask = Button1Mask | Button2Mask | Button3Mask + | Button4Mask | Button5Mask; + switch (eventPtr->type) { + case ButtonPress: + dispPtr = TkGetDisplay(eventPtr->xbutton.display); + dispPtr->mouseButtonWindow = eventPtr->xbutton.window; + eventPtr->xbutton.state |= dispPtr->mouseButtonState; + + dispPtr->mouseButtonState |= GetButtonMask(eventPtr->xbutton.button); + break; + + case ButtonRelease: + dispPtr = TkGetDisplay(eventPtr->xbutton.display); + dispPtr->mouseButtonWindow = None; + dispPtr->mouseButtonState &= ~GetButtonMask(eventPtr->xbutton.button); + eventPtr->xbutton.state |= dispPtr->mouseButtonState; + break; + + case MotionNotify: + dispPtr = TkGetDisplay(eventPtr->xmotion.display); + if (dispPtr->mouseButtonState & allButtonsMask) { + if (eventPtr->xbutton.window != dispPtr->mouseButtonWindow) { + /* + * This motion event should not be interpreted as a button + * press + motion event since this is not the same window the + * button was pressed down in. + */ + + dispPtr->mouseButtonState &= ~allButtonsMask; + dispPtr->mouseButtonWindow = None; + } else { + eventPtr->xmotion.state |= dispPtr->mouseButtonState; + } + } + break; + } +} /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- + * + * InvokeClientMessageHandlers -- + * + * Iterate the list of handlers and invoke the function pointer for each. + * + * Results: + * None. + * + * Side effects: + * Handlers may be deleted and events may be sent to handlers. + * + *---------------------------------------------------------------------- + */ + +static void +InvokeClientMessageHandlers( + ThreadSpecificData *tsdPtr, + Tk_Window tkwin, + XEvent *eventPtr) +{ + GenericHandler *prevPtr, *tmpPtr, *curPtr = tsdPtr->cmList; + + for (prevPtr = NULL; curPtr != NULL; ) { + if (curPtr->deleteFlag) { + if (!tsdPtr->handlersActive) { + /* + * This handler needs to be deleted and there are no calls + * pending through any handlers, so now is a safe time to + * delete it. + */ + + tmpPtr = curPtr->nextPtr; + if (prevPtr == NULL) { + tsdPtr->cmList = tmpPtr; + } else { + prevPtr->nextPtr = tmpPtr; + } + if (tmpPtr == NULL) { + tsdPtr->lastCmPtr = prevPtr; + } + (void) ckfree((char *) curPtr); + curPtr = tmpPtr; + continue; + } + } else { + int done; + + tsdPtr->handlersActive++; + done = (*(Tk_ClientMessageProc *)curPtr->proc)(tkwin, eventPtr); + tsdPtr->handlersActive--; + if (done) { + break; + } + } + prevPtr = curPtr; + curPtr = curPtr->nextPtr; + } +} + +/* + *---------------------------------------------------------------------- + * + * InvokeGenericHandlers -- + * + * Iterate the list of handlers and invoke the function pointer for each. + * If the handler invoked returns a non-zero value then we are done. + * + * Results: + * 0 when the event wasn't handled by a handler. Non-zero when it was + * processed and handled by a handler. + * + * Side effects: + * Handlers may be deleted and events may be sent to handlers. + * + *---------------------------------------------------------------------- + */ + +static int +InvokeGenericHandlers( + ThreadSpecificData *tsdPtr, + XEvent *eventPtr) +{ + GenericHandler *prevPtr, *tmpPtr, *curPtr = tsdPtr->genericList; + + for (prevPtr = NULL; curPtr != NULL; ) { + if (curPtr->deleteFlag) { + if (!tsdPtr->handlersActive) { + /* + * This handler needs to be deleted and there are no calls + * pending through the handler, so now is a safe time to + * delete it. + */ + + tmpPtr = curPtr->nextPtr; + if (prevPtr == NULL) { + tsdPtr->genericList = tmpPtr; + } else { + prevPtr->nextPtr = tmpPtr; + } + if (tmpPtr == NULL) { + tsdPtr->lastGenericPtr = prevPtr; + } + (void) ckfree((char *) curPtr); + curPtr = tmpPtr; + continue; + } + } else { + int done; + + tsdPtr->handlersActive++; + done = (*curPtr->proc)(curPtr->clientData, eventPtr); + tsdPtr->handlersActive--; + if (done) { + return done; + } + } + prevPtr = curPtr; + curPtr = curPtr->nextPtr; + } + return 0; +} + +/* + *---------------------------------------------------------------------- * * Tk_CreateEventHandler -- * - * Arrange for a given procedure to be invoked whenever - * events from a given class occur in a given window. + * Arrange for a given function to be invoked whenever events from a + * given class occur in a given window. * * Results: * None. * * Side effects: - * From now on, whenever an event of the type given by - * mask occurs for token and is processed by Tk_HandleEvent, - * proc will be called. See the manual entry for details - * of the calling sequence and return value for proc. + * From now on, whenever an event of the type given by mask occurs for + * token and is processed by Tk_HandleEvent, proc will be called. See the + * manual entry for details of the calling sequence and return value for + * proc. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_CreateEventHandler(token, mask, proc, clientData) - Tk_Window token; /* Token for window in which to - * create handler. */ - unsigned long mask; /* Events for which proc should - * be called. */ - Tk_EventProc *proc; /* Procedure to call for each - * selected event */ - ClientData clientData; /* Arbitrary data to pass to proc. */ +Tk_CreateEventHandler( + Tk_Window token, /* Token for window in which to create + * handler. */ + unsigned long mask, /* Events for which proc should be called. */ + Tk_EventProc *proc, /* Function to call for each selected event */ + ClientData clientData) /* Arbitrary data to pass to proc. */ { register TkEventHandler *handlerPtr; register TkWindow *winPtr = (TkWindow *) token; - int found; /* - * Skim through the list of existing handlers to (a) compute the - * overall event mask for the window (so we can pass this new - * value to the X system) and (b) see if there's already a handler - * declared with the same callback and clientData (if so, just - * change the mask). If no existing handler matches, then create - * a new handler. + * Skim through the list of existing handlers to (a) compute the overall + * event mask for the window (so we can pass this new value to the X + * system) and (b) see if there's already a handler declared with the same + * callback and clientData (if so, just change the mask). If no existing + * handler matches, then create a new handler. */ - found = 0; if (winPtr->handlerList == NULL) { - handlerPtr = (TkEventHandler *) ckalloc( - (unsigned) sizeof(TkEventHandler)); + /* + * No event handlers defined at all, so must create. + */ + + handlerPtr = (TkEventHandler *) ckalloc(sizeof(TkEventHandler)); winPtr->handlerList = handlerPtr; - goto initHandler; } else { + int found = 0; + for (handlerPtr = winPtr->handlerList; ; handlerPtr = handlerPtr->nextPtr) { if ((handlerPtr->proc == proc) @@ -224,31 +810,43 @@ Tk_CreateEventHandler(token, mask, proc, clientData) break; } } - } - /* - * Create a new handler if no matching old handler was found. - */ + /* + * If we found anything, we're done because we do not need to use + * XSelectInput; Tk always selects on all events anyway in order to + * support binding on classes, 'all' and other bind-tags. + */ + + if (found) { + return; + } + + /* + * No event handler matched, so create a new one. + */ - if (!found) { handlerPtr->nextPtr = (TkEventHandler *) ckalloc(sizeof(TkEventHandler)); handlerPtr = handlerPtr->nextPtr; - initHandler: - handlerPtr->mask = mask; - handlerPtr->proc = proc; - handlerPtr->clientData = clientData; - handlerPtr->nextPtr = NULL; } /* - * No need to call XSelectInput: Tk always selects on all events - * for all windows (needed to support bindings on classes and "all"). + * Initialize the new event handler. + */ + + handlerPtr->mask = mask; + handlerPtr->proc = proc; + handlerPtr->clientData = clientData; + handlerPtr->nextPtr = NULL; + + /* + * No need to call XSelectInput: Tk always selects on all events for all + * windows (needed to support bindings on classes and "all"). */ } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * Tk_DeleteEventHandler -- * @@ -258,30 +856,29 @@ Tk_CreateEventHandler(token, mask, proc, clientData) * None. * * Side effects: - * If there existed a handler as described by the - * parameters, the handler is deleted so that proc - * will not be invoked again. + * If there existed a handler as described by the parameters, the handler + * is deleted so that proc will not be invoked again. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_DeleteEventHandler(token, mask, proc, clientData) - Tk_Window token; /* Same as corresponding arguments passed */ - unsigned long mask; /* previously to Tk_CreateEventHandler. */ - Tk_EventProc *proc; - ClientData clientData; +Tk_DeleteEventHandler( + Tk_Window token, /* Same as corresponding arguments passed */ + unsigned long mask, /* previously to Tk_CreateEventHandler. */ + Tk_EventProc *proc, + ClientData clientData) { register TkEventHandler *handlerPtr; register InProgress *ipPtr; TkEventHandler *prevPtr; register TkWindow *winPtr = (TkWindow *) token; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); /* - * Find the event handler to be deleted, or return - * immediately if it doesn't exist. + * Find the event handler to be deleted, or return immediately if it + * doesn't exist. */ for (handlerPtr = winPtr->handlerList, prevPtr = NULL; ; @@ -296,8 +893,8 @@ Tk_DeleteEventHandler(token, mask, proc, clientData) } /* - * If Tk_HandleEvent is about to process this handler, tell it to - * process the next one instead. + * If Tk_HandleEvent is about to process this handler, tell it to process + * the next one instead. */ for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { @@ -317,43 +914,42 @@ Tk_DeleteEventHandler(token, mask, proc, clientData) } ckfree((char *) handlerPtr); - /* - * No need to call XSelectInput: Tk always selects on all events - * for all windows (needed to support bindings on classes and "all"). + * No need to call XSelectInput: Tk always selects on all events for all + * windows (needed to support bindings on classes and "all"). */ } -/*-------------------------------------------------------------- +/*---------------------------------------------------------------------- * * Tk_CreateGenericHandler -- * - * Register a procedure to be called on each X event, regardless - * of display or window. Generic handlers are useful for capturing - * events that aren't associated with windows, or events for windows - * not managed by Tk. + * Register a function to be called on each X event, regardless of + * display or window. Generic handlers are useful for capturing events + * that aren't associated with windows, or events for windows not managed + * by Tk. * * Results: * None. * * Side Effects: - * From now on, whenever an X event is given to Tk_HandleEvent, - * invoke proc, giving it clientData and the event as arguments. + * From now on, whenever an X event is given to Tk_HandleEvent, invoke + * proc, giving it clientData and the event as arguments. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_CreateGenericHandler(proc, clientData) - Tk_GenericProc *proc; /* Procedure to call on every event. */ - ClientData clientData; /* One-word value to pass to proc. */ +Tk_CreateGenericHandler( + Tk_GenericProc *proc, /* Function to call on every event. */ + ClientData clientData) /* One-word value to pass to proc. */ { GenericHandler *handlerPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - handlerPtr = (GenericHandler *) ckalloc (sizeof (GenericHandler)); - + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + + handlerPtr = (GenericHandler *) ckalloc(sizeof(GenericHandler)); + handlerPtr->proc = proc; handlerPtr->clientData = clientData; handlerPtr->deleteFlag = 0; @@ -367,7 +963,7 @@ Tk_CreateGenericHandler(proc, clientData) } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * Tk_DeleteGenericHandler -- * @@ -377,77 +973,76 @@ Tk_CreateGenericHandler(proc, clientData) * None. * * Side Effects: - * If there existed a handler as described by the parameters, - * that handler is logically deleted so that proc will not be - * invoked again. The physical deletion happens in the event - * loop in Tk_HandleEvent. + * If there existed a handler as described by the parameters, that + * handler is logically deleted so that proc will not be invoked again. + * The physical deletion happens in the event loop in Tk_HandleEvent. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_DeleteGenericHandler(proc, clientData) - Tk_GenericProc *proc; - ClientData clientData; +Tk_DeleteGenericHandler( + Tk_GenericProc *proc, + ClientData clientData) { GenericHandler * handler; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - for (handler = tsdPtr->genericList; handler; handler = handler->nextPtr) { + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + + for (handler=tsdPtr->genericList ; handler ; handler=handler->nextPtr) { if ((handler->proc == proc) && (handler->clientData == clientData)) { handler->deleteFlag = 1; } } } -/*-------------------------------------------------------------- +/*---------------------------------------------------------------------- * * Tk_CreateClientMessageHandler -- * - * Register a procedure to be called on each ClientMessage event. + * Register a function to be called on each ClientMessage event. * ClientMessage handlers are useful for Drag&Drop extensions. * * Results: * None. * * Side Effects: - * From now on, whenever a ClientMessage event is received that isn't - * a WM_PROTOCOL event or SelectionEvent, invoke proc, giving it - * tkwin and the event as arguments. + * From now on, whenever a ClientMessage event is received that isn't a + * WM_PROTOCOL event or SelectionEvent, invoke proc, giving it tkwin and + * the event as arguments. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_CreateClientMessageHandler(proc) - Tk_ClientMessageProc *proc; /* Procedure to call on event. */ +Tk_CreateClientMessageHandler( + Tk_ClientMessageProc *proc) /* Function to call on event. */ { GenericHandler *handlerPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); /* - * We use a GenericHandler struct, because it's basically the same, - * except with an extra clientData field we'll never use. + * We use a GenericHandler struct, because it's basically the same, except + * with an extra clientData field we'll never use. */ - handlerPtr = (GenericHandler *) - ckalloc (sizeof (GenericHandler)); - handlerPtr->proc = (Tk_GenericProc *) proc; - handlerPtr->clientData = NULL; /* never used */ - handlerPtr->deleteFlag = 0; - handlerPtr->nextPtr = NULL; + handlerPtr = (GenericHandler *) ckalloc(sizeof(GenericHandler)); + + handlerPtr->proc = (Tk_GenericProc *) proc; + handlerPtr->clientData = NULL; /* never used */ + handlerPtr->deleteFlag = 0; + handlerPtr->nextPtr = NULL; if (tsdPtr->cmList == NULL) { - tsdPtr->cmList = handlerPtr; + tsdPtr->cmList = handlerPtr; } else { tsdPtr->lastCmPtr->nextPtr = handlerPtr; } - tsdPtr->lastCmPtr = handlerPtr; + tsdPtr->lastCmPtr = handlerPtr; } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * Tk_DeleteClientMessageHandler -- * @@ -457,24 +1052,23 @@ Tk_CreateClientMessageHandler(proc) * None. * * Side Effects: - * If there existed a handler as described by the parameters, - * that handler is logically deleted so that proc will not be - * invoked again. The physical deletion happens in the event - * loop in TkClientMessageEventProc. + * If there existed a handler as described by the parameters, that + * handler is logically deleted so that proc will not be invoked again. + * The physical deletion happens in the event loop in + * TkClientMessageEventProc. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_DeleteClientMessageHandler(proc) - Tk_ClientMessageProc *proc; +Tk_DeleteClientMessageHandler( + Tk_ClientMessageProc *proc) { GenericHandler * handler; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - for (handler = tsdPtr->cmList; handler != NULL; - handler = handler->nextPtr) { + for (handler=tsdPtr->cmList ; handler!=NULL ; handler=handler->nextPtr) { if (handler->proc == (Tk_GenericProc *) proc) { handler->deleteFlag = 1; } @@ -482,14 +1076,13 @@ Tk_DeleteClientMessageHandler(proc) } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * TkEventInit -- * - * This procedures initializes all the event module - * structures used by the current thread. It must be - * called before any other procedure in this file is - * called. + * This functions initializes all the event module structures used by the + * current thread. It must be called before any other function in this + * file is called. * * Results: * None. @@ -497,14 +1090,14 @@ Tk_DeleteClientMessageHandler(proc) * Side Effects: * None. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -TkEventInit _ANSI_ARGS_((void)) +TkEventInit(void) { - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); tsdPtr->handlersActive = 0; tsdPtr->pendingPtr = NULL; @@ -517,28 +1110,26 @@ TkEventInit _ANSI_ARGS_((void)) } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * TkXErrorHandler -- * - * TkXErrorHandler is an error handler, to be installed - * via Tk_CreateErrorHandler, that will set a flag if an - * X error occurred. + * TkXErrorHandler is an error handler, to be installed via + * Tk_CreateErrorHandler, that will set a flag if an X error occurred. * * Results: - * Always returns 0, indicating that the X error was - * handled. + * Always returns 0, indicating that the X error was handled. * * Side effects: * None. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ static int -TkXErrorHandler (clientData, errEventPtr) - ClientData clientData; /* Pointer to flag we set */ - XErrorEvent *errEventPtr; /* X error info */ +TkXErrorHandler( + ClientData clientData, /* Pointer to flag we set. */ + XErrorEvent *errEventPtr) /* X error info. */ { int *error; @@ -548,12 +1139,12 @@ TkXErrorHandler (clientData, errEventPtr) } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * ParentXId -- * - * Returns the parent of the given window, or "None" - * if the window doesn't exist. + * Returns the parent of the given window, or "None" if the window + * doesn't exist. * * Results: * Returns an X window ID. @@ -561,13 +1152,13 @@ TkXErrorHandler (clientData, errEventPtr) * Side effects: * None. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ static Window -ParentXId(display, w) - Display *display; - Window w; +ParentXId( + Display *display, + Window w) { Tk_ErrorHandler handler; int gotXError; @@ -577,17 +1168,23 @@ ParentXId(display, w) Window *childList; unsigned int nChildren; - /* Handle errors ourselves. */ + /* + * Handle errors ourselves. + */ gotXError = 0; handler = Tk_CreateErrorHandler(display, -1, -1, -1, - TkXErrorHandler, (ClientData) (&gotXError)); + TkXErrorHandler, (ClientData) (&gotXError)); - /* Get the parent window. */ + /* + * Get the parent window. + */ status = XQueryTree(display, w, &root, &parent, &childList, &nChildren); - /* Do some cleanup; gotta return "None" if we got an error. */ + /* + * Do some cleanup; gotta return "None" if we got an error. + */ Tk_DeleteErrorHandler(handler); XSync(display, False); @@ -595,19 +1192,19 @@ ParentXId(display, w) XFree(childList); } if (status == 0) { - parent = None; + parent = None; } return parent; } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * Tk_HandleEvent -- * - * Given an event, invoke all the handlers that have - * been registered for the event. + * Given an event, invoke all the handlers that have been registered for + * the event. * * Results: * None. @@ -615,348 +1212,106 @@ ParentXId(display, w) * Side effects: * Depends on the handlers. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_HandleEvent(eventPtr) - XEvent *eventPtr; /* Event to dispatch. */ +Tk_HandleEvent( + XEvent *eventPtr) /* Event to dispatch. */ { register TkEventHandler *handlerPtr; - register GenericHandler *genericPtr; - register GenericHandler *genPrevPtr; TkWindow *winPtr; unsigned long mask; InProgress ip; - Window handlerWindow; - Window parentXId; - TkDisplay *dispPtr; - Tcl_Interp *interp = (Tcl_Interp *) NULL; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - /* - * Hack for simulated X-events: Correct the state field - * of the event record to match with the ButtonPress - * and ButtonRelease events. - */ - - if (eventPtr->type==ButtonPress) { - dispPtr = TkGetDisplay(eventPtr->xbutton.display); - dispPtr->mouseButtonWindow = eventPtr->xbutton.window; - eventPtr->xbutton.state |= dispPtr->mouseButtonState; - switch (eventPtr->xbutton.button) { - case 1: dispPtr->mouseButtonState |= Button1Mask; break; - case 2: dispPtr->mouseButtonState |= Button2Mask; break; - case 3: dispPtr->mouseButtonState |= Button3Mask; break; - } - } else if (eventPtr->type==ButtonRelease) { - dispPtr = TkGetDisplay(eventPtr->xbutton.display); - dispPtr->mouseButtonWindow = 0; - switch (eventPtr->xbutton.button) { - case 1: dispPtr->mouseButtonState &= ~Button1Mask; break; - case 2: dispPtr->mouseButtonState &= ~Button2Mask; break; - case 3: dispPtr->mouseButtonState &= ~Button3Mask; break; - } - eventPtr->xbutton.state |= dispPtr->mouseButtonState; - } else if (eventPtr->type==MotionNotify) { - dispPtr = TkGetDisplay(eventPtr->xmotion.display); - if (dispPtr->mouseButtonState & (Button1Mask|Button2Mask|Button3Mask)) { - if (eventPtr->xbutton.window != dispPtr->mouseButtonWindow) { - /* - * This motion event should not be interpreted as a button - * press + motion event since this is not the same window - * the button was pressed down in. - */ - dispPtr->mouseButtonState &= - ~(Button1Mask|Button2Mask|Button3Mask); - dispPtr->mouseButtonWindow = 0; - } else { - eventPtr->xmotion.state |= dispPtr->mouseButtonState; - } - } - } - - /* - * Next, invoke all the generic event handlers (those that are - * invoked for all events). If a generic event handler reports that - * an event is fully processed, go no further. - */ + Tcl_Interp *interp = NULL; + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - for (genPrevPtr = NULL, genericPtr = tsdPtr->genericList; - genericPtr != NULL; ) { - if (genericPtr->deleteFlag) { - if (!tsdPtr->handlersActive) { - GenericHandler *tmpPtr; - - /* - * This handler needs to be deleted and there are no - * calls pending through the handler, so now is a safe - * time to delete it. - */ - - tmpPtr = genericPtr->nextPtr; - if (genPrevPtr == NULL) { - tsdPtr->genericList = tmpPtr; - } else { - genPrevPtr->nextPtr = tmpPtr; - } - if (tmpPtr == NULL) { - tsdPtr->lastGenericPtr = genPrevPtr; - } - (void) ckfree((char *) genericPtr); - genericPtr = tmpPtr; - continue; - } - } else { - int done; - - tsdPtr->handlersActive++; - done = (*genericPtr->proc)(genericPtr->clientData, eventPtr); - tsdPtr->handlersActive--; - if (done) { - return; - } - } - genPrevPtr = genericPtr; - genericPtr = genPrevPtr->nextPtr; - } + UpdateButtonEventState(eventPtr); /* - * If the event is a MappingNotify event, find its display and - * refresh the keyboard mapping information for the display. - * After that there's nothing else to do with the event, so just - * quit. + * If the generic handler processed this event we are done and can return. */ - if (eventPtr->type == MappingNotify) { - dispPtr = TkGetDisplay(eventPtr->xmapping.display); - if (dispPtr != NULL) { - XRefreshKeyboardMapping(&eventPtr->xmapping); - dispPtr->bindInfoStale = 1; - } - return; + if (InvokeGenericHandlers(tsdPtr, eventPtr)) { + goto releaseEventResources; } - /* - * Events selected by StructureNotify require special handling. - * They look the same as those selected by SubstructureNotify. - * The only difference is whether the "event" and "window" fields - * are the same. Compare the two fields and convert StructureNotify - * to SubstructureNotify if necessary. - */ - - handlerWindow = eventPtr->xany.window; - mask = eventMasks[eventPtr->xany.type]; - if (mask == StructureNotifyMask) { - if (eventPtr->xmap.event != eventPtr->xmap.window) { - mask = SubstructureNotifyMask; - handlerWindow = eventPtr->xmap.event; - } - } - winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, handlerWindow); - if (winPtr == NULL) { + if (RefreshKeyboardMappingIfNeeded(eventPtr)) { /* - * There isn't a TkWindow structure for this window. - * However, if the event is a PropertyNotify event then call - * the selection manager (it deals beneath-the-table with - * certain properties). Also, if the window's parent is a - * Tk window that has the TK_PROP_PROPCHANGE flag set, then - * we must propagate the PropertyNotify event up to the parent. + * We are done with a MappingNotify event. */ - if (eventPtr->type != PropertyNotify) { - return; - } - - TkSelPropProc(eventPtr); - - /* Get handlerWindow's parent. */ - - parentXId = ParentXId(eventPtr->xany.display, handlerWindow); - if (parentXId == None) { - return; - } - - winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, parentXId); - if (winPtr == NULL) { - return; - } + goto releaseEventResources; + } - if (!(winPtr->flags & TK_PROP_PROPCHANGE)) { - return; - } + mask = GetEventMaskFromXEvent(eventPtr); + winPtr = GetTkWindowFromXEvent(eventPtr); - handlerWindow = parentXId; + if (winPtr == NULL) { + goto releaseEventResources; } /* * Once a window has started getting deleted, don't process any more - * events for it except for the DestroyNotify event. This check is - * needed because a DestroyNotify handler could re-invoke the event - * loop, causing other pending events to be handled for the window - * (the window doesn't get totally expunged from our tables until - * after the DestroyNotify event has been completely handled). + * events for it except for the DestroyNotify event. This check is needed + * because a DestroyNotify handler could re-invoke the event loop, causing + * other pending events to be handled for the window (the window doesn't + * get totally expunged from our tables until after the DestroyNotify + * event has been completely handled). */ if ((winPtr->flags & TK_ALREADY_DEAD) && (eventPtr->type != DestroyNotify)) { - return; + goto releaseEventResources; } if (winPtr->mainPtr != NULL) { + int result; + + interp = winPtr->mainPtr->interp; - /* - * Protect interpreter for this window from possible deletion - * while we are dealing with the event for this window. Thus, - * widget writers do not have to worry about protecting the - * interpreter in their own code. - */ - - interp = winPtr->mainPtr->interp; - Tcl_Preserve((ClientData) interp); - - /* - * Call focus-related code to look at FocusIn, FocusOut, Enter, - * and Leave events; depending on its return value, ignore the - * event. - */ - - if ((mask & (FocusChangeMask|EnterWindowMask|LeaveWindowMask)) - && !TkFocusFilterEvent(winPtr, eventPtr)) { - Tcl_Release((ClientData) interp); - return; - } - - /* - * Redirect KeyPress and KeyRelease events to the focus window, - * or ignore them entirely if there is no focus window. We also - * route the MouseWheel event to the focus window. The MouseWheel - * event is an extension to the X event set. Currently, it is only - * available on the Windows version of Tk. - */ - -#ifdef MAC_OSX_TK - /* MouseWheel events are not focus specific on Mac OS X */ - if (mask & (KeyPressMask|KeyReleaseMask)) { -#else - if (mask & (KeyPressMask|KeyReleaseMask|MouseWheelMask)) { -#endif - winPtr->dispPtr->lastEventTime = eventPtr->xkey.time; - winPtr = TkFocusKeyEvent(winPtr, eventPtr); - if (winPtr == NULL) { - Tcl_Release((ClientData) interp); - return; - } - } - /* - * Call a grab-related procedure to do special processing on - * pointer events. + * Protect interpreter for this window from possible deletion while we + * are dealing with the event for this window. Thus, widget writers do + * not have to worry about protecting the interpreter in their own + * code. */ - - if (mask & (ButtonPressMask|ButtonReleaseMask|PointerMotionMask - |EnterWindowMask|LeaveWindowMask)) { - if (mask & (ButtonPressMask|ButtonReleaseMask)) { - winPtr->dispPtr->lastEventTime = eventPtr->xbutton.time; - } else if (mask & PointerMotionMask) { - winPtr->dispPtr->lastEventTime = eventPtr->xmotion.time; - } else { - winPtr->dispPtr->lastEventTime = eventPtr->xcrossing.time; - } - if (TkPointerEvent(eventPtr, winPtr) == 0) { - goto done; - } + + Tcl_Preserve((ClientData) interp); + + result = ((InvokeFocusHandlers(&winPtr, mask, eventPtr)) + || (InvokeMouseHandlers(winPtr, mask, eventPtr))); + + if (result) { + goto releaseInterpreter; } } -#ifdef TK_USE_INPUT_METHODS /* - * Pass the event to the input method(s), if there are any, and - * discard the event if the input method(s) insist. Create the - * input context for the window if it hasn't already been done - * (XFilterEvent needs this context). XIM is only ever enabled on - * Unix, but this hasn't been factored out of the generic code yet. + * Create the input context for the window if it hasn't already been done + * (XFilterEvent needs this context). When the event is a FocusIn event, + * set the input context focus to the receiving window. This code is only + * ever active for X11. */ - dispPtr = winPtr->dispPtr; - if ((dispPtr->flags & TK_DISPLAY_USE_IM)) { - long im_event_mask = 0L; + +#ifdef TK_USE_INPUT_METHODS + if ((winPtr->dispPtr->flags & TK_DISPLAY_USE_IM)) { if (!(winPtr->flags & (TK_CHECKED_IC|TK_ALREADY_DEAD))) { winPtr->flags |= TK_CHECKED_IC; - if (dispPtr->inputMethod != NULL) { -#if TK_XIM_SPOT - if (dispPtr->flags & TK_DISPLAY_XIM_SPOT) { - XVaNestedList preedit_attr; - XPoint spot = {0, 0}; - - if (dispPtr->inputXfs == NULL) { - /* - * We only need to create one XFontSet - */ - char **missing_list; - int missing_count; - char *def_string; - - dispPtr->inputXfs = XCreateFontSet(dispPtr->display, - "-*-*-*-R-Normal--14-130-75-75-*-*", - &missing_list, &missing_count, &def_string); - if (missing_count > 0) { - XFreeStringList(missing_list); - } - } - - preedit_attr = XVaCreateNestedList(0, XNSpotLocation, - &spot, XNFontSet, dispPtr->inputXfs, NULL); - if (winPtr->inputContext != NULL) - panic("inputContext not NULL"); - winPtr->inputContext = XCreateIC(dispPtr->inputMethod, - XNInputStyle, XIMPreeditPosition|XIMStatusNothing, - XNClientWindow, winPtr->window, - XNFocusWindow, winPtr->window, - XNPreeditAttributes, preedit_attr, - NULL); - XFree(preedit_attr); - } else { - if (winPtr->inputContext != NULL) - panic("inputContext not NULL"); - winPtr->inputContext = XCreateIC(dispPtr->inputMethod, - XNInputStyle, XIMPreeditNothing|XIMStatusNothing, - XNClientWindow, winPtr->window, - XNFocusWindow, winPtr->window, - NULL); - } -#else - if (winPtr->inputContext != NULL) - panic("inputContext not NULL"); - winPtr->inputContext = XCreateIC(dispPtr->inputMethod, - XNInputStyle, XIMPreeditNothing|XIMStatusNothing, - XNClientWindow, winPtr->window, - XNFocusWindow, winPtr->window, - NULL); -#endif - } - } - if (winPtr->inputContext != NULL && - (eventPtr->xany.type == FocusIn)) { - XGetICValues(winPtr->inputContext, - XNFilterEvents, &im_event_mask, NULL); - if (im_event_mask != 0L) { - XSelectInput(winPtr->display, winPtr->window, - winPtr->atts.event_mask | im_event_mask); - XSetICFocus(winPtr->inputContext); + if (winPtr->dispPtr->inputMethod != NULL) { + CreateXIC(winPtr); } } - if (eventPtr->type == KeyPress || eventPtr->type == KeyRelease) { - if (XFilterEvent(eventPtr, None)) { - goto done; - } + if (eventPtr->type == FocusIn && winPtr->inputContext != NULL) { + XSetICFocus(winPtr->inputContext); } } -#endif /* TK_USE_INPUT_METHODS */ +#endif /* - * For events where it hasn't already been done, update the current - * time in the display. + * For events where it hasn't already been done, update the current time + * in the display. */ if (eventPtr->type == PropertyNotify) { @@ -964,8 +1319,8 @@ Tk_HandleEvent(eventPtr) } /* - * There's a potential interaction here with Tk_DeleteEventHandler. - * Read the documentation for pendingPtr. + * There's a potential interaction here with Tk_DeleteEventHandler. Read + * the documentation for pendingPtr. */ ip.eventPtr = eventPtr; @@ -983,49 +1338,8 @@ Tk_HandleEvent(eventPtr) Tk_InternAtom((Tk_Window) winPtr, "WM_PROTOCOLS")) { TkWmProtocolEventProc(winPtr, eventPtr); } else { - /* - * Finally, invoke any ClientMessage event handlers. - */ - - for (genPrevPtr = NULL, genericPtr = tsdPtr->cmList; - genericPtr != NULL; ) { - if (genericPtr->deleteFlag) { - if (!tsdPtr->handlersActive) { - GenericHandler *tmpPtr; - - /* - * This handler needs to be deleted and there are - * no calls pending through any handlers, so now - * is a safe time to delete it. - */ - - tmpPtr = genericPtr->nextPtr; - if (genPrevPtr == NULL) { - tsdPtr->cmList = tmpPtr; - } else { - genPrevPtr->nextPtr = tmpPtr; - } - if (tmpPtr == NULL) { - tsdPtr->lastCmPtr = genPrevPtr; - } - (void) ckfree((char *) genericPtr); - genericPtr = tmpPtr; - continue; - } - } else { - int done; - - tsdPtr->handlersActive++; - done = (*(Tk_ClientMessageProc *)genericPtr->proc) - ((Tk_Window) winPtr, eventPtr); - tsdPtr->handlersActive--; - if (done) { - break; - } - } - genPrevPtr = genericPtr; - genericPtr = genPrevPtr->nextPtr; - } + InvokeClientMessageHandlers(tsdPtr, (Tk_Window)winPtr, + eventPtr); } } } else { @@ -1040,44 +1354,53 @@ Tk_HandleEvent(eventPtr) } /* - * Pass the event to the "bind" command mechanism. But, don't - * do this for SubstructureNotify events. The "bind" command - * doesn't support them anyway, and it's easier to filter out - * these events here than in the lower-level procedures. + * Pass the event to the "bind" command mechanism. But, don't do this + * for SubstructureNotify events. The "bind" command doesn't support + * them anyway, and it's easier to filter out these events here than + * in the lower-level functions. */ /* - * ...well, except when we use the tkwm patches, in which case - * we DO handle CreateNotify events, so we gotta pass 'em through. + * ...well, except when we use the tkwm patches, in which case we DO + * handle CreateNotify events, so we gotta pass 'em through. */ if ((ip.winPtr != None) && ((mask != SubstructureNotifyMask) - || (eventPtr->type == CreateNotify))) { + || (eventPtr->type == CreateNotify))) { TkBindEventProc(winPtr, eventPtr); } } tsdPtr->pendingPtr = ip.nextPtr; -done: /* * Release the interpreter for this window so that it can be potentially * deleted if requested. */ - - if (interp != (Tcl_Interp *) NULL) { - Tcl_Release((ClientData) interp); + + releaseInterpreter: + if (interp != NULL) { + Tcl_Release((ClientData) interp); } + + /* + * Release the user_data from the event (if it is a virtual event and the + * field was non-NULL in the first place.) Note that this is done using a + * Tcl_Obj interface, and we set the field back to NULL afterwards out of + * paranoia. Also clean up any cached %A substitutions from key events. + */ + + releaseEventResources: + CleanUpTkEvent(eventPtr); } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- * * TkEventDeadWindow -- * - * This procedure is invoked when it is determined that - * a window is dead. It cleans up event-related information - * about the window. + * This function is invoked when it is determined that a window is dead. + * It cleans up event-related information about the window. * * Results: * None. @@ -1085,31 +1408,30 @@ done: * Side effects: * Various things get cleaned up and recycled. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -TkEventDeadWindow(winPtr) - TkWindow *winPtr; /* Information about the window - * that is being deleted. */ +TkEventDeadWindow( + TkWindow *winPtr) /* Information about the window that is being + * deleted. */ { register TkEventHandler *handlerPtr; register InProgress *ipPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); /* - * While deleting all the handlers, be careful to check for - * Tk_HandleEvent being about to process one of the deleted - * handlers. If it is, tell it to quit (all of the handlers - * are being deleted). + * While deleting all the handlers, be careful to check for Tk_HandleEvent + * being about to process one of the deleted handlers. If it is, tell it + * to quit (all of the handlers are being deleted). */ while (winPtr->handlerList != NULL) { handlerPtr = winPtr->handlerList; winPtr->handlerList = handlerPtr->nextPtr; - for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; - ipPtr = ipPtr->nextPtr) { + for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; + ipPtr = ipPtr->nextPtr) { if (ipPtr->nextHandler == handlerPtr) { ipPtr->nextHandler = NULL; } @@ -1126,15 +1448,13 @@ TkEventDeadWindow(winPtr) * * TkCurrentTime -- * - * Try to deduce the current time. "Current time" means the time - * of the event that led to the current code being executed, which - * means the time in the most recently-nested invocation of - * Tk_HandleEvent. + * Try to deduce the current time. "Current time" means the time of the + * event that led to the current code being executed, which means the + * time in the most recently-nested invocation of Tk_HandleEvent. * * Results: - * The return value is the time from the current event, or - * CurrentTime if there is no current event or if the current - * event contains no time. + * The return value is the time from the current event, or CurrentTime if + * there is no current event or if the current event contains no time. * * Side effects: * None. @@ -1143,31 +1463,31 @@ TkEventDeadWindow(winPtr) */ Time -TkCurrentTime(dispPtr) - TkDisplay *dispPtr; /* Display for which the time is desired. */ +TkCurrentTime( + TkDisplay *dispPtr) /* Display for which the time is desired. */ { register XEvent *eventPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (tsdPtr->pendingPtr == NULL) { return dispPtr->lastEventTime; } eventPtr = tsdPtr->pendingPtr->eventPtr; switch (eventPtr->type) { - case ButtonPress: - case ButtonRelease: - return eventPtr->xbutton.time; - case KeyPress: - case KeyRelease: - return eventPtr->xkey.time; - case MotionNotify: - return eventPtr->xmotion.time; - case EnterNotify: - case LeaveNotify: - return eventPtr->xcrossing.time; - case PropertyNotify: - return eventPtr->xproperty.time; + case ButtonPress: + case ButtonRelease: + return eventPtr->xbutton.time; + case KeyPress: + case KeyRelease: + return eventPtr->xkey.time; + case MotionNotify: + return eventPtr->xmotion.time; + case EnterNotify: + case LeaveNotify: + return eventPtr->xcrossing.time; + case PropertyNotify: + return eventPtr->xproperty.time; } return dispPtr->lastEventTime; } @@ -1177,15 +1497,14 @@ TkCurrentTime(dispPtr) * * Tk_RestrictEvents -- * - * This procedure is used to globally restrict the set of events - * that will be dispatched. The restriction is done by filtering - * all incoming X events through a procedure that determines - * whether they are to be processed immediately, deferred, or - * discarded. + * This function is used to globally restrict the set of events that will + * be dispatched. The restriction is done by filtering all incoming X + * events through a function that determines whether they are to be + * processed immediately, deferred, or discarded. * * Results: - * The return value is the previous restriction procedure in effect, - * if there was one, or NULL if there wasn't. + * The return value is the previous restriction function in effect, if + * there was one, or NULL if there wasn't. * * Side effects: * From now on, proc will be called to determine whether to process, @@ -1195,16 +1514,15 @@ TkCurrentTime(dispPtr) */ Tk_RestrictProc * -Tk_RestrictEvents(proc, arg, prevArgPtr) - Tk_RestrictProc *proc; /* Procedure to call for each incoming - * event. */ - ClientData arg; /* Arbitrary argument to pass to proc. */ - ClientData *prevArgPtr; /* Place to store information about previous +Tk_RestrictEvents( + Tk_RestrictProc *proc, /* Function to call for each incoming event */ + ClientData arg, /* Arbitrary argument to pass to proc. */ + ClientData *prevArgPtr) /* Place to store information about previous * argument. */ { Tk_RestrictProc *prev; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); prev = tsdPtr->restrictProc; *prevArgPtr = tsdPtr->restrictArg; @@ -1218,7 +1536,7 @@ Tk_RestrictEvents(proc, arg, prevArgPtr) * * Tk_CollapseMotionEvents -- * - * This procedure controls whether we collapse motion events in a + * This function controls whether we collapse motion events in a * particular display or not. * * Results: @@ -1231,10 +1549,10 @@ Tk_RestrictEvents(proc, arg, prevArgPtr) */ int -Tk_CollapseMotionEvents(display, collapse) - Display *display; /* Display handling these events. */ - int collapse; /* boolean value that specifies whether - * motion events should be collapsed. */ +Tk_CollapseMotionEvents( + Display *display, /* Display handling these events. */ + int collapse) /* Boolean value that specifies whether motion + * events should be collapsed. */ { TkDisplay *dispPtr = (TkDisplay *) display; int prev = (dispPtr->flags & TK_DISPLAY_COLLAPSE_MOTION_EVENTS); @@ -1252,28 +1570,26 @@ Tk_CollapseMotionEvents(display, collapse) * * Tk_QueueWindowEvent -- * - * Given an X-style window event, this procedure adds it to the - * Tcl event queue at the given position. This procedure also - * performs mouse motion event collapsing if possible. + * Given an X-style window event, this function adds it to the Tcl event + * queue at the given position. This function also performs mouse motion + * event collapsing if possible. * * Results: * None. * * Side effects: - * Adds stuff to the event queue, which will eventually be - * processed. + * Adds stuff to the event queue, which will eventually be processed. * *---------------------------------------------------------------------- */ void -Tk_QueueWindowEvent(eventPtr, position) - XEvent *eventPtr; /* Event to add to queue. This - * procedures copies it before adding - * it to the queue. */ - Tcl_QueuePosition position; /* Where to put it on the queue: - * TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, - * or TCL_QUEUE_MARK. */ +Tk_QueueWindowEvent( + XEvent *eventPtr, /* Event to add to queue. This function copies + * it before adding it to the queue. */ + Tcl_QueuePosition position) /* Where to put it on the queue: + * TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, or + * TCL_QUEUE_MARK. */ { TkWindowEvent *wevPtr; TkDisplay *dispPtr; @@ -1292,10 +1608,11 @@ Tk_QueueWindowEvent(eventPtr, position) } /* - * Don't filter motion events if the user - * defaulting to true (1), which could be set to false (0) when the - * user wishes to receive all the motion data) + * Don't filter motion events if the user defaulting to true (1), which + * could be set to false (0) when the user wishes to receive all the + * motion data) */ + if (!(dispPtr->flags & TK_DISPLAY_COLLAPSE_MOTION_EVENTS)) { wevPtr = (TkWindowEvent *) ckalloc(sizeof(TkWindowEvent)); wevPtr->header.proc = WindowEventProc; @@ -1308,9 +1625,8 @@ Tk_QueueWindowEvent(eventPtr, position) if ((eventPtr->type == MotionNotify) && (eventPtr->xmotion.window == dispPtr->delayedMotionPtr->event.xmotion.window)) { /* - * The new event is a motion event in the same window as the - * saved motion event. Just replace the saved event with the - * new one. + * The new event is a motion event in the same window as the saved + * motion event. Just replace the saved event with the new one. */ dispPtr->delayedMotionPtr->event = *eventPtr; @@ -1319,7 +1635,7 @@ Tk_QueueWindowEvent(eventPtr, position) && (eventPtr->type != NoExpose) && (eventPtr->type != Expose)) { /* - * The new event may conflict with the saved motion event. Queue + * The new event may conflict with the saved motion event. Queue * the saved motion event now so that it will be processed before * the new event. */ @@ -1335,13 +1651,13 @@ Tk_QueueWindowEvent(eventPtr, position) wevPtr->event = *eventPtr; if ((eventPtr->type == MotionNotify) && (position == TCL_QUEUE_TAIL)) { /* - * The new event is a motion event so don't queue it immediately; - * save it around in case another motion event arrives that it can - * be collapsed with. + * The new event is a motion event so don't queue it immediately; save + * it around in case another motion event arrives that it can be + * collapsed with. */ if (dispPtr->delayedMotionPtr != NULL) { - panic("Tk_QueueWindowEvent found unexpected delayed motion event"); + Tcl_Panic("Tk_QueueWindowEvent found unexpected delayed motion event"); } dispPtr->delayedMotionPtr = wevPtr; Tcl_DoWhenIdle(DelayedMotionProc, (ClientData) dispPtr); @@ -1351,12 +1667,12 @@ Tk_QueueWindowEvent(eventPtr, position) } /* - *--------------------------------------------------------------------------- + *---------------------------------------------------------------------- * * TkQueueEventForAllChildren -- * - * Given an XEvent, recursively queue the event for this window and - * all non-toplevel children of the given window. + * Given an XEvent, recursively queue the event for this window and all + * non-toplevel children of the given window. * * Results: * None. @@ -1364,23 +1680,23 @@ Tk_QueueWindowEvent(eventPtr, position) * Side effects: * Events queued. * - *--------------------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -TkQueueEventForAllChildren(winPtr, eventPtr) - TkWindow *winPtr; /* Window to which event is sent. */ - XEvent *eventPtr; /* The event to be sent. */ +TkQueueEventForAllChildren( + TkWindow *winPtr, /* Window to which event is sent. */ + XEvent *eventPtr) /* The event to be sent. */ { TkWindow *childPtr; if (!Tk_IsMapped(winPtr)) { - return; + return; } - + eventPtr->xany.window = winPtr->window; Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL); - + childPtr = winPtr->childList; while (childPtr != NULL) { if (!Tk_TopWinHierarchy(childPtr)) { @@ -1395,16 +1711,16 @@ TkQueueEventForAllChildren(winPtr, eventPtr) * * WindowEventProc -- * - * This procedure is called by Tcl_DoOneEvent when a window event - * reaches the front of the event queue. This procedure is responsible - * for actually handling the event. + * This function is called by Tcl_DoOneEvent when a window event reaches + * the front of the event queue. This function is responsible for + * actually handling the event. * * Results: - * Returns 1 if the event was handled, meaning it should be removed - * from the queue. Returns 0 if the event was not handled, meaning - * it should stay on the queue. The event isn't handled if the - * TCL_WINDOW_EVENTS bit isn't set in flags, if a restrict proc - * prevents the event from being handled. + * Returns 1 if the event was handled, meaning it should be removed from + * the queue. Returns 0 if the event was not handled, meaning it should + * stay on the queue. The event isn't handled if the TCL_WINDOW_EVENTS + * bit isn't set in flags, if a restrict proc prevents the event from + * being handled. * * Side effects: * Whatever the event handlers for the event do. @@ -1413,15 +1729,15 @@ TkQueueEventForAllChildren(winPtr, eventPtr) */ static int -WindowEventProc(evPtr, flags) - Tcl_Event *evPtr; /* Event to service. */ - int flags; /* Flags that indicate what events to - * handle, such as TCL_WINDOW_EVENTS. */ +WindowEventProc( + Tcl_Event *evPtr, /* Event to service. */ + int flags) /* Flags that indicate what events to handle, + * such as TCL_WINDOW_EVENTS. */ { TkWindowEvent *wevPtr = (TkWindowEvent *) evPtr; Tk_RestrictAction result; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (!(flags & TCL_WINDOW_EVENTS)) { return 0; @@ -1436,68 +1752,398 @@ WindowEventProc(evPtr, flags) * TK_DELETE_EVENT: return and say we processed the event, * even though we didn't do anything at all. */ + + CleanUpTkEvent(&wevPtr->event); return 1; } } } Tk_HandleEvent(&wevPtr->event); + CleanUpTkEvent(&wevPtr->event); return 1; } /* *---------------------------------------------------------------------- * + * CleanUpTkEvent -- + * + * This function is called to remove and deallocate any information in + * the event which is not directly in the event structure itself. It may + * be called multiple times per event, so it takes care to set the + * cleared pointer fields to NULL afterwards. + * + * Results: + * None. + * + * Side effects: + * Makes the event no longer have any external resources. + * + *---------------------------------------------------------------------- + */ + +static void +CleanUpTkEvent( + XEvent *eventPtr) +{ + switch (eventPtr->type) { + case KeyPress: + case KeyRelease: { + TkKeyEvent *kePtr = (TkKeyEvent *) eventPtr; + + if (kePtr->charValuePtr != NULL) { + ckfree(kePtr->charValuePtr); + kePtr->charValuePtr = NULL; + kePtr->charValueLen = 0; + } + break; + } + + case VirtualEvent: { + XVirtualEvent *vePtr = (XVirtualEvent *) eventPtr; + + if (vePtr->user_data != NULL) { + Tcl_DecrRefCount(vePtr->user_data); + vePtr->user_data = NULL; + } + break; + } + } +} + +/* + *---------------------------------------------------------------------- + * * DelayedMotionProc -- * - * This procedure is invoked as an idle handler when a mouse motion - * event has been delayed. It queues the delayed event so that it - * will finally be serviced. + * This function is invoked as an idle handler when a mouse motion event + * has been delayed. It queues the delayed event so that it will finally + * be serviced. * * Results: * None. * * Side effects: - * The delayed mouse motion event gets added to the Tcl event - * queue for servicing. + * The delayed mouse motion event gets added to the Tcl event queue for + * servicing. * *---------------------------------------------------------------------- */ static void -DelayedMotionProc(clientData) - ClientData clientData; /* Pointer to display containing a delayed +DelayedMotionProc( + ClientData clientData) /* Pointer to display containing a delayed * motion event to be serviced. */ { TkDisplay *dispPtr = (TkDisplay *) clientData; if (dispPtr->delayedMotionPtr == NULL) { - panic("DelayedMotionProc found no delayed mouse motion event"); + Tcl_Panic("DelayedMotionProc found no delayed mouse motion event"); } Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, TCL_QUEUE_TAIL); dispPtr->delayedMotionPtr = NULL; } /* - *-------------------------------------------------------------- + *---------------------------------------------------------------------- + * + * TkCreateExitHandler -- + * + * Same as Tcl_CreateExitHandler, but private to Tk. + * + * Results: + * None. + * + * Side effects. + * Sets a handler with Tcl_CreateExitHandler if this is the first call. + * + *---------------------------------------------------------------------- + */ + +void +TkCreateExitHandler( + Tcl_ExitProc *proc, /* Function to invoke. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr; + + exitPtr = (ExitHandler *) ckalloc(sizeof(ExitHandler)); + exitPtr->proc = proc; + exitPtr->clientData = clientData; + Tcl_MutexLock(&exitMutex); + + /* + * The call to TclInExit() is disabled here. That's a private Tcl routine, + * and calling it is causing some trouble with portability of building Tk. + * We should avoid private Tcl routines generally. + * + * In this case, the TclInExit() call is being used only to prevent a + * Tcl_CreateExitHandler() call when Tcl finalization is in progress. + * That's a situation that shouldn't happen anyway. Recent changes within + * Tcl_Finalize now cause a Tcl_Panic() to happen if exit handlers get + * added after exit handling is complete. By disabling the guard here, + * that panic will serve to help us find the buggy conditions and correct + * them. + * + * We can restore this guard if we find we must (hopefully getting public + * access to TclInExit() if we discover extensions really do need this), + * but during alpha development, this is a good time to dig in and find + * the root causes of finalization bugs. + */ + + if (firstExitPtr == NULL/* && !TclInExit()*/) { + Tcl_CreateExitHandler(TkFinalize, NULL); + } + exitPtr->nextPtr = firstExitPtr; + firstExitPtr = exitPtr; + Tcl_MutexUnlock(&exitMutex); +} + +/* + *---------------------------------------------------------------------- + * + * TkDeleteExitHandler -- + * + * Same as Tcl_DeleteExitHandler, but private to Tk. + * + * Results: + * None. + * + * Side effects. + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkDeleteExitHandler( + Tcl_ExitProc *proc, /* Function that was previously registered. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr, *prevPtr; + + Tcl_MutexLock(&exitMutex); + for (prevPtr = NULL, exitPtr = firstExitPtr; exitPtr != NULL; + prevPtr = exitPtr, exitPtr = exitPtr->nextPtr) { + if ((exitPtr->proc == proc) + && (exitPtr->clientData == clientData)) { + if (prevPtr == NULL) { + firstExitPtr = exitPtr->nextPtr; + } else { + prevPtr->nextPtr = exitPtr->nextPtr; + } + ckfree((char *) exitPtr); + break; + } + } + Tcl_MutexUnlock(&exitMutex); + return; +} + +/* + *---------------------------------------------------------------------- + * + * TkCreateThreadExitHandler -- + * + * Same as Tcl_CreateThreadExitHandler, but private to Tk. + * + * Results: + * None. + * + * Side effects: + * Proc will be invoked with clientData as argument when the application + * exits. + * + *---------------------------------------------------------------------- + */ + +void +TkCreateThreadExitHandler( + Tcl_ExitProc *proc, /* Function to invoke. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr; + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + + exitPtr = (ExitHandler *) ckalloc(sizeof(ExitHandler)); + exitPtr->proc = proc; + exitPtr->clientData = clientData; + + /* + * See comments in TkCreateExitHandler(). + */ + + if (tsdPtr->firstExitPtr == NULL/* && !TclInExit()*/) { + Tcl_CreateThreadExitHandler(TkFinalizeThread, NULL); + } + exitPtr->nextPtr = tsdPtr->firstExitPtr; + tsdPtr->firstExitPtr = exitPtr; +} + +/* + *---------------------------------------------------------------------- + * + * TkDeleteThreadExitHandler -- + * + * Same as Tcl_DeleteThreadExitHandler, but private to Tk. + * + * Results: + * None. + * + * Side effects: + * If there is an exit handler corresponding to proc and clientData then + * it is cancelled; if no such handler exists then nothing happens. + * + *---------------------------------------------------------------------- + */ + +void +TkDeleteThreadExitHandler( + Tcl_ExitProc *proc, /* Function that was previously registered. */ + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr, *prevPtr; + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + + for (prevPtr = NULL, exitPtr = tsdPtr->firstExitPtr; exitPtr != NULL; + prevPtr = exitPtr, exitPtr = exitPtr->nextPtr) { + if ((exitPtr->proc == proc) + && (exitPtr->clientData == clientData)) { + if (prevPtr == NULL) { + tsdPtr->firstExitPtr = exitPtr->nextPtr; + } else { + prevPtr->nextPtr = exitPtr->nextPtr; + } + ckfree((char *) exitPtr); + return; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkFinalize -- + * + * Runs our private exit handlers and removes itself from Tcl. This is + * benificial should we want to protect from dangling pointers should the + * Tk shared library be unloaded prior to Tcl which can happen on windows + * should the process be forcefully exiting from an exception handler. + * + * Results: + * None. + * + * Side effects. + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkFinalize( + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr; + + Tcl_DeleteExitHandler(TkFinalize, NULL); + + Tcl_MutexLock(&exitMutex); + for (exitPtr = firstExitPtr; exitPtr != NULL; exitPtr = firstExitPtr) { + /* + * Be careful to remove the handler from the list before invoking its + * callback. This protects us against double-freeing if the callback + * should call TkDeleteExitHandler on itself. + */ + + firstExitPtr = exitPtr->nextPtr; + Tcl_MutexUnlock(&exitMutex); + (*exitPtr->proc)(exitPtr->clientData); + ckfree((char *) exitPtr); + Tcl_MutexLock(&exitMutex); + } + firstExitPtr = NULL; + Tcl_MutexUnlock(&exitMutex); +} + +/* + *---------------------------------------------------------------------- + * + * TkFinalizeThread -- + * + * Runs our private thread exit handlers and removes itself from Tcl. + * This is benificial should we want to protect from dangling pointers + * should the Tk shared library be unloaded prior to Tcl which can happen + * on Windows should the process be forcefully exiting from an exception + * handler. + * + * Results: + * None. + * + * Side effects. + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkFinalizeThread( + ClientData clientData) /* Arbitrary value to pass to proc. */ +{ + ExitHandler *exitPtr; + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + + Tcl_DeleteThreadExitHandler(TkFinalizeThread, NULL); + + if (tsdPtr != NULL) { + tsdPtr->inExit = 1; + + for (exitPtr = tsdPtr->firstExitPtr; exitPtr != NULL; + exitPtr = tsdPtr->firstExitPtr) { + /* + * Be careful to remove the handler from the list before invoking + * its callback. This protects us against double-freeing if the + * callback should call TkDeleteThreadExitHandler on itself. + */ + + tsdPtr->firstExitPtr = exitPtr->nextPtr; + (*exitPtr->proc)(exitPtr->clientData); + ckfree((char *) exitPtr); + } + } +} + +/* + *---------------------------------------------------------------------- * * Tk_MainLoop -- * - * Call Tcl_DoOneEvent over and over again in an infinite - * loop as long as there exist any main windows. + * Call Tcl_DoOneEvent over and over again in an infinite loop as long as + * there exist any main windows. * * Results: * None. * * Side effects: - * Arbitrary; depends on handlers for events. + * Arbitrary; depends on handlers for events. * - *-------------------------------------------------------------- + *---------------------------------------------------------------------- */ void -Tk_MainLoop() +Tk_MainLoop(void) { while (Tk_GetNumMainWindows() > 0) { Tcl_DoOneEvent(0); } } + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |