search sounds and player in $ResourceDir
[micropolis] / src / tk / tkshare.c
0 / 409 (  0%)
CommitLineData
1/*
2 * tkShare.c --
3 *
4 * This module implements a simple mechanism for sharing
5 * mouse- and button-related events among collections of
6 * windows. It is used primarily for menus. For example,
7 * if one menu is posted and mouse moves over the menu button
8 * for a different menu, then the menubutton needs to see the
9 * event so that it can post itself and unpost the first menu.
10 *
11 * Copyright 1990-1992 Regents of the University of California
12 * Permission to use, copy, modify, and distribute this
13 * software and its documentation for any purpose and without
14 * fee is hereby granted, provided that the above copyright
15 * notice appear in all copies. The University of California
16 * makes no representations about the suitability of this
17 * software for any purpose. It is provided "as is" without
18 * express or implied warranty.
19 */
20
21#ifndef lint
22static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkShare.c,v 1.10 92/05/31 16:20:12 ouster Exp $ SPRITE (Berkeley)";
23#endif /* not lint */
24
25#include "tkconfig.h"
26#include "tk.h"
27
28/*
29 * the global variable below is used to tell TkPointerEvent
30 * not to do any processing on an event that we're forwarding from one
31 * window to another. This is really ugly. Eventually this file and
32 * tkGrab.c need to get merged together to produce something cleaner.
33 */
34
35XEvent *tkShareEventPtr = NULL;
36
37/*
38 * Sharing is implemented in terms of groups of windows, where events
39 * are shared among all the windows in a group. One of the following
40 * structures exists for each group.
41 */
42
43typedef struct Group {
44 Tk_Uid groupId; /* Identifies group uniquely among all
45 * share groups. */
46 Tk_Window *windows; /* Pointer to array of windows in
47 * this group. Malloc'ed. */
48 int numWindows; /* Number of windows currently in
49 * this group. */
50 Tk_Window lastWindow; /* Last window found that contained
51 * an event. Needed in order to
52 * notify window when mouse moves out
53 * of it. NULL means nobody to
54 * notify. */
55 XEvent *activeEvent; /* If non-NULL, means that a recursive
56 * call to Tk_HandleEvent is in
57 * progress for this share group, and
58 * identifies event. NULL means no
59 * recursive call in progress. Used
60 * to avoid infinite recursion. */
61 struct Group *nextPtr; /* Next in list of all share groups. */
62} Group;
63
64static Group *groupList = NULL; /* First in list of all share groups
65 * currently defined. */
66
67/*
68 * Forward declarations for procedures defined later in this file:
69 */
70
71static void DeleteGroup _ANSI_ARGS_((Group *groupPtr));
72static void ShareEventProc _ANSI_ARGS_((ClientData clientData,
73 XEvent *eventPtr));
74\f
75/*
76 *----------------------------------------------------------------------
77 *
78 * Tk_ShareEvents --
79 *
80 * Add tkwin to a group of windows sharing events.
81 *
82 * Results:
83 * None.
84 *
85 * Side effects:
86 * In the future, if a button- or mouse-related event occurs for
87 * any window in the same group as tkwin, but the mouse is actually
88 * in tkwin (the event went to a different window because of a
89 * grab) then a synthetic event will be generated with tkwin as
90 * window and adjusted coordinates.
91 *
92 *----------------------------------------------------------------------
93 */
94
95void
96Tk_ShareEvents(tkwin, groupId)
97 Tk_Window tkwin; /* Token for window. */
98 Tk_Uid groupId; /* Identifier for group among which
99 * events are to be shared. */
100{
101 register Group *groupPtr;
102
103 /*
104 * See if this group exists. If so, add the window to the group.
105 */
106
107 for (groupPtr = groupList; groupPtr != NULL;
108 groupPtr = groupPtr->nextPtr) {
109 Tk_Window *new;
110
111 if (groupPtr->groupId != groupId) {
112 continue;
113 }
114 new = (Tk_Window *) ckalloc((unsigned)
115 (groupPtr->numWindows+1) * sizeof(Tk_Window *));
116 memcpy((VOID *) (new+1), (VOID *) groupPtr->windows,
117 (groupPtr->numWindows * sizeof(Tk_Window *)));
118 ckfree((char *) groupPtr->windows);
119 groupPtr->windows = new;
120 groupPtr->windows[0] = tkwin;
121 groupPtr->numWindows++;
122 break;
123 }
124
125 if (groupPtr == NULL) {
126 /*
127 * Group doesn't exist. Make a new one.
128 */
129
130 groupPtr = (Group *) ckalloc(sizeof(Group));
131 groupPtr->groupId = groupId;
132 groupPtr->windows = (Tk_Window *) ckalloc(sizeof (Tk_Window *));
133 groupPtr->windows[0] = tkwin;
134 groupPtr->numWindows = 1;
135 groupPtr->lastWindow = NULL;
136 groupPtr->activeEvent = NULL;
137 groupPtr->nextPtr = groupList;
138 groupList = groupPtr;
139 }
140
141 /*
142 * Create an event handler so we find out about relevant events
143 * that are directed to tkwin.
144 */
145
146 Tk_CreateEventHandler(tkwin,
147 ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
148 ShareEventProc, (ClientData) groupPtr);
149}
150\f
151/*
152 *----------------------------------------------------------------------
153 *
154 * Tk_UnshareEvents --
155 *
156 * Remove tkwin from a group of windows sharing events.
157 *
158 * Results:
159 * None.
160 *
161 * Side effects:
162 * Tkwin will no longer participate in event-sharing for the
163 * given group, either as source of events or as destination.
164 *
165 *----------------------------------------------------------------------
166 */
167
168void
169Tk_UnshareEvents(tkwin, groupId)
170 Tk_Window tkwin; /* Token for window. */
171 Tk_Uid groupId; /* Identifier for group. */
172{
173 register Group *groupPtr;
174 int i;
175
176 for (groupPtr = groupList; groupPtr != NULL;
177 groupPtr = groupPtr->nextPtr) {
178 if (groupPtr->groupId != groupId) {
179 continue;
180 }
181 if (groupPtr->lastWindow == tkwin) {
182 groupPtr->lastWindow = NULL;
183 }
184 for (i = 0; i < groupPtr->numWindows; i++) {
185 if (groupPtr->windows[i] != tkwin) {
186 continue;
187 }
188 if ((i+1) < groupPtr->numWindows) {
189 memcpy((VOID *) (groupPtr->windows + i),
190 (VOID *) (groupPtr->windows + i + 1),
191 (groupPtr->numWindows - (i+1))*sizeof(Tk_Window *));
192 }
193 groupPtr->numWindows--;
194 Tk_DeleteEventHandler(tkwin,
195 ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
196 ShareEventProc, (ClientData) groupPtr);
197 if (groupPtr->numWindows == 0) {
198 DeleteGroup(groupPtr);
199 }
200 return;
201 }
202 }
203}
204\f
205/*
206 *----------------------------------------------------------------------
207 *
208 * DeleteGroup --
209 *
210 * This procedure is called when a group has no more members.
211 * It deletes the group from the list of existing groups.
212 *
213 * Results:
214 * None.
215 *
216 * Side effects:
217 * Memory gets freed.
218 *
219 *----------------------------------------------------------------------
220 */
221
222static void
223DeleteGroup(groupPtr)
224 Group *groupPtr; /* Group to delete. */
225{
226 if (groupList == groupPtr) {
227 groupList = groupPtr->nextPtr;
228 } else {
229 register Group *prevPtr;
230
231 for (prevPtr = groupList; ; prevPtr = prevPtr->nextPtr) {
232 if (prevPtr == NULL) {
233 panic("DeleteGroup couldn't find group on shareList");
234 }
235 if (prevPtr->nextPtr == groupPtr) {
236 prevPtr->nextPtr = groupPtr->nextPtr;
237 break;
238 }
239 }
240 }
241 ckfree((char *) groupPtr->windows);
242 ckfree((char *) groupPtr);
243}
244\f
245/*
246 *----------------------------------------------------------------------
247 *
248 * ShareEventProc --
249 *
250 * This procedure is invoked by the Tk dispatcher when an event
251 * occurs for which we need to implement sharing.
252 *
253 * Results:
254 * None.
255 *
256 * Side effects:
257 * If the mouse is actually in a window other than the one for
258 * which the event occurred, generate a new event translated to
259 * that window.
260 *
261 *----------------------------------------------------------------------
262 */
263
264static void
265ShareEventProc(clientData, eventPtr)
266 ClientData clientData; /* Information about share group. */
267 register XEvent *eventPtr; /* Event that just occurred. */
268{
269 register Group *groupPtr = (Group *) clientData;
270 register Tk_Window tkwin;
271 Window window;
272 XEvent newEvent, *savedActive, *savedShareEventPtr;
273 int i, x, y;
274 Tk_Uid savedId;
275 register Group *grpPtr;
276
277 /*
278 * If this event was a synthetic one that we generated, then
279 * don't bother to process it again.
280 */
281
282 if (groupPtr->activeEvent == eventPtr) {
283 return;
284 }
285 savedActive = groupPtr->activeEvent;
286 groupPtr->activeEvent = &newEvent;
287 savedId = groupPtr->groupId;
288
289 savedShareEventPtr = tkShareEventPtr;
290 tkShareEventPtr = &newEvent;
291
292 /*
293 * Scan through all of the windows for this group to find the
294 * first one (if any) that contains the event.
295 */
296
297 tkwin = NULL; /* Not needed, but stops compiler warning. */
298 for (i = 0; i < groupPtr->numWindows; i++) {
299 Tk_Window tkwin2;
300
301 tkwin = groupPtr->windows[i];
302 Tk_GetRootCoords(tkwin, &x, &y);
303 x = eventPtr->xmotion.x_root - x - Tk_Changes(tkwin)->border_width;
304 y = eventPtr->xmotion.y_root - y - Tk_Changes(tkwin)->border_width;
305 if ((x < 0) || (y < 0) || (x >= Tk_Width(tkwin))
306 || (y >= Tk_Height(tkwin))) {
307 continue;
308 }
309 for (tkwin2 = tkwin; ; tkwin2 = Tk_Parent(tkwin2)) {
310 if (tkwin2 == NULL) {
311 goto foundWindow;
312 }
313 if (!Tk_IsMapped(tkwin2)) {
314 break;
315 }
316 if (((Tk_FakeWin *) (tkwin2))->flags & TK_TOP_LEVEL) {
317 goto foundWindow;
318 }
319 }
320 }
321
322 foundWindow:
323 window = None; /* Not really needed but stops compiler warning. */
324 if (i >= groupPtr->numWindows) {
325 tkwin = NULL;
326 } else {
327 window = Tk_WindowId(tkwin);
328 }
329
330 /*
331 * SPECIAL NOTE: it is possible that any or all of the information
332 * in groupPtr could be modified as part of the processing of the
333 * events that we generate and hand to Tk_HandleEvent below. For this
334 * to work smoothly, it is imperative that we extract any information
335 * we need from groupPtr (and from tkwin's, since they could be
336 * deleted) before the first call to Tk_HandleEvent below. The code
337 * below may potentially pass an X window identifier to Tk_HandleEvent
338 * after the window has been deleted, but as long as identifiers
339 * aren't recycled Tk_HandleEvent will simply discard the event if
340 * this occurs.
341 */
342
343 /*
344 * If the pointer is in a different window now than the last time
345 * we were invoked, send a LeaveNotify event to the old window and
346 * an EnterNotify event to the new window.
347 */
348
349 newEvent = *eventPtr;
350 newEvent.xany.send_event = True;
351 if (tkwin != groupPtr->lastWindow) {
352 newEvent = *eventPtr;
353 newEvent.xany.send_event = True;
354 newEvent.xcrossing.mode = TK_NOTIFY_SHARE;
355 newEvent.xcrossing.detail = NotifyAncestor;
356 newEvent.xcrossing.same_screen = True;
357 newEvent.xcrossing.state = eventPtr->xmotion.state;
358 if (groupPtr->lastWindow != NULL) {
359 newEvent.xcrossing.type = LeaveNotify;
360 newEvent.xcrossing.window = Tk_WindowId(groupPtr->lastWindow);
361 Tk_GetRootCoords(groupPtr->lastWindow, &newEvent.xcrossing.x,
362 &newEvent.xcrossing.y);
363 newEvent.xcrossing.x = eventPtr->xmotion.x_root
364 - newEvent.xcrossing.x
365 - Tk_Changes(groupPtr->lastWindow)->border_width;
366 newEvent.xcrossing.y = eventPtr->xmotion.y_root
367 - newEvent.xcrossing.y
368 - Tk_Changes(groupPtr->lastWindow)->border_width;
369 Tk_HandleEvent(&newEvent);
370 }
371 if (tkwin != NULL) {
372 newEvent.xcrossing.type = EnterNotify;
373 newEvent.xcrossing.window = window;
374 newEvent.xcrossing.x = x;
375 newEvent.xcrossing.y = y;
376 Tk_HandleEvent(&newEvent);
377 }
378 groupPtr->lastWindow = tkwin;
379 }
380
381 /*
382 * If the pointer is in the window to which the event was sent,
383 * then we needn't do any forwarding at all. Ditto if the pointer
384 * isn't in any window at all.
385 */
386
387 if ((tkwin != NULL) && (Tk_WindowId(tkwin) != eventPtr->xmotion.window)) {
388 newEvent = *eventPtr;
389 newEvent.xmotion.send_event = True;
390 newEvent.xmotion.window = window;
391 newEvent.xmotion.x = x;
392 newEvent.xmotion.y = y;
393 Tk_HandleEvent(&newEvent);
394 }
395
396 /*
397 * Only restore the activeEvent if the group still exists.
398 * (It could be deleted as a side effect of processing the event.)
399 */
400
401 for (grpPtr = groupList; grpPtr != NULL; grpPtr = grpPtr->nextPtr) {
402 if (grpPtr->groupId == savedId) {
403 groupPtr->activeEvent = savedActive;
404 break;
405 }
406 }
407
408 tkShareEventPtr = savedShareEventPtr;
409}
Impressum, Datenschutz