/* * tkEvent.c -- * * 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. * * RCS: @(#) $Id: tkEvent.c,v 1.35.2.1 2008/08/05 20:31:53 jenglish Exp $ */ #include "tkInt.h" /* * 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. */ } InProgress; /* * 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; /* 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 * 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. */ typedef struct TkWindowEvent { Tcl_Event header; /* Standard information for all events. */ XEvent event; /* The X event. */ } TkWindowEvent; /* * Array of event masks corresponding to each X event: */ static unsigned long realEventMasks[MappingNotify+1] = { 0, 0, KeyPressMask, /* KeyPress */ KeyReleaseMask, /* KeyRelease */ ButtonPressMask, /* ButtonPress */ ButtonReleaseMask, /* ButtonRelease */ PointerMotionMask|PointerMotionHintMask|ButtonMotionMask |Button1MotionMask|Button2MotionMask|Button3MotionMask |Button4MotionMask|Button5MotionMask, /* MotionNotify */ EnterWindowMask, /* EnterNotify */ LeaveWindowMask, /* LeaveNotify */ FocusChangeMask, /* FocusIn */ FocusChangeMask, /* FocusOut */ KeymapStateMask, /* KeymapNotify */ ExposureMask, /* Expose */ ExposureMask, /* GraphicsExpose */ ExposureMask, /* NoExpose */ VisibilityChangeMask, /* VisibilityNotify */ SubstructureNotifyMask, /* CreateNotify */ StructureNotifyMask, /* DestroyNotify */ StructureNotifyMask, /* UnmapNotify */ StructureNotifyMask, /* MapNotify */ SubstructureRedirectMask, /* MapRequest */ StructureNotifyMask, /* ReparentNotify */ StructureNotifyMask, /* ConfigureNotify */ SubstructureRedirectMask, /* ConfigureRequest */ StructureNotifyMask, /* GravityNotify */ ResizeRedirectMask, /* ResizeRequest */ StructureNotifyMask, /* CirculateNotify */ SubstructureRedirectMask, /* CirculateRequest */ PropertyChangeMask, /* PropertyNotify */ 0, /* SelectionClear */ 0, /* SelectionRequest */ 0, /* SelectionNotify */ ColormapChangeMask, /* ColormapNotify */ 0, /* ClientMessage */ 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. */ 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. */ /* * List of generic handler records. */ 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 *lastCmPtr; /* Last handler in list. */ /* * If someone has called Tk_RestrictEvents, the information below keeps * track of it. */ Tk_RestrictProc *restrictProc; /* 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; /* * 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 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 int InvokeInputMethods(TkWindow *winPtr, XEvent *eventPtr); 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); } /* * 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 /* *---------------------------------------------------------------------- * * InvokeInputMethods -- * * 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). * * When the event is a FocusIn event, set the input context focus to the * receiving window. * * Results: * 1 when we are done with the event. * 0 when the event can be processed further. * * Side effects: * Input contexts/methods may be created. * *---------------------------------------------------------------------- */ #ifdef TK_USE_INPUT_METHODS static int InvokeInputMethods( TkWindow *winPtr, XEvent *eventPtr) { TkDisplay *dispPtr = winPtr->dispPtr; if ((dispPtr->flags & TK_DISPLAY_USE_IM)) { if (!(winPtr->flags & (TK_CHECKED_IC|TK_ALREADY_DEAD))) { winPtr->flags |= TK_CHECKED_IC; if (dispPtr->inputMethod != NULL) { CreateXIC(winPtr); } } switch (eventPtr->type) { case FocusIn: if (winPtr->inputContext != NULL) { XSetICFocus(winPtr->inputContext); } break; case KeyPress: case KeyRelease: if (XFilterEvent(eventPtr, None)) { return 1; } break; } } return 0; } #endif /*TK_USE_INPUT_METHODS*/ /* *---------------------------------------------------------------------- * * 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.typexany.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 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 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. * *---------------------------------------------------------------------- */ void 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; /* * 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. */ if (winPtr->handlerList == NULL) { /* * No event handlers defined at all, so must create. */ handlerPtr = (TkEventHandler *) ckalloc(sizeof(TkEventHandler)); winPtr->handlerList = handlerPtr; } else { int found = 0; for (handlerPtr = winPtr->handlerList; ; handlerPtr = handlerPtr->nextPtr) { if ((handlerPtr->proc == proc) && (handlerPtr->clientData == clientData)) { handlerPtr->mask = mask; found = 1; } if (handlerPtr->nextPtr == NULL) { break; } } /* * 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. */ handlerPtr->nextPtr = (TkEventHandler *) ckalloc(sizeof(TkEventHandler)); handlerPtr = handlerPtr->nextPtr; } /* * 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 -- * * Delete a previously-created handler. * * Results: * 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. * *---------------------------------------------------------------------- */ void 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)); /* * Find the event handler to be deleted, or return immediately if it * doesn't exist. */ for (handlerPtr = winPtr->handlerList, prevPtr = NULL; ; prevPtr = handlerPtr, handlerPtr = handlerPtr->nextPtr) { if (handlerPtr == NULL) { return; } if ((handlerPtr->mask == mask) && (handlerPtr->proc == proc) && (handlerPtr->clientData == clientData)) { break; } } /* * 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) { if (ipPtr->nextHandler == handlerPtr) { ipPtr->nextHandler = handlerPtr->nextPtr; } } /* * Free resources associated with the handler. */ if (prevPtr == NULL) { winPtr->handlerList = handlerPtr->nextPtr; } else { prevPtr->nextPtr = handlerPtr->nextPtr; } 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"). */ } /*---------------------------------------------------------------------- * * Tk_CreateGenericHandler -- * * 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. * *---------------------------------------------------------------------- */ void 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)); handlerPtr->proc = proc; handlerPtr->clientData = clientData; handlerPtr->deleteFlag = 0; handlerPtr->nextPtr = NULL; if (tsdPtr->genericList == NULL) { tsdPtr->genericList = handlerPtr; } else { tsdPtr->lastGenericPtr->nextPtr = handlerPtr; } tsdPtr->lastGenericPtr = handlerPtr; } /* *---------------------------------------------------------------------- * * Tk_DeleteGenericHandler -- * * Delete a previously-created generic handler. * * Results: * 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. * *---------------------------------------------------------------------- */ void 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) { if ((handler->proc == proc) && (handler->clientData == clientData)) { handler->deleteFlag = 1; } } } /*---------------------------------------------------------------------- * * Tk_CreateClientMessageHandler -- * * 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. * *---------------------------------------------------------------------- */ void Tk_CreateClientMessageHandler( Tk_ClientMessageProc *proc) /* Function to call on event. */ { GenericHandler *handlerPtr; 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. */ 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; } else { tsdPtr->lastCmPtr->nextPtr = handlerPtr; } tsdPtr->lastCmPtr = handlerPtr; } /* *---------------------------------------------------------------------- * * Tk_DeleteClientMessageHandler -- * * Delete a previously-created ClientMessage handler. * * Results: * 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. * *---------------------------------------------------------------------- */ void Tk_DeleteClientMessageHandler( Tk_ClientMessageProc *proc) { GenericHandler * handler; ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); for (handler=tsdPtr->cmList ; handler!=NULL ; handler=handler->nextPtr) { if (handler->proc == (Tk_GenericProc *) proc) { handler->deleteFlag = 1; } } } /* *---------------------------------------------------------------------- * * TkEventInit -- * * 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. * * Side Effects: * None. * *---------------------------------------------------------------------- */ void TkEventInit(void) { ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); tsdPtr->handlersActive = 0; tsdPtr->pendingPtr = NULL; tsdPtr->genericList = NULL; tsdPtr->lastGenericPtr = NULL; tsdPtr->cmList = NULL; tsdPtr->lastCmPtr = NULL; tsdPtr->restrictProc = NULL; tsdPtr->restrictArg = NULL; } /* *---------------------------------------------------------------------- * * TkXErrorHandler -- * * 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. * * Side effects: * None. * *---------------------------------------------------------------------- */ static int TkXErrorHandler( ClientData clientData, /* Pointer to flag we set. */ XErrorEvent *errEventPtr) /* X error info. */ { int *error; error = (int *) clientData; *error = 1; return 0; } /* *---------------------------------------------------------------------- * * ParentXId -- * * Returns the parent of the given window, or "None" if the window * doesn't exist. * * Results: * Returns an X window ID. * * Side effects: * None. * *---------------------------------------------------------------------- */ static Window ParentXId( Display *display, Window w) { Tk_ErrorHandler handler; int gotXError; Status status; Window parent; Window root; Window *childList; unsigned int nChildren; /* * Handle errors ourselves. */ gotXError = 0; handler = Tk_CreateErrorHandler(display, -1, -1, -1, TkXErrorHandler, (ClientData) (&gotXError)); /* * Get the parent window. */ status = XQueryTree(display, w, &root, &parent, &childList, &nChildren); /* * Do some cleanup; gotta return "None" if we got an error. */ Tk_DeleteErrorHandler(handler); XSync(display, False); if (status != 0 && childList != NULL) { XFree(childList); } if (status == 0) { parent = None; } return parent; } /* *---------------------------------------------------------------------- * * Tk_HandleEvent -- * * Given an event, invoke all the handlers that have been registered for * the event. * * Results: * None. * * Side effects: * Depends on the handlers. * *---------------------------------------------------------------------- */ void Tk_HandleEvent( XEvent *eventPtr) /* Event to dispatch. */ { register TkEventHandler *handlerPtr; TkWindow *winPtr; unsigned long mask; InProgress ip; Tcl_Interp *interp = NULL; ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); UpdateButtonEventState(eventPtr); /* * If the generic handler processed this event we are done and can return. */ if (InvokeGenericHandlers(tsdPtr, eventPtr)) { goto releaseUserData; } if (RefreshKeyboardMappingIfNeeded(eventPtr)) { /* * We are done with a MappingNotify event. */ goto releaseUserData; } mask = GetEventMaskFromXEvent(eventPtr); winPtr = GetTkWindowFromXEvent(eventPtr); if (winPtr == NULL) { goto releaseUserData; } /* * 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). */ if ((winPtr->flags & TK_ALREADY_DEAD) && (eventPtr->type != DestroyNotify)) { goto releaseUserData; } 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. */ Tcl_Preserve((ClientData) interp); result = ((InvokeFocusHandlers(&winPtr, mask, eventPtr)) || (InvokeMouseHandlers(winPtr, mask, eventPtr))); if (result) { goto releaseInterpreter; } } #ifdef TK_USE_INPUT_METHODS if (InvokeInputMethods(winPtr, eventPtr)) { goto releaseInterpreter; } #endif /* * For events where it hasn't already been done, update the current time * in the display. */ if (eventPtr->type == PropertyNotify) { winPtr->dispPtr->lastEventTime = eventPtr->xproperty.time; } /* * There's a potential interaction here with Tk_DeleteEventHandler. Read * the documentation for pendingPtr. */ ip.eventPtr = eventPtr; ip.winPtr = winPtr; ip.nextHandler = NULL; ip.nextPtr = tsdPtr->pendingPtr; tsdPtr->pendingPtr = &ip; if (mask == 0) { if ((eventPtr->type == SelectionClear) || (eventPtr->type == SelectionRequest) || (eventPtr->type == SelectionNotify)) { TkSelEventProc((Tk_Window) winPtr, eventPtr); } else if (eventPtr->type == ClientMessage) { if (eventPtr->xclient.message_type == Tk_InternAtom((Tk_Window) winPtr, "WM_PROTOCOLS")) { TkWmProtocolEventProc(winPtr, eventPtr); } else { InvokeClientMessageHandlers(tsdPtr, (Tk_Window)winPtr, eventPtr); } } } else { for (handlerPtr = winPtr->handlerList; handlerPtr != NULL; ) { if ((handlerPtr->mask & mask) != 0) { ip.nextHandler = handlerPtr->nextPtr; (*(handlerPtr->proc))(handlerPtr->clientData, eventPtr); handlerPtr = ip.nextHandler; } else { handlerPtr = handlerPtr->nextPtr; } } /* * 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. */ if ((ip.winPtr != None) && ((mask != SubstructureNotifyMask) || (eventPtr->type == CreateNotify))) { TkBindEventProc(winPtr, eventPtr); } } tsdPtr->pendingPtr = ip.nextPtr; /* * Release the interpreter for this window so that it can be potentially * deleted if requested. */ 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. */ releaseUserData: if (eventPtr->type == VirtualEvent) { XVirtualEvent *vePtr = (XVirtualEvent *) eventPtr; if (vePtr->user_data != NULL) { Tcl_DecrRefCount(vePtr->user_data); vePtr->user_data = NULL; } } } /* *---------------------------------------------------------------------- * * TkEventDeadWindow -- * * This function is invoked when it is determined that a window is dead. * It cleans up event-related information about the window. * * Results: * None. * * Side effects: * Various things get cleaned up and recycled. * *---------------------------------------------------------------------- */ void 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)); /* * 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) { if (ipPtr->nextHandler == handlerPtr) { ipPtr->nextHandler = NULL; } if (ipPtr->winPtr == winPtr) { ipPtr->winPtr = None; } } ckfree((char *) handlerPtr); } } /* *---------------------------------------------------------------------- * * 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. * * 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. * * Side effects: * None. * *---------------------------------------------------------------------- */ Time TkCurrentTime( TkDisplay *dispPtr) /* Display for which the time is desired. */ { register XEvent *eventPtr; 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; } return dispPtr->lastEventTime; } /* *---------------------------------------------------------------------- * * Tk_RestrictEvents -- * * 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 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, * defer or discard each incoming X event. * *---------------------------------------------------------------------- */ Tk_RestrictProc * 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)); prev = tsdPtr->restrictProc; *prevArgPtr = tsdPtr->restrictArg; tsdPtr->restrictProc = proc; tsdPtr->restrictArg = arg; return prev; } /* *---------------------------------------------------------------------- * * Tk_CollapseMotionEvents -- * * This function controls whether we collapse motion events in a * particular display or not. * * Results: * The return value is the previous collapse value in effect. * * Side effects: * Filtering of motion events may be changed after calling this. * *---------------------------------------------------------------------- */ int 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); if (collapse) { dispPtr->flags |= TK_DISPLAY_COLLAPSE_MOTION_EVENTS; } else { dispPtr->flags &= ~TK_DISPLAY_COLLAPSE_MOTION_EVENTS; } return prev; } /* *---------------------------------------------------------------------- * * Tk_QueueWindowEvent -- * * 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. * *---------------------------------------------------------------------- */ void 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; /* * Find our display structure for the event's display. */ for (dispPtr = TkGetDisplayList(); ; dispPtr = dispPtr->nextPtr) { if (dispPtr == NULL) { return; } if (dispPtr->display == eventPtr->xany.display) { break; } } /* * 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; wevPtr->event = *eventPtr; Tcl_QueueEvent(&wevPtr->header, position); return; } if ((dispPtr->delayedMotionPtr != NULL) && (position == TCL_QUEUE_TAIL)) { 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. */ dispPtr->delayedMotionPtr->event = *eventPtr; return; } else if ((eventPtr->type != GraphicsExpose) && (eventPtr->type != NoExpose) && (eventPtr->type != Expose)) { /* * 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. */ Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, position); dispPtr->delayedMotionPtr = NULL; Tcl_CancelIdleCall(DelayedMotionProc, (ClientData) dispPtr); } } wevPtr = (TkWindowEvent *) ckalloc(sizeof(TkWindowEvent)); wevPtr->header.proc = WindowEventProc; 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. */ if (dispPtr->delayedMotionPtr != NULL) { Tcl_Panic("Tk_QueueWindowEvent found unexpected delayed motion event"); } dispPtr->delayedMotionPtr = wevPtr; Tcl_DoWhenIdle(DelayedMotionProc, (ClientData) dispPtr); } else { Tcl_QueueEvent(&wevPtr->header, position); } } /* *---------------------------------------------------------------------- * * TkQueueEventForAllChildren -- * * Given an XEvent, recursively queue the event for this window and all * non-toplevel children of the given window. * * Results: * None. * * Side effects: * Events queued. * *---------------------------------------------------------------------- */ void TkQueueEventForAllChildren( TkWindow *winPtr, /* Window to which event is sent. */ XEvent *eventPtr) /* The event to be sent. */ { TkWindow *childPtr; if (!Tk_IsMapped(winPtr)) { return; } eventPtr->xany.window = winPtr->window; Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL); childPtr = winPtr->childList; while (childPtr != NULL) { if (!Tk_TopWinHierarchy(childPtr)) { TkQueueEventForAllChildren(childPtr, eventPtr); } childPtr = childPtr->nextPtr; } } /* *---------------------------------------------------------------------- * * WindowEventProc -- * * 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. * * Side effects: * Whatever the event handlers for the event do. * *---------------------------------------------------------------------- */ static int 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)); if (!(flags & TCL_WINDOW_EVENTS)) { return 0; } if (tsdPtr->restrictProc != NULL) { result = (*tsdPtr->restrictProc)(tsdPtr->restrictArg, &wevPtr->event); if (result != TK_PROCESS_EVENT) { if (result == TK_DEFER_EVENT) { return 0; } else { /* * TK_DELETE_EVENT: return and say we processed the event, * even though we didn't do anything at all. */ return 1; } } } Tk_HandleEvent(&wevPtr->event); return 1; } /* *---------------------------------------------------------------------- * * DelayedMotionProc -- * * 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. * *---------------------------------------------------------------------- */ static void DelayedMotionProc( ClientData clientData) /* Pointer to display containing a delayed * motion event to be serviced. */ { TkDisplay *dispPtr = (TkDisplay *) clientData; if (dispPtr->delayedMotionPtr == NULL) { 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. * * Results: * None. * * Side effects: * Arbitrary; depends on handlers for events. * *---------------------------------------------------------------------- */ void Tk_MainLoop(void) { while (Tk_GetNumMainWindows() > 0) { Tcl_DoOneEvent(0); } } /* * Local Variables: * mode: c * c-basic-offset: 4 * fill-column: 78 * End: */