shared/tk_base/tkerror.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkerror.c,v 1.1.1.1 2001/06/13 05:00:00 dtashley Exp $ */

/* 
 * tkError.c --
 *
 *      This file provides a high-performance mechanism for
 *      selectively dealing with errors that occur in talking
 *      to the X server.  This is useful, for example, when
 *      communicating with a window that may not exist.
 *
 * Copyright (c) 1990-1994 The Regents of the University of California.
 * Copyright (c) 1994-1995 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tkerror.c,v 1.1.1.1 2001/06/13 05:00:00 dtashley Exp $
 */

#include "tkPort.h"
#include "tkInt.h"

/*
 * The default X error handler gets saved here, so that it can
 * be invoked if an error occurs that we can't handle.
 */

static int      (*defaultHandler) _ANSI_ARGS_((Display *display,
                    XErrorEvent *eventPtr)) = NULL;


/*
 * Forward references to procedures declared later in this file:
 */

static int      ErrorProc _ANSI_ARGS_((Display *display,
                    XErrorEvent *errEventPtr));

/*
 *--------------------------------------------------------------
 *
 * Tk_CreateErrorHandler --
 *
 *      Arrange for all a given procedure to be invoked whenever
 *      certain errors occur.
 *
 * Results:
 *      The return value is a token identifying the handler;
 *      it must be passed to Tk_DeleteErrorHandler to delete the
 *      handler.
 *
 * Side effects:
 *      If an X error occurs that matches the error, request,
 *      and minor arguments, then errorProc will be invoked.
 *      ErrorProc should have the following structure:
 *
 *      int
 *      errorProc(clientData, errorEventPtr)
 *          caddr_t clientData;
 *          XErrorEvent *errorEventPtr;
 *      {
 *      }
 *
 *      The clientData argument will be the same as the clientData
 *      argument to this procedure, and errorEvent will describe
 *      the error.  If errorProc returns 0, it means that it
 *      completely "handled" the error:  no further processing
 *      should be done.  If errorProc returns 1, it means that it
 *      didn't know how to deal with the error, so we should look
 *      for other error handlers, or invoke the default error
 *      handler if no other handler returns zero.  Handlers are
 *      invoked in order of age:  youngest handler first.
 *
 *      Note:  errorProc will only be called for errors associated
 *      with X requests made AFTER this call, but BEFORE the handler
 *      is deleted by calling Tk_DeleteErrorHandler.
 *
 *--------------------------------------------------------------
 */

Tk_ErrorHandler
Tk_CreateErrorHandler(display, error, request, minorCode, errorProc, clientData)
    Display *display;           /* Display for which to handle
                                 * errors. */
    int error;                  /* Consider only errors with this
                                 * error_code (-1 means consider
                                 * all errors). */
    int request;                /* Consider only errors with this
                                 * major request code (-1 means
                                 * consider all major codes). */
    int minorCode;              /* Consider only errors with this
                                 * minor request code (-1 means
                                 * consider all minor codes). */
    Tk_ErrorProc *errorProc;    /* Procedure to invoke when a
                                 * matching error occurs.  NULL means
                                 * just ignore matching errors. */
    ClientData clientData;      /* Arbitrary value to pass to
                                 * errorProc. */
{
    register TkErrorHandler *errorPtr;
    register TkDisplay *dispPtr;

    /*
     * Find the display.  If Tk doesn't know about this display then
     * it's an error:  panic.
     */

    dispPtr = TkGetDisplay(display);
    if (dispPtr == NULL) {
        panic("Unknown display passed to Tk_CreateErrorHandler");
    }

    /*
     * Make sure that X calls us whenever errors occur.
     */

    if (defaultHandler == NULL) {
        defaultHandler = XSetErrorHandler(ErrorProc);
    }

    /*
     * Create the handler record.
     */

    errorPtr = (TkErrorHandler *) ckalloc(sizeof(TkErrorHandler));
    errorPtr->dispPtr = dispPtr;
    errorPtr->firstRequest = NextRequest(display);
    errorPtr->lastRequest = (unsigned) -1;
    errorPtr->error = error;
    errorPtr->request = request;
    errorPtr->minorCode = minorCode;
    errorPtr->errorProc = errorProc;
    errorPtr->clientData = clientData;
    errorPtr->nextPtr = dispPtr->errorPtr;
    dispPtr->errorPtr = errorPtr;

    return (Tk_ErrorHandler) errorPtr;
}

