Tizen 2.1 base
[framework/uifw/xorg/lib/libxmu.git] / src / CloseHook.c
1 /*
2 Copyright 1989, 1998  The Open Group
3
4 Permission to use, copy, modify, distribute, and sell this software and its
5 documentation for any purpose is hereby granted without fee, provided that
6 the above copyright notice appear in all copies and that both that
7 copyright notice and this permission notice appear in supporting
8 documentation.
9
10 The above copyright notice and this permission notice shall be included in
11 all copies or substantial portions of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
16 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
17 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19
20 Except as contained in this notice, the name of The Open Group shall not be
21 used in advertising or otherwise to promote the sale, use or other dealings
22 in this Software without prior written authorization from The Open Group.
23
24 */
25
26 /*
27  * CloseDisplayHook package - provide callback on XCloseDisplay
28  *
29  * *
30  * Author:  Jim Fulton, MIT X Consortium
31  *
32  *
33  *                            Public Entry Points
34  *
35  * CloseHook XmuAddCloseDisplayHook (dpy, func, arg)
36  *     Display *dpy;
37  *     XmuCloseHookProc func;
38  *     XPointer arg;
39  *
40  * Bool XmuRemoveCloseDisplayHook (dpy, hook, func, arg)
41  *     Display *dpy;
42  *     CloseHook hook;
43  *     XmuCloseHookProc func;
44  *     XPointer arg;
45  *
46  * Bool XmuLookupCloseDisplayHook (dpy, hook, func, arg)
47  *     Display *dpy;
48  *     CloseHook hook;
49  *     XmuCloseHookProc func;
50  *     XPointer arg;
51  *
52  */
53
54 #ifdef HAVE_CONFIG_H
55 #include <config.h>
56 #endif
57 #include <stdio.h>                                      /* for NULL */
58 #include <X11/Xos.h>
59 #include <X11/Xlib.h>
60 #include <X11/Xmu/CloseHook.h>
61 #include <stdlib.h>
62
63 /*
64  *                               Private data
65  *
66  * This is a list of display entries, each of which contains a list of callback
67  * records.
68  */
69
70 typedef struct _CallbackRec {
71     struct _CallbackRec *next;          /* next link in chain */
72     XmuCloseHookProc func;              /* function to call */
73     XPointer arg;                       /* argument to pass with function */
74 } CallbackRec;
75
76
77 typedef struct _DisplayEntry {
78     struct _DisplayEntry *next;         /* next link in chain */
79     Display *dpy;                       /* the display this represents */
80     int extension;                      /* from XAddExtension */
81     struct _CallbackRec *start, *end;   /* linked list of callbacks */
82     struct _CallbackRec *calling;       /* currently being called back */
83 } DisplayEntry;
84
85 /*
86  * Prototypes
87  */
88 static DisplayEntry *_FindDisplayEntry(Display*, DisplayEntry**);
89 static Bool _MakeExtension(Display*, int*);
90
91 static DisplayEntry *elist = NULL;
92
93
94 /*
95  *****************************************************************************
96  *                            Public Entry Points                            *
97  *****************************************************************************
98  */
99
100 /*
101  * Add - add a callback for the given display.  When the display is closed,
102  * the given function will be called as:
103  *
104  *         (*func) (dpy, arg)
105  *
106  * This function is declared to return an int even though the value is ignored
107  * because some compilers have problems with functions returning void.
108  *
109  * This routine returns NULL if it was unable to add the callback, otherwise
110  * it returns an untyped pointer that can be used with Remove or Lookup, but
111  * not dereferenced.
112  */
113 CloseHook
114 XmuAddCloseDisplayHook(Display *dpy, XmuCloseHookProc func, XPointer arg)
115 {
116     DisplayEntry *de;
117     CallbackRec *cb;
118
119     /* allocate ahead of time so that we can fail atomically */
120     cb = (CallbackRec *) malloc (sizeof (CallbackRec));
121     if (!cb) return ((XPointer) NULL);
122
123     de = _FindDisplayEntry (dpy, NULL);
124     if (!de) {
125         if ((de = (DisplayEntry *) malloc (sizeof (DisplayEntry))) == NULL ||
126             !_MakeExtension (dpy, &de->extension)) {
127             free ((char *) cb);
128             if (de) free ((char *) de);
129             return ((CloseHook) NULL);
130         }
131         de->dpy = dpy;
132         de->start = de->end = NULL;
133         de->calling = NULL;
134         de->next = elist;
135         elist = de;
136     }
137
138     /* add to end of list of callback recordss */
139     cb->func = func;
140     cb->arg = arg;
141     cb->next = NULL;
142     if (de->end) {
143         de->end->next = cb;
144     } else {
145         de->start = cb;
146     }
147     de->end = cb;
148
149     return ((CloseHook) cb);
150 }
151
152
153 /*
154  * Remove - get rid of a callback.  If handle is non-null, use that to compare
155  * entries.  Otherwise, remove first instance of the function/argument pair.
156  */
157 Bool
158 XmuRemoveCloseDisplayHook(Display *dpy, CloseHook handle,
159                           XmuCloseHookProc func, XPointer arg)
160 {
161     DisplayEntry *de = _FindDisplayEntry (dpy, NULL);
162     register CallbackRec *h, *prev;
163
164     if (!de) return False;
165
166     /* look for handle or function/argument pair */
167     for (h = de->start, prev = NULL; h; h = h->next) {
168         if (handle) {
169             if (h == (CallbackRec *) handle) break;
170         } else {
171             if (h->func == func && h->arg == arg) break;
172         }
173         prev = h;
174     }
175     if (!h) return False;
176
177
178     /* remove from list, watch head and tail */
179     if (de->start == h) {
180         de->start = h->next;
181     } else {
182         prev->next = h->next;
183     }
184     if (de->end == h) de->end = prev;
185     if (de->calling != h) free ((char *) h);
186     return True;
187 }
188
189
190 /*
191  * Lookup - see whether or not a handle has been installed.  If handle is
192  * non-NULL, look for an entry that matches it; otherwise look for an entry
193  * with the same function/argument pair.
194  */
195 Bool
196 XmuLookupCloseDisplayHook(Display *dpy, CloseHook handle,
197                           XmuCloseHookProc func, XPointer arg)
198 {
199     DisplayEntry *de = _FindDisplayEntry (dpy, NULL);
200     register CallbackRec *h;
201
202     if (!de) return False;
203
204     for (h = de->start; h; h = h->next) {
205         if (handle) {
206             if (h == (CallbackRec *) handle) break;
207         } else {
208             if (h->func == func && h->arg == arg) break;
209         }
210     }
211     return (h ? True : False);
212 }
213
214
215 /*
216  *****************************************************************************
217  *                             internal routines                             *
218  *****************************************************************************
219  */
220
221
222 /*
223  * Find the specified display on the linked list of displays.  Also return
224  * the preceeding link so that the display can be unlinked without having
225  * back pointers.
226  */
227 static DisplayEntry *
228 _FindDisplayEntry(register Display *dpy, DisplayEntry **prevp)
229 {
230     register DisplayEntry *d, *prev;
231
232     for (d = elist, prev = NULL; d; d = d->next) {
233         if (d->dpy == dpy) {
234             if (prevp) *prevp = prev;
235             return d;
236         }
237         prev = d;
238     }
239     return NULL;
240 }
241
242
243
244 /*
245  * _DoCallbacks - process all of the callbacks for this display and free
246  * the associated callback data (callback records and display entries).
247  */
248 /* ARGSUSED */
249 static int
250 _DoCallbacks(Display *dpy, XExtCodes *codes)
251 {
252     register CallbackRec *h;
253     DisplayEntry *prev;
254     DisplayEntry *de = _FindDisplayEntry (dpy, &prev);
255
256     if (!de) return 0;
257
258     /* walk the list doing the callbacks and freeing callback record */
259     for (h = de->start; h;) {
260         register CallbackRec *nexth = h->next;
261         de->calling = h;                /* let remove know we'll free it */
262         (*(h->func)) (dpy, h->arg);
263         de->calling = NULL;
264         free ((char *) h);
265         h = nexth;
266     }
267
268     /* unlink this display from chain */
269     if (elist == de) {
270         elist = de->next;
271     } else {
272         prev->next = de->next;
273     }
274     free ((char *) de);
275     return 1;
276 }
277
278
279 /*
280  * _MakeExtension - create an extension for this display; done once per display
281  */
282 static Bool
283 _MakeExtension(Display *dpy, int *extensionp)
284 {
285     XExtCodes *codes;
286
287     codes = XAddExtension (dpy);
288     if (!codes) return False;
289
290     (void) XESetCloseDisplay (dpy, codes->extension, _DoCallbacks);
291
292     *extensionp = codes->extension;
293     return True;
294 }