shared_source/c_tk_base_7_5_w_mods/tkerror.c

/* $Header$ */

/* 
 * 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);
}

/* End of tkerror.c */
1	/* $Header$ */
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	/* End of tkerror.c */