/*
 *--------------------------------------------------------------
 *
 * Tk_DeleteErrorHandler --
 *
 *      Do not use an error handler anymore.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The handler denoted by the "handler" argument will not
 *      be invoked for any X errors associated with requests
 *      made after this call.  However, if errors arrive later
 *      for requests made BEFORE this call, then the handler
 *      will still be invoked.  Call XSync if you want to be
 *      sure that all outstanding errors have been received
 *      and processed.
 *
 *--------------------------------------------------------------
 */

void
Tk_DeleteErrorHandler(handler)
    Tk_ErrorHandler handler;    /* Token for handler to delete;
                                 * was previous return value from
                                 * Tk_CreateErrorHandler. */
{
    register TkErrorHandler *errorPtr = (TkErrorHandler *) handler;
    register TkDisplay *dispPtr = errorPtr->dispPtr;

    errorPtr->lastRequest = NextRequest(dispPtr->display) - 1;

    /*
     * Every once-in-a-while, cleanup handlers that are no longer
     * active.  We probably won't be able to free the handler that
     * was just deleted (need to wait for any outstanding requests to
     * be processed by server), but there may be previously-deleted
     * handlers that are now ready for garbage collection.  To reduce
     * the cost of the cleanup, let a few dead handlers pile up, then
     * clean them all at once.  This adds a bit of overhead to errors
     * that might occur while the dead handlers are hanging around,
     * but reduces the overhead of scanning the list to clean up
     * (particularly if there are many handlers that stay around
     * forever).
     */

    dispPtr->deleteCount += 1;
    if (dispPtr->deleteCount >= 10) {
        register TkErrorHandler *prevPtr;
        TkErrorHandler *nextPtr;
        int lastSerial;

        dispPtr->deleteCount = 0;
        lastSerial = LastKnownRequestProcessed(dispPtr->display);
        errorPtr = dispPtr->errorPtr;
        for (prevPtr = NULL; errorPtr != NULL; errorPtr = nextPtr) {
            nextPtr = errorPtr->nextPtr;
            if ((errorPtr->lastRequest != (unsigned long) -1)
                    && (errorPtr->lastRequest <= (unsigned long) lastSerial)) {
                if (prevPtr == NULL) {
                    dispPtr->errorPtr = nextPtr;
                } else {
                    prevPtr->nextPtr = nextPtr;
                }
                ckfree((char *) errorPtr);
                continue;
            }
            prevPtr = errorPtr;
        }
    }
}

/*
 *--------------------------------------------------------------
 *
 * ErrorProc --
 *
 *      This procedure is invoked by the X system when error
 *      events arrive.
 *
 * Results:
 *      If it returns, the return value is zero.  However,
 *      it is possible that one of the error handlers may
 *      just exit.
 *
 * Side effects:
 *      This procedure does two things.  First, it uses the
 *      serial #  in the error event to eliminate handlers whose
 *      expiration serials are now in the past.  Second, it
 *      invokes any handlers that want to deal with the error.
 *
 *--------------------------------------------------------------
 */

