/* * tkUnixXId.c -- * * This file provides a replacement function for the default X resource * allocator (_XAllocID). The problem with the default allocator is that * it never re-uses ids, which causes long-lived applications to crash * when X resource identifiers wrap around. The replacement functions in * this file re-use old identifiers to prevent this problem. * * The code in this file is based on similar implementations by * George C. Kaplan and Michael Hoegeman. * * Copyright (c) 1993 The Regents of the University of California. * Copyright (c) 1994-1997 Sun Microsystems, Inc. * * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ /* * The definition below is needed on some systems so that we can access the * resource_alloc field of Display structures in order to replace the resource * allocator. */ #define XLIB_ILLEGAL_ACCESS 1 #include "tkUnixInt.h" /* * A structure of the following type is used to hold one or more available * resource identifiers. There is a list of these structures for each display. */ #define IDS_PER_STACK 10 typedef struct TkIdStack { XID ids[IDS_PER_STACK]; /* Array of free identifiers. */ int numUsed; /* Indicates how many of the entries in ids * are currently in use. */ TkDisplay *dispPtr; /* Display to which ids belong. */ struct TkIdStack *nextPtr; /* Next bunch of free identifiers for the same * display. */ } TkIdStack; /* * Forward declarations for functions defined in this file: */ static XID AllocXId(Display *display); static Tk_RestrictAction CheckRestrictProc(ClientData clientData, XEvent *eventPtr); static void WindowIdCleanup(ClientData clientData); static void WindowIdCleanup2(ClientData clientData); /* *---------------------------------------------------------------------- * * TkInitXId -- * * This function is called to initialize the id allocator for a given * display. * * Results: * None. * * Side effects: * The official allocator for the display is set up to be AllocXId. * *---------------------------------------------------------------------- */ void TkInitXId( TkDisplay *dispPtr) /* Tk's information about the display. */ { dispPtr->idStackPtr = NULL; dispPtr->defaultAllocProc = (XID (*) (Display *display)) dispPtr->display->resource_alloc; dispPtr->display->resource_alloc = AllocXId; dispPtr->windowStackPtr = NULL; dispPtr->idCleanupScheduled = (Tcl_TimerToken) 0; } /* *---------------------------------------------------------------------- * * TkFreeXId -- * * This function is called to free resources for the id allocator for a * given display. * * Results: * None. * * Side effects: * Frees the id and window stack pools. * *---------------------------------------------------------------------- */ void TkFreeXId( TkDisplay *dispPtr) /* Tk's information about the display. */ { TkIdStack *stackPtr, *freePtr; if (dispPtr->idCleanupScheduled) { Tcl_DeleteTimerHandler(dispPtr->idCleanupScheduled); } for (stackPtr = dispPtr->idStackPtr; stackPtr != NULL; ) { freePtr = stackPtr; stackPtr = stackPtr->nextPtr; ckfree((char *) freePtr); } dispPtr->idStackPtr = NULL; for (stackPtr = dispPtr->windowStackPtr; stackPtr != NULL; ) { freePtr = stackPtr; stackPtr = stackPtr->nextPtr; ckfree((char *) freePtr); } dispPtr->windowStackPtr = NULL; } /* *---------------------------------------------------------------------- * * AllocXId -- * * This function is invoked by Xlib as the resource allocator for a * display. * * Results: * The return value is an X resource identifier that isn't currently in * use. * * Side effects: * The identifier is removed from the stack of free identifiers, if it * was previously on the stack. * *---------------------------------------------------------------------- */ static XID AllocXId( Display *display) /* Display for which to allocate. */ { TkDisplay *dispPtr; TkIdStack *stackPtr; /* * Find Tk's information about the display. */ dispPtr = TkGetDisplay(display); /* * If the topmost chunk on the stack is empty then free it. Then check for * a free id on the stack and return it if it exists. */ stackPtr = dispPtr->idStackPtr; if (stackPtr != NULL) { while (stackPtr->numUsed == 0) { dispPtr->idStackPtr = stackPtr->nextPtr; ckfree((char *) stackPtr); stackPtr = dispPtr->idStackPtr; if (stackPtr == NULL) { goto defAlloc; } } stackPtr->numUsed--; return stackPtr->ids[stackPtr->numUsed]; } /* * No free ids in the stack: just get one from the default allocator. */ defAlloc: return (*dispPtr->defaultAllocProc)(display); } /* *---------------------------------------------------------------------- * * Tk_FreeXId -- * * This function is called to indicate that an X resource identifier is * now free. * * Results: * None. * * Side effects: * The identifier is added to the stack of free identifiers for its * display, so that it can be re-used. * *---------------------------------------------------------------------- */ void Tk_FreeXId( Display *display, /* Display for which xid was allocated. */ XID xid) /* Identifier that is no longer in use. */ { TkDisplay *dispPtr; TkIdStack *stackPtr; /* * Find Tk's information about the display. */ dispPtr = TkGetDisplay(display); /* * Add a new chunk to the stack if the current chunk is full. */ stackPtr = dispPtr->idStackPtr; if ((stackPtr == NULL) || (stackPtr->numUsed >= IDS_PER_STACK)) { stackPtr = (TkIdStack *) ckalloc(sizeof(TkIdStack)); stackPtr->numUsed = 0; stackPtr->dispPtr = dispPtr; stackPtr->nextPtr = dispPtr->idStackPtr; dispPtr->idStackPtr = stackPtr; } /* * Add the id to the current chunk. */ stackPtr->ids[stackPtr->numUsed] = xid; stackPtr->numUsed++; } /* *---------------------------------------------------------------------- * * TkFreeWindowId -- * * This function is invoked instead of TkFreeXId for window ids. See * below for the reason why. * * Results: * None. * * Side effects: * The id given by w will eventually be freed, so that it can be reused * for other resources. * * Design: * Freeing window ids is very tricky because there could still be events * pending for a window in the event queue (or even in the server) at the * time the window is destroyed. If the window id were to get reused * immediately for another window, old events could "drop in" on the new * window, causing unexpected behavior. * * Thus we have to wait to re-use a window id until we know that there * are no events left for it. Right now this is done in two steps. First, * we wait until we know that the server has seen the XDestroyWindow * request, so we can be sure that it won't generate more events for the * window and that any existing events are in our queue. Second, we make * sure that there are no events whatsoever in our queue (this is * conservative but safe). * * The first step is done by remembering the request id of the * XDestroyWindow request and using LastKnownRequestProcessed to see what * events the server has processed. If multiple windows get destroyed at * about the same time, we just remember the most recent request number * for any of them (again, conservative but safe). * * There are a few other complications as well. When Tk destroys a * sub-tree of windows, it only issues a single XDestroyWindow call, at * the very end for the root of the subtree. We can't free any of the * window ids until the final XDestroyWindow call. To make sure that this * happens, we have to keep track of deletions in progress, hence the * need for the "destroyCount" field of the display. * * One final problem. Some servers, like Sun X11/News servers still seem * to have problems with ids getting reused too quickly. I'm not * completely sure why this is a problem, but delaying the recycling of * ids appears to eliminate it. Therefore, we wait an additional few * seconds, even after "the coast is clear" before reusing the ids. * *---------------------------------------------------------------------- */ void TkFreeWindowId( TkDisplay *dispPtr, /* Display that w belongs to. */ Window w) /* X identifier for window on dispPtr. */ { TkIdStack *stackPtr; /* * Put the window id on a separate stack of window ids, rather than the * main stack, so it won't get reused right away. Add a new chunk to the * stack if the current chunk is full. */ stackPtr = dispPtr->windowStackPtr; if ((stackPtr == NULL) || (stackPtr->numUsed >= IDS_PER_STACK)) { stackPtr = (TkIdStack *) ckalloc(sizeof(TkIdStack)); stackPtr->numUsed = 0; stackPtr->dispPtr = dispPtr; stackPtr->nextPtr = dispPtr->windowStackPtr; dispPtr->windowStackPtr = stackPtr; } /* * Add the id to the current chunk. */ stackPtr->ids[stackPtr->numUsed] = w; stackPtr->numUsed++; /* * Schedule a call to WindowIdCleanup if one isn't already scheduled. */ if (!dispPtr->idCleanupScheduled) { dispPtr->idCleanupScheduled = Tcl_CreateTimerHandler(100, WindowIdCleanup, (ClientData) dispPtr); } } /* *---------------------------------------------------------------------- * * WindowIdCleanup -- * * See if we can now free up all the accumulated ids of deleted windows. * * Results: * None. * * Side effects: * If it's safe to move the window ids back to the main free list, we * schedule this to happen after a few mores seconds of delay. If it's * not safe to move them yet, a timer handler gets invoked to try again * later. * *---------------------------------------------------------------------- */ static void WindowIdCleanup( ClientData clientData) /* Pointer to TkDisplay for display */ { TkDisplay *dispPtr = (TkDisplay *) clientData; int anyEvents, delta; Tk_RestrictProc *oldProc; ClientData oldData; static Tcl_Time timeout = {0, 0}; dispPtr->idCleanupScheduled = (Tcl_TimerToken) 0; /* * See if it's safe to recycle the window ids. It's safe if: * (a) no deletions are in progress. * (b) the server has seen all of the requests up to the last * XDestroyWindow request. * (c) there are no events in the event queue; the only way to test for * this right now is to create a restrict proc that will filter the * events, then call Tcl_DoOneEvent to see if the function gets * invoked. */ if (dispPtr->destroyCount > 0) { goto tryAgain; } delta = LastKnownRequestProcessed(dispPtr->display) - dispPtr->lastDestroyRequest; if (delta < 0) { XSync(dispPtr->display, False); } anyEvents = 0; oldProc = Tk_RestrictEvents(CheckRestrictProc, (ClientData) &anyEvents, &oldData); TkUnixDoOneXEvent(&timeout); Tk_RestrictEvents(oldProc, oldData, &oldData); if (anyEvents) { goto tryAgain; } /* * These ids look safe to recycle, but we still need to delay a bit more * (see comments for TkFreeWindowId). Schedule the final freeing. */ if (dispPtr->windowStackPtr != NULL) { Tcl_CreateTimerHandler(5000, WindowIdCleanup2, (ClientData) dispPtr->windowStackPtr); dispPtr->windowStackPtr = NULL; } return; /* * It's still not safe to free up the ids. Try again a bit later. */ tryAgain: dispPtr->idCleanupScheduled = Tcl_CreateTimerHandler(500, WindowIdCleanup, (ClientData) dispPtr); } /* *---------------------------------------------------------------------- * * WindowIdCleanup2 -- * * This function is the last one in the chain that recycles window ids. * It takes all of the ids indicated by its argument and adds them back * to the main id free list. * * Results: * None. * * Side effects: * Window ids get added to the main free list for their display. * *---------------------------------------------------------------------- */ static void WindowIdCleanup2( ClientData clientData) /* Pointer to TkIdStack list. */ { TkIdStack *stackPtr = (TkIdStack *) clientData; TkIdStack *lastPtr; lastPtr = stackPtr; while (lastPtr->nextPtr != NULL) { lastPtr = lastPtr->nextPtr; } lastPtr->nextPtr = stackPtr->dispPtr->idStackPtr; stackPtr->dispPtr->idStackPtr = stackPtr; } /* *---------------------------------------------------------------------- * * CheckRestrictProc -- * * This function is a restrict function, called by Tcl_DoOneEvent to * filter X events. All it does is to set a flag to indicate that there * are X events present. * * Results: * Sets the integer pointed to by the argument, then returns * TK_DEFER_EVENT. * * Side effects: * None. * *---------------------------------------------------------------------- */ static Tk_RestrictAction CheckRestrictProc( ClientData clientData, /* Pointer to flag to set. */ XEvent *eventPtr) /* Event to filter; not used. */ { int *flag = (int *) clientData; *flag = 1; return TK_DEFER_EVENT; } /* *---------------------------------------------------------------------- * * Tk_GetPixmap -- * * Same as the XCreatePixmap function except that it manages resource * identifiers better. * * Results: * Returns a new pixmap. * * Side effects: * None. * *---------------------------------------------------------------------- */ Pixmap Tk_GetPixmap( Display *display, /* Display for new pixmap. */ Drawable d, /* Drawable where pixmap will be used. */ int width, int height, /* Dimensions of pixmap. */ int depth) /* Bits per pixel for pixmap. */ { return XCreatePixmap(display, d, (unsigned) width, (unsigned) height, (unsigned) depth); } /* *---------------------------------------------------------------------- * * Tk_FreePixmap -- * * Same as the XFreePixmap function except that it also marks the * resource identifier as free. * * Results: * None. * * Side effects: * The pixmap is freed in the X server and its resource identifier is * saved for re-use. * *---------------------------------------------------------------------- */ void Tk_FreePixmap( Display *display, /* Display for which pixmap was allocated. */ Pixmap pixmap) /* Identifier for pixmap. */ { XFreePixmap(display, pixmap); Tk_FreeXId(display, (XID) pixmap); } /* *---------------------------------------------------------------------- * * TkpWindowWasRecentlyDeleted -- * * Checks whether the window was recently deleted. This is called by the * generic error handler to detect asynchronous notification of errors * due to operations by Tk on a window that was already deleted by the * server. * * Results: * 1 if the window was deleted recently, 0 otherwise. * * Side effects: * None. * *---------------------------------------------------------------------- */ int TkpWindowWasRecentlyDeleted( Window win, /* The window to check for. */ TkDisplay *dispPtr) /* The window belongs to this display. */ { TkIdStack *stackPtr; int i; for (stackPtr = dispPtr->windowStackPtr; stackPtr != NULL; stackPtr = stackPtr->nextPtr) { for (i = 0; i < stackPtr->numUsed; i++) { if ((Window) stackPtr->ids[i] == win) { return 1; } } } return 0; } /* *---------------------------------------------------------------------- * * TkpScanWindowId -- * * Given a string, produce the corresponding Window Id. * * Results: * The return value is normally TCL_OK; in this case *idPtr will be set * to the Window value equivalent to string. If string is improperly * formed then TCL_ERROR is returned and an error message will be left in * the interp's result. * * Side effects: * None. * *---------------------------------------------------------------------- */ int TkpScanWindowId( Tcl_Interp *interp, CONST char *string, Window *idPtr) { int value; if (Tcl_GetInt(interp, string, &value) != TCL_OK) { return TCL_ERROR; } *idPtr = (Window) value; return TCL_OK; } /* * Local Variables: * mode: c * c-basic-offset: 4 * fill-column: 78 * End: */