static int
ErrorProc(display, errEventPtr)
    Display *display;                   /* Display for which error
                                         * occurred. */
    register XErrorEvent *errEventPtr;  /* Information about error. */
{
    register TkDisplay *dispPtr;
    register TkErrorHandler *errorPtr;

    /*
     * See if we know anything about the display.  If not, then
     * invoke the default error handler.
     */

    dispPtr = TkGetDisplay(display);
    if (dispPtr == NULL) {
        goto couldntHandle;
    }

    /*
     * Otherwise invoke any relevant handlers for the error, in order.
     */

    for (errorPtr = dispPtr->errorPtr; errorPtr != NULL;
            errorPtr = errorPtr->nextPtr) {
        if ((errorPtr->firstRequest > errEventPtr->serial)
                || ((errorPtr->error != -1)
                    && (errorPtr->error != errEventPtr->error_code))
                || ((errorPtr->request != -1)
                    && (errorPtr->request != errEventPtr->request_code))
                || ((errorPtr->minorCode != -1)
                    && (errorPtr->minorCode != errEventPtr->minor_code))
                || ((errorPtr->lastRequest != (unsigned long) -1)
                    && (errorPtr->lastRequest < errEventPtr->serial))) {
            continue;
        }
        if (errorPtr->errorProc == NULL) {
            return 0;
        } else {
            if ((*errorPtr->errorProc)(errorPtr->clientData,
                    errEventPtr) == 0) {
                return 0;
            }
        }
    }

    /*
     * See if the error is a BadWindow error.  If so, and it refers
     * to a window that still exists in our window table, then ignore
     * the error.  Errors like this can occur if a window owned by us
     * is deleted by someone externally, like a window manager.  We'll
     * ignore the errors at least long enough to clean up internally and
     * remove the entry from the window table.
     *
     * NOTE: For embedding, we must also check whether the window was
     * recently deleted. If so, it may be that Tk generated operations on
     * windows that were deleted by the container. Now we are getting
     * the errors (BadWindow) after Tk already deleted the window itself.
     */

    if ((errEventPtr->error_code == BadWindow) &&
            ((Tk_IdToWindow(display, (Window) errEventPtr->resourceid) !=
                    NULL) ||
                (TkpWindowWasRecentlyDeleted((Window) errEventPtr->resourceid,
                        dispPtr)))) {
        return 0;
    }

    /*
     * We couldn't handle the error.  Use the default handler.
     */

    couldntHandle:
    return (*defaultHandler)(display, errEventPtr);
}


/* $History: tkError.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 2:50a
 * Created in $/IjuScripter, IjuConsole/Source/Tk Base
 * Initial check-in.
 */

/* End of TKERROR.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkerror.c,v 1.1.1.1 2001/06/13 05:00:00 dtashley Exp $ */
2
3			/*
4			* tkError.c --
5			*
6			* This file provides a high-performance mechanism for
7			* selectively dealing with errors that occur in talking
8			* to the X server. This is useful, for example, when
9			* communicating with a window that may not exist.
10			*
11			* Copyright (c) 1990-1994 The Regents of the University of California.
12			* Copyright (c) 1994-1995 Sun Microsystems, Inc.
13			*
14			* See the file "license.terms" for information on usage and redistribution
15			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
16			*
17			* RCS: @(#) $Id: tkerror.c,v 1.1.1.1 2001/06/13 05:00:00 dtashley Exp $
18			*/
19
20			#include "tkPort.h"
21			#include "tkInt.h"
22
23			/*
24			* The default X error handler gets saved here, so that it can
25			* be invoked if an error occurs that we can't handle.
26			*/
27
28			static int (defaultHandler) _ANSI_ARGS_((Display display,
29			XErrorEvent *eventPtr)) = NULL;
30
31
32			/*
33			* Forward references to procedures declared later in this file:
34			*/
35
36			static int ErrorProc _ANSI_ARGS_((Display *display,
37			XErrorEvent *errEventPtr));
38
39			/*
40			*--------------------------------------------------------------
41			*
42			* Tk_CreateErrorHandler --
43			*
44			* Arrange for all a given procedure to be invoked whenever
45			* certain errors occur.
46			*
47			* Results:
48			* The return value is a token identifying the handler;
49			* it must be passed to Tk_DeleteErrorHandler to delete the
50			* handler.
51			*
52			* Side effects:
53			* If an X error occurs that matches the error, request,
54			* and minor arguments, then errorProc will be invoked.
55			* ErrorProc should have the following structure:
56			*
57			* int
58			* errorProc(clientData, errorEventPtr)
59			* caddr_t clientData;
60			* XErrorEvent *errorEventPtr;
61			* {
62			* }
63			*
64			* The clientData argument will be the same as the clientData
65			* argument to this procedure, and errorEvent will describe
66			* the error. If errorProc returns 0, it means that it
67			* completely "handled" the error: no further processing
68			* should be done. If errorProc returns 1, it means that it
69			* didn't know how to deal with the error, so we should look
70			* for other error handlers, or invoke the default error
71			* handler if no other handler returns zero. Handlers are
72			* invoked in order of age: youngest handler first.
73			*
74			* Note: errorProc will only be called for errors associated
75			* with X requests made AFTER this call, but BEFORE the handler
76			* is deleted by calling Tk_DeleteErrorHandler.
77			*
78			*--------------------------------------------------------------
79			*/
80
81			Tk_ErrorHandler
82			Tk_CreateErrorHandler(display, error, request, minorCode, errorProc, clientData)
83			Display display; / Display for which to handle
84			* errors. */
85			int error; /* Consider only errors with this
86			* error_code (-1 means consider
87			* all errors). */
88			int request; /* Consider only errors with this
89			* major request code (-1 means
90			* consider all major codes). */
91			int minorCode; /* Consider only errors with this
92			* minor request code (-1 means
93			* consider all minor codes). */
94			Tk_ErrorProc errorProc; / Procedure to invoke when a
95			* matching error occurs. NULL means
96			* just ignore matching errors. */
97			ClientData clientData; /* Arbitrary value to pass to
98			* errorProc. */
99			{
100			register TkErrorHandler *errorPtr;
101			register TkDisplay *dispPtr;
102
103			/*
104			* Find the display. If Tk doesn't know about this display then
105			* it's an error: panic.
106			*/
107
108			dispPtr = TkGetDisplay(display);
109			if (dispPtr == NULL) {
110			panic("Unknown display passed to Tk_CreateErrorHandler");
111			}
112
113			/*
114			* Make sure that X calls us whenever errors occur.
115			*/
116
117			if (defaultHandler == NULL) {
118			defaultHandler = XSetErrorHandler(ErrorProc);
119			}
120
121			/*
122			* Create the handler record.
123			*/
124
125			errorPtr = (TkErrorHandler *) ckalloc(sizeof(TkErrorHandler));
126			errorPtr->dispPtr = dispPtr;
127			errorPtr->firstRequest = NextRequest(display);
128			errorPtr->lastRequest = (unsigned) -1;
129			errorPtr->error = error;
130			errorPtr->request = request;
131			errorPtr->minorCode = minorCode;
132			errorPtr->errorProc = errorProc;
133			errorPtr->clientData = clientData;
134			errorPtr->nextPtr = dispPtr->errorPtr;
135			dispPtr->errorPtr = errorPtr;
136
137			return (Tk_ErrorHandler) errorPtr;
138			}
139
140			/*
141			*--------------------------------------------------------------
142			*
143			* Tk_DeleteErrorHandler --
144			*
145			* Do not use an error handler anymore.
146			*
147			* Results:
148			* None.
149			*
150			* Side effects:
151			* The handler denoted by the "handler" argument will not
152			* be invoked for any X errors associated with requests
153			* made after this call. However, if errors arrive later
154			* for requests made BEFORE this call, then the handler
155			* will still be invoked. Call XSync if you want to be
156			* sure that all outstanding errors have been received
157			* and processed.
158			*
159			*--------------------------------------------------------------
160			*/
161
162			void
163			Tk_DeleteErrorHandler(handler)
164			Tk_ErrorHandler handler; /* Token for handler to delete;
165			* was previous return value from
166			* Tk_CreateErrorHandler. */
167			{
168			register TkErrorHandler errorPtr = (TkErrorHandler ) handler;
169			register TkDisplay *dispPtr = errorPtr->dispPtr;
170
171			errorPtr->lastRequest = NextRequest(dispPtr->display) - 1;
172
173			/*
174			* Every once-in-a-while, cleanup handlers that are no longer
175			* active. We probably won't be able to free the handler that
176			* was just deleted (need to wait for any outstanding requests to
177			* be processed by server), but there may be previously-deleted
178			* handlers that are now ready for garbage collection. To reduce
179			* the cost of the cleanup, let a few dead handlers pile up, then
180			* clean them all at once. This adds a bit of overhead to errors
181			* that might occur while the dead handlers are hanging around,
182			* but reduces the overhead of scanning the list to clean up
183			* (particularly if there are many handlers that stay around
184			* forever).
185			*/
186
187			dispPtr->deleteCount += 1;
188			if (dispPtr->deleteCount >= 10) {
189			register TkErrorHandler *prevPtr;
190			TkErrorHandler *nextPtr;
191			int lastSerial;
192
193			dispPtr->deleteCount = 0;
194			lastSerial = LastKnownRequestProcessed(dispPtr->display);
195			errorPtr = dispPtr->errorPtr;
196			for (prevPtr = NULL; errorPtr != NULL; errorPtr = nextPtr) {
197			nextPtr = errorPtr->nextPtr;
198			if ((errorPtr->lastRequest != (unsigned long) -1)
199			&& (errorPtr->lastRequest <= (unsigned long) lastSerial)) {
200			if (prevPtr == NULL) {
201			dispPtr->errorPtr = nextPtr;
202			} else {
203			prevPtr->nextPtr = nextPtr;
204			}
205			ckfree((char *) errorPtr);
206			continue;
207			}
208			prevPtr = errorPtr;
209			}
210			}
211			}
212
213			/*
214			*--------------------------------------------------------------
215			*
216			* ErrorProc --
217			*
218			* This procedure is invoked by the X system when error
219			* events arrive.
220			*
221			* Results:
222			* If it returns, the return value is zero. However,
223			* it is possible that one of the error handlers may
224			* just exit.
225			*
226			* Side effects:
227			* This procedure does two things. First, it uses the
228			* serial # in the error event to eliminate handlers whose
229			* expiration serials are now in the past. Second, it
230			* invokes any handlers that want to deal with the error.
231			*
232			*--------------------------------------------------------------
233			*/
234
235			static int
236			ErrorProc(display, errEventPtr)
237			Display display; / Display for which error
238			* occurred. */
239			register XErrorEvent errEventPtr; / Information about error. */
240			{
241			register TkDisplay *dispPtr;
242			register TkErrorHandler *errorPtr;
243
244			/*
245			* See if we know anything about the display. If not, then
246			* invoke the default error handler.
247			*/
248
249			dispPtr = TkGetDisplay(display);
250			if (dispPtr == NULL) {
251			goto couldntHandle;
252			}
253
254			/*
255			* Otherwise invoke any relevant handlers for the error, in order.
256			*/
257
258			for (errorPtr = dispPtr->errorPtr; errorPtr != NULL;
259			errorPtr = errorPtr->nextPtr) {
260			if ((errorPtr->firstRequest > errEventPtr->serial)
261			\|\| ((errorPtr->error != -1)
262			&& (errorPtr->error != errEventPtr->error_code))
263			\|\| ((errorPtr->request != -1)
264			&& (errorPtr->request != errEventPtr->request_code))
265			\|\| ((errorPtr->minorCode != -1)
266			&& (errorPtr->minorCode != errEventPtr->minor_code))
267			\|\| ((errorPtr->lastRequest != (unsigned long) -1)
268			&& (errorPtr->lastRequest < errEventPtr->serial))) {
269			continue;
270			}
271			if (errorPtr->errorProc == NULL) {
272			return 0;
273			} else {
274			if ((*errorPtr->errorProc)(errorPtr->clientData,
275			errEventPtr) == 0) {
276			return 0;
277			}
278			}
279			}
280
281			/*
282			* See if the error is a BadWindow error. If so, and it refers
283			* to a window that still exists in our window table, then ignore
284			* the error. Errors like this can occur if a window owned by us
285			* is deleted by someone externally, like a window manager. We'll
286			* ignore the errors at least long enough to clean up internally and
287			* remove the entry from the window table.
288			*
289			* NOTE: For embedding, we must also check whether the window was
290			* recently deleted. If so, it may be that Tk generated operations on
291			* windows that were deleted by the container. Now we are getting
292			* the errors (BadWindow) after Tk already deleted the window itself.
293			*/
294
295			if ((errEventPtr->error_code == BadWindow) &&
296			((Tk_IdToWindow(display, (Window) errEventPtr->resourceid) !=
297			NULL) \|\|
298			(TkpWindowWasRecentlyDeleted((Window) errEventPtr->resourceid,
299			dispPtr)))) {
300			return 0;
301			}
302
303			/*
304			* We couldn't handle the error. Use the default handler.
305			*/
306
307			couldntHandle:
308			return (*defaultHandler)(display, errEventPtr);
309			}
310
311
312			/* $History: tkError.c $
313			*
314			* *************** Version 1 ***************
315			* User: Dtashley Date: 1/02/01 Time: 2:50a
316			* Created in $/IjuScripter, IjuConsole/Source/Tk Base
317			* Initial check-in.
318			*/
319
320			/* End of TKERROR.C */