1 |
/* $Header$ */ |
/* $Header$ */ |
2 |
|
|
3 |
/* |
/* |
4 |
* tkEvent.c -- |
* tkEvent.c -- |
5 |
* |
* |
6 |
* This file provides basic low-level facilities for managing |
* This file provides basic low-level facilities for managing |
7 |
* X events in Tk. |
* X events in Tk. |
8 |
* |
* |
9 |
* Copyright (c) 1990-1994 The Regents of the University of California. |
* Copyright (c) 1990-1994 The Regents of the University of California. |
10 |
* Copyright (c) 1994-1995 Sun Microsystems, Inc. |
* Copyright (c) 1994-1995 Sun Microsystems, Inc. |
11 |
* Copyright (c) 1998 by Scriptics Corporation. |
* Copyright (c) 1998 by Scriptics Corporation. |
12 |
* |
* |
13 |
* See the file "license.terms" for information on usage and redistribution |
* See the file "license.terms" for information on usage and redistribution |
14 |
* of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
* of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
15 |
* |
* |
16 |
* RCS: @(#) $Id: tkevent.c,v 1.1.1.1 2001/06/13 05:00:10 dtashley Exp $ |
* RCS: @(#) $Id: tkevent.c,v 1.1.1.1 2001/06/13 05:00:10 dtashley Exp $ |
17 |
*/ |
*/ |
18 |
|
|
19 |
#include "tkPort.h" |
#include "tkPort.h" |
20 |
#include "tkInt.h" |
#include "tkInt.h" |
21 |
#include <signal.h> |
#include <signal.h> |
22 |
|
|
23 |
/* |
/* |
24 |
* There's a potential problem if a handler is deleted while it's |
* There's a potential problem if a handler is deleted while it's |
25 |
* current (i.e. its procedure is executing), since Tk_HandleEvent |
* current (i.e. its procedure is executing), since Tk_HandleEvent |
26 |
* will need to read the handler's "nextPtr" field when the procedure |
* will need to read the handler's "nextPtr" field when the procedure |
27 |
* returns. To handle this problem, structures of the type below |
* returns. To handle this problem, structures of the type below |
28 |
* indicate the next handler to be processed for any (recursively |
* indicate the next handler to be processed for any (recursively |
29 |
* nested) dispatches in progress. The nextHandler fields get |
* nested) dispatches in progress. The nextHandler fields get |
30 |
* updated if the handlers pointed to are deleted. Tk_HandleEvent |
* updated if the handlers pointed to are deleted. Tk_HandleEvent |
31 |
* also needs to know if the entire window gets deleted; the winPtr |
* also needs to know if the entire window gets deleted; the winPtr |
32 |
* field is set to zero if that particular window gets deleted. |
* field is set to zero if that particular window gets deleted. |
33 |
*/ |
*/ |
34 |
|
|
35 |
typedef struct InProgress { |
typedef struct InProgress { |
36 |
XEvent *eventPtr; /* Event currently being handled. */ |
XEvent *eventPtr; /* Event currently being handled. */ |
37 |
TkWindow *winPtr; /* Window for event. Gets set to None if |
TkWindow *winPtr; /* Window for event. Gets set to None if |
38 |
* window is deleted while event is being |
* window is deleted while event is being |
39 |
* handled. */ |
* handled. */ |
40 |
TkEventHandler *nextHandler; /* Next handler in search. */ |
TkEventHandler *nextHandler; /* Next handler in search. */ |
41 |
struct InProgress *nextPtr; /* Next higher nested search. */ |
struct InProgress *nextPtr; /* Next higher nested search. */ |
42 |
} InProgress; |
} InProgress; |
43 |
|
|
44 |
/* |
/* |
45 |
* For each call to Tk_CreateGenericHandler, an instance of the following |
* For each call to Tk_CreateGenericHandler, an instance of the following |
46 |
* structure will be created. All of the active handlers are linked into a |
* structure will be created. All of the active handlers are linked into a |
47 |
* list. |
* list. |
48 |
*/ |
*/ |
49 |
|
|
50 |
typedef struct GenericHandler { |
typedef struct GenericHandler { |
51 |
Tk_GenericProc *proc; /* Procedure to dispatch on all X events. */ |
Tk_GenericProc *proc; /* Procedure to dispatch on all X events. */ |
52 |
ClientData clientData; /* Client data to pass to procedure. */ |
ClientData clientData; /* Client data to pass to procedure. */ |
53 |
int deleteFlag; /* Flag to set when this handler is deleted. */ |
int deleteFlag; /* Flag to set when this handler is deleted. */ |
54 |
struct GenericHandler *nextPtr; |
struct GenericHandler *nextPtr; |
55 |
/* Next handler in list of all generic |
/* Next handler in list of all generic |
56 |
* handlers, or NULL for end of list. */ |
* handlers, or NULL for end of list. */ |
57 |
} GenericHandler; |
} GenericHandler; |
58 |
|
|
59 |
/* |
/* |
60 |
* There's a potential problem if Tk_HandleEvent is entered recursively. |
* There's a potential problem if Tk_HandleEvent is entered recursively. |
61 |
* A handler cannot be deleted physically until we have returned from |
* A handler cannot be deleted physically until we have returned from |
62 |
* calling it. Otherwise, we're looking at unallocated memory in advancing to |
* calling it. Otherwise, we're looking at unallocated memory in advancing to |
63 |
* its `next' entry. We deal with the problem by using the `delete flag' and |
* its `next' entry. We deal with the problem by using the `delete flag' and |
64 |
* deleting handlers only when it's known that there's no handler active. |
* deleting handlers only when it's known that there's no handler active. |
65 |
* |
* |
66 |
*/ |
*/ |
67 |
|
|
68 |
/* |
/* |
69 |
* The following structure is used for queueing X-style events on the |
* The following structure is used for queueing X-style events on the |
70 |
* Tcl event queue. |
* Tcl event queue. |
71 |
*/ |
*/ |
72 |
|
|
73 |
typedef struct TkWindowEvent { |
typedef struct TkWindowEvent { |
74 |
Tcl_Event header; /* Standard information for all events. */ |
Tcl_Event header; /* Standard information for all events. */ |
75 |
XEvent event; /* The X event. */ |
XEvent event; /* The X event. */ |
76 |
} TkWindowEvent; |
} TkWindowEvent; |
77 |
|
|
78 |
/* |
/* |
79 |
* Array of event masks corresponding to each X event: |
* Array of event masks corresponding to each X event: |
80 |
*/ |
*/ |
81 |
|
|
82 |
static unsigned long eventMasks[TK_LASTEVENT] = { |
static unsigned long eventMasks[TK_LASTEVENT] = { |
83 |
0, |
0, |
84 |
0, |
0, |
85 |
KeyPressMask, /* KeyPress */ |
KeyPressMask, /* KeyPress */ |
86 |
KeyReleaseMask, /* KeyRelease */ |
KeyReleaseMask, /* KeyRelease */ |
87 |
ButtonPressMask, /* ButtonPress */ |
ButtonPressMask, /* ButtonPress */ |
88 |
ButtonReleaseMask, /* ButtonRelease */ |
ButtonReleaseMask, /* ButtonRelease */ |
89 |
PointerMotionMask|PointerMotionHintMask|ButtonMotionMask |
PointerMotionMask|PointerMotionHintMask|ButtonMotionMask |
90 |
|Button1MotionMask|Button2MotionMask|Button3MotionMask |
|Button1MotionMask|Button2MotionMask|Button3MotionMask |
91 |
|Button4MotionMask|Button5MotionMask, |
|Button4MotionMask|Button5MotionMask, |
92 |
/* MotionNotify */ |
/* MotionNotify */ |
93 |
EnterWindowMask, /* EnterNotify */ |
EnterWindowMask, /* EnterNotify */ |
94 |
LeaveWindowMask, /* LeaveNotify */ |
LeaveWindowMask, /* LeaveNotify */ |
95 |
FocusChangeMask, /* FocusIn */ |
FocusChangeMask, /* FocusIn */ |
96 |
FocusChangeMask, /* FocusOut */ |
FocusChangeMask, /* FocusOut */ |
97 |
KeymapStateMask, /* KeymapNotify */ |
KeymapStateMask, /* KeymapNotify */ |
98 |
ExposureMask, /* Expose */ |
ExposureMask, /* Expose */ |
99 |
ExposureMask, /* GraphicsExpose */ |
ExposureMask, /* GraphicsExpose */ |
100 |
ExposureMask, /* NoExpose */ |
ExposureMask, /* NoExpose */ |
101 |
VisibilityChangeMask, /* VisibilityNotify */ |
VisibilityChangeMask, /* VisibilityNotify */ |
102 |
SubstructureNotifyMask, /* CreateNotify */ |
SubstructureNotifyMask, /* CreateNotify */ |
103 |
StructureNotifyMask, /* DestroyNotify */ |
StructureNotifyMask, /* DestroyNotify */ |
104 |
StructureNotifyMask, /* UnmapNotify */ |
StructureNotifyMask, /* UnmapNotify */ |
105 |
StructureNotifyMask, /* MapNotify */ |
StructureNotifyMask, /* MapNotify */ |
106 |
SubstructureRedirectMask, /* MapRequest */ |
SubstructureRedirectMask, /* MapRequest */ |
107 |
StructureNotifyMask, /* ReparentNotify */ |
StructureNotifyMask, /* ReparentNotify */ |
108 |
StructureNotifyMask, /* ConfigureNotify */ |
StructureNotifyMask, /* ConfigureNotify */ |
109 |
SubstructureRedirectMask, /* ConfigureRequest */ |
SubstructureRedirectMask, /* ConfigureRequest */ |
110 |
StructureNotifyMask, /* GravityNotify */ |
StructureNotifyMask, /* GravityNotify */ |
111 |
ResizeRedirectMask, /* ResizeRequest */ |
ResizeRedirectMask, /* ResizeRequest */ |
112 |
StructureNotifyMask, /* CirculateNotify */ |
StructureNotifyMask, /* CirculateNotify */ |
113 |
SubstructureRedirectMask, /* CirculateRequest */ |
SubstructureRedirectMask, /* CirculateRequest */ |
114 |
PropertyChangeMask, /* PropertyNotify */ |
PropertyChangeMask, /* PropertyNotify */ |
115 |
0, /* SelectionClear */ |
0, /* SelectionClear */ |
116 |
0, /* SelectionRequest */ |
0, /* SelectionRequest */ |
117 |
0, /* SelectionNotify */ |
0, /* SelectionNotify */ |
118 |
ColormapChangeMask, /* ColormapNotify */ |
ColormapChangeMask, /* ColormapNotify */ |
119 |
0, /* ClientMessage */ |
0, /* ClientMessage */ |
120 |
0, /* Mapping Notify */ |
0, /* Mapping Notify */ |
121 |
VirtualEventMask, /* VirtualEvents */ |
VirtualEventMask, /* VirtualEvents */ |
122 |
ActivateMask, /* ActivateNotify */ |
ActivateMask, /* ActivateNotify */ |
123 |
ActivateMask, /* DeactivateNotify */ |
ActivateMask, /* DeactivateNotify */ |
124 |
MouseWheelMask /* MouseWheelEvent */ |
MouseWheelMask /* MouseWheelEvent */ |
125 |
}; |
}; |
126 |
|
|
127 |
|
|
128 |
/* |
/* |
129 |
* The structure below is used to store Data for the Event module that |
* The structure below is used to store Data for the Event module that |
130 |
* must be kept thread-local. The "dataKey" is used to fetch the |
* must be kept thread-local. The "dataKey" is used to fetch the |
131 |
* thread-specific storage for the current thread. |
* thread-specific storage for the current thread. |
132 |
*/ |
*/ |
133 |
|
|
134 |
typedef struct ThreadSpecificData { |
typedef struct ThreadSpecificData { |
135 |
|
|
136 |
int genericHandlersActive; |
int genericHandlersActive; |
137 |
/* The following variable has a non-zero |
/* The following variable has a non-zero |
138 |
* value when a handler is active. */ |
* value when a handler is active. */ |
139 |
InProgress *pendingPtr; |
InProgress *pendingPtr; |
140 |
/* Topmost search in progress, or |
/* Topmost search in progress, or |
141 |
* NULL if none. */ |
* NULL if none. */ |
142 |
GenericHandler *genericList; |
GenericHandler *genericList; |
143 |
/* First handler in the list, or NULL. */ |
/* First handler in the list, or NULL. */ |
144 |
GenericHandler *lastGenericPtr; |
GenericHandler *lastGenericPtr; |
145 |
/* Last handler in list. */ |
/* Last handler in list. */ |
146 |
|
|
147 |
/* |
/* |
148 |
* If someone has called Tk_RestrictEvents, the information below |
* If someone has called Tk_RestrictEvents, the information below |
149 |
* keeps track of it. |
* keeps track of it. |
150 |
*/ |
*/ |
151 |
|
|
152 |
Tk_RestrictProc *restrictProc; |
Tk_RestrictProc *restrictProc; |
153 |
/* Procedure to call. NULL means no |
/* Procedure to call. NULL means no |
154 |
* restrictProc is currently in effect. */ |
* restrictProc is currently in effect. */ |
155 |
ClientData restrictArg; /* Argument to pass to restrictProc. */ |
ClientData restrictArg; /* Argument to pass to restrictProc. */ |
156 |
} ThreadSpecificData; |
} ThreadSpecificData; |
157 |
static Tcl_ThreadDataKey dataKey; |
static Tcl_ThreadDataKey dataKey; |
158 |
|
|
159 |
/* |
/* |
160 |
* Prototypes for procedures that are only referenced locally within |
* Prototypes for procedures that are only referenced locally within |
161 |
* this file. |
* this file. |
162 |
*/ |
*/ |
163 |
|
|
164 |
static void DelayedMotionProc _ANSI_ARGS_((ClientData clientData)); |
static void DelayedMotionProc _ANSI_ARGS_((ClientData clientData)); |
165 |
static int WindowEventProc _ANSI_ARGS_((Tcl_Event *evPtr, |
static int WindowEventProc _ANSI_ARGS_((Tcl_Event *evPtr, |
166 |
int flags)); |
int flags)); |
167 |
|
|
168 |
/* |
/* |
169 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
170 |
* |
* |
171 |
* Tk_CreateEventHandler -- |
* Tk_CreateEventHandler -- |
172 |
* |
* |
173 |
* Arrange for a given procedure to be invoked whenever |
* Arrange for a given procedure to be invoked whenever |
174 |
* events from a given class occur in a given window. |
* events from a given class occur in a given window. |
175 |
* |
* |
176 |
* Results: |
* Results: |
177 |
* None. |
* None. |
178 |
* |
* |
179 |
* Side effects: |
* Side effects: |
180 |
* From now on, whenever an event of the type given by |
* From now on, whenever an event of the type given by |
181 |
* mask occurs for token and is processed by Tk_HandleEvent, |
* mask occurs for token and is processed by Tk_HandleEvent, |
182 |
* proc will be called. See the manual entry for details |
* proc will be called. See the manual entry for details |
183 |
* of the calling sequence and return value for proc. |
* of the calling sequence and return value for proc. |
184 |
* |
* |
185 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
186 |
*/ |
*/ |
187 |
|
|
188 |
void |
void |
189 |
Tk_CreateEventHandler(token, mask, proc, clientData) |
Tk_CreateEventHandler(token, mask, proc, clientData) |
190 |
Tk_Window token; /* Token for window in which to |
Tk_Window token; /* Token for window in which to |
191 |
* create handler. */ |
* create handler. */ |
192 |
unsigned long mask; /* Events for which proc should |
unsigned long mask; /* Events for which proc should |
193 |
* be called. */ |
* be called. */ |
194 |
Tk_EventProc *proc; /* Procedure to call for each |
Tk_EventProc *proc; /* Procedure to call for each |
195 |
* selected event */ |
* selected event */ |
196 |
ClientData clientData; /* Arbitrary data to pass to proc. */ |
ClientData clientData; /* Arbitrary data to pass to proc. */ |
197 |
{ |
{ |
198 |
register TkEventHandler *handlerPtr; |
register TkEventHandler *handlerPtr; |
199 |
register TkWindow *winPtr = (TkWindow *) token; |
register TkWindow *winPtr = (TkWindow *) token; |
200 |
int found; |
int found; |
201 |
|
|
202 |
/* |
/* |
203 |
* Skim through the list of existing handlers to (a) compute the |
* Skim through the list of existing handlers to (a) compute the |
204 |
* overall event mask for the window (so we can pass this new |
* overall event mask for the window (so we can pass this new |
205 |
* value to the X system) and (b) see if there's already a handler |
* value to the X system) and (b) see if there's already a handler |
206 |
* declared with the same callback and clientData (if so, just |
* declared with the same callback and clientData (if so, just |
207 |
* change the mask). If no existing handler matches, then create |
* change the mask). If no existing handler matches, then create |
208 |
* a new handler. |
* a new handler. |
209 |
*/ |
*/ |
210 |
|
|
211 |
found = 0; |
found = 0; |
212 |
if (winPtr->handlerList == NULL) { |
if (winPtr->handlerList == NULL) { |
213 |
handlerPtr = (TkEventHandler *) ckalloc( |
handlerPtr = (TkEventHandler *) ckalloc( |
214 |
(unsigned) sizeof(TkEventHandler)); |
(unsigned) sizeof(TkEventHandler)); |
215 |
winPtr->handlerList = handlerPtr; |
winPtr->handlerList = handlerPtr; |
216 |
goto initHandler; |
goto initHandler; |
217 |
} else { |
} else { |
218 |
for (handlerPtr = winPtr->handlerList; ; |
for (handlerPtr = winPtr->handlerList; ; |
219 |
handlerPtr = handlerPtr->nextPtr) { |
handlerPtr = handlerPtr->nextPtr) { |
220 |
if ((handlerPtr->proc == proc) |
if ((handlerPtr->proc == proc) |
221 |
&& (handlerPtr->clientData == clientData)) { |
&& (handlerPtr->clientData == clientData)) { |
222 |
handlerPtr->mask = mask; |
handlerPtr->mask = mask; |
223 |
found = 1; |
found = 1; |
224 |
} |
} |
225 |
if (handlerPtr->nextPtr == NULL) { |
if (handlerPtr->nextPtr == NULL) { |
226 |
break; |
break; |
227 |
} |
} |
228 |
} |
} |
229 |
} |
} |
230 |
|
|
231 |
/* |
/* |
232 |
* Create a new handler if no matching old handler was found. |
* Create a new handler if no matching old handler was found. |
233 |
*/ |
*/ |
234 |
|
|
235 |
if (!found) { |
if (!found) { |
236 |
handlerPtr->nextPtr = (TkEventHandler *) |
handlerPtr->nextPtr = (TkEventHandler *) |
237 |
ckalloc(sizeof(TkEventHandler)); |
ckalloc(sizeof(TkEventHandler)); |
238 |
handlerPtr = handlerPtr->nextPtr; |
handlerPtr = handlerPtr->nextPtr; |
239 |
initHandler: |
initHandler: |
240 |
handlerPtr->mask = mask; |
handlerPtr->mask = mask; |
241 |
handlerPtr->proc = proc; |
handlerPtr->proc = proc; |
242 |
handlerPtr->clientData = clientData; |
handlerPtr->clientData = clientData; |
243 |
handlerPtr->nextPtr = NULL; |
handlerPtr->nextPtr = NULL; |
244 |
} |
} |
245 |
|
|
246 |
/* |
/* |
247 |
* No need to call XSelectInput: Tk always selects on all events |
* No need to call XSelectInput: Tk always selects on all events |
248 |
* for all windows (needed to support bindings on classes and "all"). |
* for all windows (needed to support bindings on classes and "all"). |
249 |
*/ |
*/ |
250 |
} |
} |
251 |
|
|
252 |
/* |
/* |
253 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
254 |
* |
* |
255 |
* Tk_DeleteEventHandler -- |
* Tk_DeleteEventHandler -- |
256 |
* |
* |
257 |
* Delete a previously-created handler. |
* Delete a previously-created handler. |
258 |
* |
* |
259 |
* Results: |
* Results: |
260 |
* None. |
* None. |
261 |
* |
* |
262 |
* Side effects: |
* Side effects: |
263 |
* If there existed a handler as described by the |
* If there existed a handler as described by the |
264 |
* parameters, the handler is deleted so that proc |
* parameters, the handler is deleted so that proc |
265 |
* will not be invoked again. |
* will not be invoked again. |
266 |
* |
* |
267 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
268 |
*/ |
*/ |
269 |
|
|
270 |
void |
void |
271 |
Tk_DeleteEventHandler(token, mask, proc, clientData) |
Tk_DeleteEventHandler(token, mask, proc, clientData) |
272 |
Tk_Window token; /* Same as corresponding arguments passed */ |
Tk_Window token; /* Same as corresponding arguments passed */ |
273 |
unsigned long mask; /* previously to Tk_CreateEventHandler. */ |
unsigned long mask; /* previously to Tk_CreateEventHandler. */ |
274 |
Tk_EventProc *proc; |
Tk_EventProc *proc; |
275 |
ClientData clientData; |
ClientData clientData; |
276 |
{ |
{ |
277 |
register TkEventHandler *handlerPtr; |
register TkEventHandler *handlerPtr; |
278 |
register InProgress *ipPtr; |
register InProgress *ipPtr; |
279 |
TkEventHandler *prevPtr; |
TkEventHandler *prevPtr; |
280 |
register TkWindow *winPtr = (TkWindow *) token; |
register TkWindow *winPtr = (TkWindow *) token; |
281 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
282 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
283 |
|
|
284 |
/* |
/* |
285 |
* Find the event handler to be deleted, or return |
* Find the event handler to be deleted, or return |
286 |
* immediately if it doesn't exist. |
* immediately if it doesn't exist. |
287 |
*/ |
*/ |
288 |
|
|
289 |
for (handlerPtr = winPtr->handlerList, prevPtr = NULL; ; |
for (handlerPtr = winPtr->handlerList, prevPtr = NULL; ; |
290 |
prevPtr = handlerPtr, handlerPtr = handlerPtr->nextPtr) { |
prevPtr = handlerPtr, handlerPtr = handlerPtr->nextPtr) { |
291 |
if (handlerPtr == NULL) { |
if (handlerPtr == NULL) { |
292 |
return; |
return; |
293 |
} |
} |
294 |
if ((handlerPtr->mask == mask) && (handlerPtr->proc == proc) |
if ((handlerPtr->mask == mask) && (handlerPtr->proc == proc) |
295 |
&& (handlerPtr->clientData == clientData)) { |
&& (handlerPtr->clientData == clientData)) { |
296 |
break; |
break; |
297 |
} |
} |
298 |
} |
} |
299 |
|
|
300 |
/* |
/* |
301 |
* If Tk_HandleEvent is about to process this handler, tell it to |
* If Tk_HandleEvent is about to process this handler, tell it to |
302 |
* process the next one instead. |
* process the next one instead. |
303 |
*/ |
*/ |
304 |
|
|
305 |
for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { |
for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; ipPtr = ipPtr->nextPtr) { |
306 |
if (ipPtr->nextHandler == handlerPtr) { |
if (ipPtr->nextHandler == handlerPtr) { |
307 |
ipPtr->nextHandler = handlerPtr->nextPtr; |
ipPtr->nextHandler = handlerPtr->nextPtr; |
308 |
} |
} |
309 |
} |
} |
310 |
|
|
311 |
/* |
/* |
312 |
* Free resources associated with the handler. |
* Free resources associated with the handler. |
313 |
*/ |
*/ |
314 |
|
|
315 |
if (prevPtr == NULL) { |
if (prevPtr == NULL) { |
316 |
winPtr->handlerList = handlerPtr->nextPtr; |
winPtr->handlerList = handlerPtr->nextPtr; |
317 |
} else { |
} else { |
318 |
prevPtr->nextPtr = handlerPtr->nextPtr; |
prevPtr->nextPtr = handlerPtr->nextPtr; |
319 |
} |
} |
320 |
ckfree((char *) handlerPtr); |
ckfree((char *) handlerPtr); |
321 |
|
|
322 |
|
|
323 |
/* |
/* |
324 |
* No need to call XSelectInput: Tk always selects on all events |
* No need to call XSelectInput: Tk always selects on all events |
325 |
* for all windows (needed to support bindings on classes and "all"). |
* for all windows (needed to support bindings on classes and "all"). |
326 |
*/ |
*/ |
327 |
} |
} |
328 |
|
|
329 |
/*-------------------------------------------------------------- |
/*-------------------------------------------------------------- |
330 |
* |
* |
331 |
* Tk_CreateGenericHandler -- |
* Tk_CreateGenericHandler -- |
332 |
* |
* |
333 |
* Register a procedure to be called on each X event, regardless |
* Register a procedure to be called on each X event, regardless |
334 |
* of display or window. Generic handlers are useful for capturing |
* of display or window. Generic handlers are useful for capturing |
335 |
* events that aren't associated with windows, or events for windows |
* events that aren't associated with windows, or events for windows |
336 |
* not managed by Tk. |
* not managed by Tk. |
337 |
* |
* |
338 |
* Results: |
* Results: |
339 |
* None. |
* None. |
340 |
* |
* |
341 |
* Side Effects: |
* Side Effects: |
342 |
* From now on, whenever an X event is given to Tk_HandleEvent, |
* From now on, whenever an X event is given to Tk_HandleEvent, |
343 |
* invoke proc, giving it clientData and the event as arguments. |
* invoke proc, giving it clientData and the event as arguments. |
344 |
* |
* |
345 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
346 |
*/ |
*/ |
347 |
|
|
348 |
void |
void |
349 |
Tk_CreateGenericHandler(proc, clientData) |
Tk_CreateGenericHandler(proc, clientData) |
350 |
Tk_GenericProc *proc; /* Procedure to call on every event. */ |
Tk_GenericProc *proc; /* Procedure to call on every event. */ |
351 |
ClientData clientData; /* One-word value to pass to proc. */ |
ClientData clientData; /* One-word value to pass to proc. */ |
352 |
{ |
{ |
353 |
GenericHandler *handlerPtr; |
GenericHandler *handlerPtr; |
354 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
355 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
356 |
|
|
357 |
handlerPtr = (GenericHandler *) ckalloc (sizeof (GenericHandler)); |
handlerPtr = (GenericHandler *) ckalloc (sizeof (GenericHandler)); |
358 |
|
|
359 |
handlerPtr->proc = proc; |
handlerPtr->proc = proc; |
360 |
handlerPtr->clientData = clientData; |
handlerPtr->clientData = clientData; |
361 |
handlerPtr->deleteFlag = 0; |
handlerPtr->deleteFlag = 0; |
362 |
handlerPtr->nextPtr = NULL; |
handlerPtr->nextPtr = NULL; |
363 |
if (tsdPtr->genericList == NULL) { |
if (tsdPtr->genericList == NULL) { |
364 |
tsdPtr->genericList = handlerPtr; |
tsdPtr->genericList = handlerPtr; |
365 |
} else { |
} else { |
366 |
tsdPtr->lastGenericPtr->nextPtr = handlerPtr; |
tsdPtr->lastGenericPtr->nextPtr = handlerPtr; |
367 |
} |
} |
368 |
tsdPtr->lastGenericPtr = handlerPtr; |
tsdPtr->lastGenericPtr = handlerPtr; |
369 |
} |
} |
370 |
|
|
371 |
/* |
/* |
372 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
373 |
* |
* |
374 |
* Tk_DeleteGenericHandler -- |
* Tk_DeleteGenericHandler -- |
375 |
* |
* |
376 |
* Delete a previously-created generic handler. |
* Delete a previously-created generic handler. |
377 |
* |
* |
378 |
* Results: |
* Results: |
379 |
* None. |
* None. |
380 |
* |
* |
381 |
* Side Effects: |
* Side Effects: |
382 |
* If there existed a handler as described by the parameters, |
* If there existed a handler as described by the parameters, |
383 |
* that handler is logically deleted so that proc will not be |
* that handler is logically deleted so that proc will not be |
384 |
* invoked again. The physical deletion happens in the event |
* invoked again. The physical deletion happens in the event |
385 |
* loop in Tk_HandleEvent. |
* loop in Tk_HandleEvent. |
386 |
* |
* |
387 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
388 |
*/ |
*/ |
389 |
|
|
390 |
void |
void |
391 |
Tk_DeleteGenericHandler(proc, clientData) |
Tk_DeleteGenericHandler(proc, clientData) |
392 |
Tk_GenericProc *proc; |
Tk_GenericProc *proc; |
393 |
ClientData clientData; |
ClientData clientData; |
394 |
{ |
{ |
395 |
GenericHandler * handler; |
GenericHandler * handler; |
396 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
397 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
398 |
|
|
399 |
for (handler = tsdPtr->genericList; handler; handler = handler->nextPtr) { |
for (handler = tsdPtr->genericList; handler; handler = handler->nextPtr) { |
400 |
if ((handler->proc == proc) && (handler->clientData == clientData)) { |
if ((handler->proc == proc) && (handler->clientData == clientData)) { |
401 |
handler->deleteFlag = 1; |
handler->deleteFlag = 1; |
402 |
} |
} |
403 |
} |
} |
404 |
} |
} |
405 |
|
|
406 |
/* |
/* |
407 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
408 |
* |
* |
409 |
* TkEventInit -- |
* TkEventInit -- |
410 |
* |
* |
411 |
* This procedures initializes all the event module |
* This procedures initializes all the event module |
412 |
* structures used by the current thread. It must be |
* structures used by the current thread. It must be |
413 |
* called before any other procedure in this file is |
* called before any other procedure in this file is |
414 |
* called. |
* called. |
415 |
* |
* |
416 |
* Results: |
* Results: |
417 |
* None. |
* None. |
418 |
* |
* |
419 |
* Side Effects: |
* Side Effects: |
420 |
* None. |
* None. |
421 |
* |
* |
422 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
423 |
*/ |
*/ |
424 |
|
|
425 |
void |
void |
426 |
TkEventInit _ANSI_ARGS_((void)) |
TkEventInit _ANSI_ARGS_((void)) |
427 |
{ |
{ |
428 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
429 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
430 |
|
|
431 |
tsdPtr->genericHandlersActive = 0; |
tsdPtr->genericHandlersActive = 0; |
432 |
tsdPtr->pendingPtr = NULL; |
tsdPtr->pendingPtr = NULL; |
433 |
tsdPtr->genericList = NULL; |
tsdPtr->genericList = NULL; |
434 |
tsdPtr->lastGenericPtr = NULL; |
tsdPtr->lastGenericPtr = NULL; |
435 |
tsdPtr->restrictProc = NULL; |
tsdPtr->restrictProc = NULL; |
436 |
tsdPtr->restrictArg = NULL; |
tsdPtr->restrictArg = NULL; |
437 |
} |
} |
438 |
|
|
439 |
/* |
/* |
440 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
441 |
* |
* |
442 |
* Tk_HandleEvent -- |
* Tk_HandleEvent -- |
443 |
* |
* |
444 |
* Given an event, invoke all the handlers that have |
* Given an event, invoke all the handlers that have |
445 |
* been registered for the event. |
* been registered for the event. |
446 |
* |
* |
447 |
* Results: |
* Results: |
448 |
* None. |
* None. |
449 |
* |
* |
450 |
* Side effects: |
* Side effects: |
451 |
* Depends on the handlers. |
* Depends on the handlers. |
452 |
* |
* |
453 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
454 |
*/ |
*/ |
455 |
|
|
456 |
void |
void |
457 |
Tk_HandleEvent(eventPtr) |
Tk_HandleEvent(eventPtr) |
458 |
XEvent *eventPtr; /* Event to dispatch. */ |
XEvent *eventPtr; /* Event to dispatch. */ |
459 |
{ |
{ |
460 |
register TkEventHandler *handlerPtr; |
register TkEventHandler *handlerPtr; |
461 |
register GenericHandler *genericPtr; |
register GenericHandler *genericPtr; |
462 |
register GenericHandler *genPrevPtr; |
register GenericHandler *genPrevPtr; |
463 |
TkWindow *winPtr; |
TkWindow *winPtr; |
464 |
unsigned long mask; |
unsigned long mask; |
465 |
InProgress ip; |
InProgress ip; |
466 |
Window handlerWindow; |
Window handlerWindow; |
467 |
TkDisplay *dispPtr; |
TkDisplay *dispPtr; |
468 |
Tcl_Interp *interp = (Tcl_Interp *) NULL; |
Tcl_Interp *interp = (Tcl_Interp *) NULL; |
469 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
470 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
471 |
|
|
472 |
/* |
/* |
473 |
* Hack for simulated X-events: Correct the state field |
* Hack for simulated X-events: Correct the state field |
474 |
* of the event record to match with the ButtonPress |
* of the event record to match with the ButtonPress |
475 |
* and ButtonRelease events. |
* and ButtonRelease events. |
476 |
*/ |
*/ |
477 |
|
|
478 |
if (eventPtr->type==ButtonPress) { |
if (eventPtr->type==ButtonPress) { |
479 |
dispPtr = TkGetDisplay(eventPtr->xbutton.display); |
dispPtr = TkGetDisplay(eventPtr->xbutton.display); |
480 |
eventPtr->xbutton.state |= dispPtr->mouseButtonState; |
eventPtr->xbutton.state |= dispPtr->mouseButtonState; |
481 |
switch (eventPtr->xbutton.button) { |
switch (eventPtr->xbutton.button) { |
482 |
case 1: dispPtr->mouseButtonState |= Button1Mask; break; |
case 1: dispPtr->mouseButtonState |= Button1Mask; break; |
483 |
case 2: dispPtr->mouseButtonState |= Button2Mask; break; |
case 2: dispPtr->mouseButtonState |= Button2Mask; break; |
484 |
case 3: dispPtr->mouseButtonState |= Button3Mask; break; |
case 3: dispPtr->mouseButtonState |= Button3Mask; break; |
485 |
} |
} |
486 |
} else if (eventPtr->type==ButtonRelease) { |
} else if (eventPtr->type==ButtonRelease) { |
487 |
dispPtr = TkGetDisplay(eventPtr->xbutton.display); |
dispPtr = TkGetDisplay(eventPtr->xbutton.display); |
488 |
switch (eventPtr->xbutton.button) { |
switch (eventPtr->xbutton.button) { |
489 |
case 1: dispPtr->mouseButtonState &= ~Button1Mask; break; |
case 1: dispPtr->mouseButtonState &= ~Button1Mask; break; |
490 |
case 2: dispPtr->mouseButtonState &= ~Button2Mask; break; |
case 2: dispPtr->mouseButtonState &= ~Button2Mask; break; |
491 |
case 3: dispPtr->mouseButtonState &= ~Button3Mask; break; |
case 3: dispPtr->mouseButtonState &= ~Button3Mask; break; |
492 |
} |
} |
493 |
eventPtr->xbutton.state |= dispPtr->mouseButtonState; |
eventPtr->xbutton.state |= dispPtr->mouseButtonState; |
494 |
} else if (eventPtr->type==MotionNotify) { |
} else if (eventPtr->type==MotionNotify) { |
495 |
dispPtr = TkGetDisplay(eventPtr->xmotion.display); |
dispPtr = TkGetDisplay(eventPtr->xmotion.display); |
496 |
eventPtr->xmotion.state |= dispPtr->mouseButtonState; |
eventPtr->xmotion.state |= dispPtr->mouseButtonState; |
497 |
} |
} |
498 |
|
|
499 |
/* |
/* |
500 |
* Next, invoke all the generic event handlers (those that are |
* Next, invoke all the generic event handlers (those that are |
501 |
* invoked for all events). If a generic event handler reports that |
* invoked for all events). If a generic event handler reports that |
502 |
* an event is fully processed, go no further. |
* an event is fully processed, go no further. |
503 |
*/ |
*/ |
504 |
|
|
505 |
for (genPrevPtr = NULL, genericPtr = tsdPtr->genericList; |
for (genPrevPtr = NULL, genericPtr = tsdPtr->genericList; |
506 |
genericPtr != NULL; ) { |
genericPtr != NULL; ) { |
507 |
if (genericPtr->deleteFlag) { |
if (genericPtr->deleteFlag) { |
508 |
if (!tsdPtr->genericHandlersActive) { |
if (!tsdPtr->genericHandlersActive) { |
509 |
GenericHandler *tmpPtr; |
GenericHandler *tmpPtr; |
510 |
|
|
511 |
/* |
/* |
512 |
* This handler needs to be deleted and there are no |
* This handler needs to be deleted and there are no |
513 |
* calls pending through the handler, so now is a safe |
* calls pending through the handler, so now is a safe |
514 |
* time to delete it. |
* time to delete it. |
515 |
*/ |
*/ |
516 |
|
|
517 |
tmpPtr = genericPtr->nextPtr; |
tmpPtr = genericPtr->nextPtr; |
518 |
if (genPrevPtr == NULL) { |
if (genPrevPtr == NULL) { |
519 |
tsdPtr->genericList = tmpPtr; |
tsdPtr->genericList = tmpPtr; |
520 |
} else { |
} else { |
521 |
genPrevPtr->nextPtr = tmpPtr; |
genPrevPtr->nextPtr = tmpPtr; |
522 |
} |
} |
523 |
if (tmpPtr == NULL) { |
if (tmpPtr == NULL) { |
524 |
tsdPtr->lastGenericPtr = genPrevPtr; |
tsdPtr->lastGenericPtr = genPrevPtr; |
525 |
} |
} |
526 |
(void) ckfree((char *) genericPtr); |
(void) ckfree((char *) genericPtr); |
527 |
genericPtr = tmpPtr; |
genericPtr = tmpPtr; |
528 |
continue; |
continue; |
529 |
} |
} |
530 |
} else { |
} else { |
531 |
int done; |
int done; |
532 |
|
|
533 |
tsdPtr->genericHandlersActive++; |
tsdPtr->genericHandlersActive++; |
534 |
done = (*genericPtr->proc)(genericPtr->clientData, eventPtr); |
done = (*genericPtr->proc)(genericPtr->clientData, eventPtr); |
535 |
tsdPtr->genericHandlersActive--; |
tsdPtr->genericHandlersActive--; |
536 |
if (done) { |
if (done) { |
537 |
return; |
return; |
538 |
} |
} |
539 |
} |
} |
540 |
genPrevPtr = genericPtr; |
genPrevPtr = genericPtr; |
541 |
genericPtr = genPrevPtr->nextPtr; |
genericPtr = genPrevPtr->nextPtr; |
542 |
} |
} |
543 |
|
|
544 |
/* |
/* |
545 |
* If the event is a MappingNotify event, find its display and |
* If the event is a MappingNotify event, find its display and |
546 |
* refresh the keyboard mapping information for the display. |
* refresh the keyboard mapping information for the display. |
547 |
* After that there's nothing else to do with the event, so just |
* After that there's nothing else to do with the event, so just |
548 |
* quit. |
* quit. |
549 |
*/ |
*/ |
550 |
|
|
551 |
if (eventPtr->type == MappingNotify) { |
if (eventPtr->type == MappingNotify) { |
552 |
dispPtr = TkGetDisplay(eventPtr->xmapping.display); |
dispPtr = TkGetDisplay(eventPtr->xmapping.display); |
553 |
if (dispPtr != NULL) { |
if (dispPtr != NULL) { |
554 |
XRefreshKeyboardMapping(&eventPtr->xmapping); |
XRefreshKeyboardMapping(&eventPtr->xmapping); |
555 |
dispPtr->bindInfoStale = 1; |
dispPtr->bindInfoStale = 1; |
556 |
} |
} |
557 |
return; |
return; |
558 |
} |
} |
559 |
|
|
560 |
/* |
/* |
561 |
* Events selected by StructureNotify require special handling. |
* Events selected by StructureNotify require special handling. |
562 |
* They look the same as those selected by SubstructureNotify. |
* They look the same as those selected by SubstructureNotify. |
563 |
* The only difference is whether the "event" and "window" fields |
* The only difference is whether the "event" and "window" fields |
564 |
* are the same. Compare the two fields and convert StructureNotify |
* are the same. Compare the two fields and convert StructureNotify |
565 |
* to SubstructureNotify if necessary. |
* to SubstructureNotify if necessary. |
566 |
*/ |
*/ |
567 |
|
|
568 |
handlerWindow = eventPtr->xany.window; |
handlerWindow = eventPtr->xany.window; |
569 |
mask = eventMasks[eventPtr->xany.type]; |
mask = eventMasks[eventPtr->xany.type]; |
570 |
if (mask == StructureNotifyMask) { |
if (mask == StructureNotifyMask) { |
571 |
if (eventPtr->xmap.event != eventPtr->xmap.window) { |
if (eventPtr->xmap.event != eventPtr->xmap.window) { |
572 |
mask = SubstructureNotifyMask; |
mask = SubstructureNotifyMask; |
573 |
handlerWindow = eventPtr->xmap.event; |
handlerWindow = eventPtr->xmap.event; |
574 |
} |
} |
575 |
} |
} |
576 |
winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, handlerWindow); |
winPtr = (TkWindow *) Tk_IdToWindow(eventPtr->xany.display, handlerWindow); |
577 |
if (winPtr == NULL) { |
if (winPtr == NULL) { |
578 |
|
|
579 |
/* |
/* |
580 |
* There isn't a TkWindow structure for this window. |
* There isn't a TkWindow structure for this window. |
581 |
* However, if the event is a PropertyNotify event then call |
* However, if the event is a PropertyNotify event then call |
582 |
* the selection manager (it deals beneath-the-table with |
* the selection manager (it deals beneath-the-table with |
583 |
* certain properties). |
* certain properties). |
584 |
*/ |
*/ |
585 |
|
|
586 |
if (eventPtr->type == PropertyNotify) { |
if (eventPtr->type == PropertyNotify) { |
587 |
TkSelPropProc(eventPtr); |
TkSelPropProc(eventPtr); |
588 |
} |
} |
589 |
return; |
return; |
590 |
} |
} |
591 |
|
|
592 |
/* |
/* |
593 |
* Once a window has started getting deleted, don't process any more |
* Once a window has started getting deleted, don't process any more |
594 |
* events for it except for the DestroyNotify event. This check is |
* events for it except for the DestroyNotify event. This check is |
595 |
* needed because a DestroyNotify handler could re-invoke the event |
* needed because a DestroyNotify handler could re-invoke the event |
596 |
* loop, causing other pending events to be handled for the window |
* loop, causing other pending events to be handled for the window |
597 |
* (the window doesn't get totally expunged from our tables until |
* (the window doesn't get totally expunged from our tables until |
598 |
* after the DestroyNotify event has been completely handled). |
* after the DestroyNotify event has been completely handled). |
599 |
*/ |
*/ |
600 |
|
|
601 |
if ((winPtr->flags & TK_ALREADY_DEAD) |
if ((winPtr->flags & TK_ALREADY_DEAD) |
602 |
&& (eventPtr->type != DestroyNotify)) { |
&& (eventPtr->type != DestroyNotify)) { |
603 |
return; |
return; |
604 |
} |
} |
605 |
|
|
606 |
if (winPtr->mainPtr != NULL) { |
if (winPtr->mainPtr != NULL) { |
607 |
|
|
608 |
/* |
/* |
609 |
* Protect interpreter for this window from possible deletion |
* Protect interpreter for this window from possible deletion |
610 |
* while we are dealing with the event for this window. Thus, |
* while we are dealing with the event for this window. Thus, |
611 |
* widget writers do not have to worry about protecting the |
* widget writers do not have to worry about protecting the |
612 |
* interpreter in their own code. |
* interpreter in their own code. |
613 |
*/ |
*/ |
614 |
|
|
615 |
interp = winPtr->mainPtr->interp; |
interp = winPtr->mainPtr->interp; |
616 |
Tcl_Preserve((ClientData) interp); |
Tcl_Preserve((ClientData) interp); |
617 |
|
|
618 |
/* |
/* |
619 |
* Call focus-related code to look at FocusIn, FocusOut, Enter, |
* Call focus-related code to look at FocusIn, FocusOut, Enter, |
620 |
* and Leave events; depending on its return value, ignore the |
* and Leave events; depending on its return value, ignore the |
621 |
* event. |
* event. |
622 |
*/ |
*/ |
623 |
|
|
624 |
if ((mask & (FocusChangeMask|EnterWindowMask|LeaveWindowMask)) |
if ((mask & (FocusChangeMask|EnterWindowMask|LeaveWindowMask)) |
625 |
&& !TkFocusFilterEvent(winPtr, eventPtr)) { |
&& !TkFocusFilterEvent(winPtr, eventPtr)) { |
626 |
Tcl_Release((ClientData) interp); |
Tcl_Release((ClientData) interp); |
627 |
return; |
return; |
628 |
} |
} |
629 |
|
|
630 |
/* |
/* |
631 |
* Redirect KeyPress and KeyRelease events to the focus window, |
* Redirect KeyPress and KeyRelease events to the focus window, |
632 |
* or ignore them entirely if there is no focus window. We also |
* or ignore them entirely if there is no focus window. We also |
633 |
* route the MouseWheel event to the focus window. The MouseWheel |
* route the MouseWheel event to the focus window. The MouseWheel |
634 |
* event is an extension to the X event set. Currently, it is only |
* event is an extension to the X event set. Currently, it is only |
635 |
* available on the Windows version of Tk. |
* available on the Windows version of Tk. |
636 |
*/ |
*/ |
637 |
|
|
638 |
if (mask & (KeyPressMask|KeyReleaseMask|MouseWheelMask)) { |
if (mask & (KeyPressMask|KeyReleaseMask|MouseWheelMask)) { |
639 |
winPtr->dispPtr->lastEventTime = eventPtr->xkey.time; |
winPtr->dispPtr->lastEventTime = eventPtr->xkey.time; |
640 |
winPtr = TkFocusKeyEvent(winPtr, eventPtr); |
winPtr = TkFocusKeyEvent(winPtr, eventPtr); |
641 |
if (winPtr == NULL) { |
if (winPtr == NULL) { |
642 |
Tcl_Release((ClientData) interp); |
Tcl_Release((ClientData) interp); |
643 |
return; |
return; |
644 |
} |
} |
645 |
} |
} |
646 |
|
|
647 |
/* |
/* |
648 |
* Call a grab-related procedure to do special processing on |
* Call a grab-related procedure to do special processing on |
649 |
* pointer events. |
* pointer events. |
650 |
*/ |
*/ |
651 |
|
|
652 |
if (mask & (ButtonPressMask|ButtonReleaseMask|PointerMotionMask |
if (mask & (ButtonPressMask|ButtonReleaseMask|PointerMotionMask |
653 |
|EnterWindowMask|LeaveWindowMask)) { |
|EnterWindowMask|LeaveWindowMask)) { |
654 |
if (mask & (ButtonPressMask|ButtonReleaseMask)) { |
if (mask & (ButtonPressMask|ButtonReleaseMask)) { |
655 |
winPtr->dispPtr->lastEventTime = eventPtr->xbutton.time; |
winPtr->dispPtr->lastEventTime = eventPtr->xbutton.time; |
656 |
} else if (mask & PointerMotionMask) { |
} else if (mask & PointerMotionMask) { |
657 |
winPtr->dispPtr->lastEventTime = eventPtr->xmotion.time; |
winPtr->dispPtr->lastEventTime = eventPtr->xmotion.time; |
658 |
} else { |
} else { |
659 |
winPtr->dispPtr->lastEventTime = eventPtr->xcrossing.time; |
winPtr->dispPtr->lastEventTime = eventPtr->xcrossing.time; |
660 |
} |
} |
661 |
if (TkPointerEvent(eventPtr, winPtr) == 0) { |
if (TkPointerEvent(eventPtr, winPtr) == 0) { |
662 |
goto done; |
goto done; |
663 |
} |
} |
664 |
} |
} |
665 |
} |
} |
666 |
|
|
667 |
#ifdef TK_USE_INPUT_METHODS |
#ifdef TK_USE_INPUT_METHODS |
668 |
/* |
/* |
669 |
* Pass the event to the input method(s), if there are any, and |
* Pass the event to the input method(s), if there are any, and |
670 |
* discard the event if the input method(s) insist. Create the |
* discard the event if the input method(s) insist. Create the |
671 |
* input context for the window if it hasn't already been done |
* input context for the window if it hasn't already been done |
672 |
* (XFilterEvent needs this context). |
* (XFilterEvent needs this context). |
673 |
*/ |
*/ |
674 |
if (winPtr->dispPtr->useInputMethods) { |
if (winPtr->dispPtr->useInputMethods) { |
675 |
if (!(winPtr->flags & TK_CHECKED_IC)) { |
if (!(winPtr->flags & TK_CHECKED_IC)) { |
676 |
if (winPtr->dispPtr->inputMethod != NULL) { |
if (winPtr->dispPtr->inputMethod != NULL) { |
677 |
winPtr->inputContext = XCreateIC( |
winPtr->inputContext = XCreateIC( |
678 |
winPtr->dispPtr->inputMethod, XNInputStyle, |
winPtr->dispPtr->inputMethod, XNInputStyle, |
679 |
XIMPreeditNothing|XIMStatusNothing, |
XIMPreeditNothing|XIMStatusNothing, |
680 |
XNClientWindow, winPtr->window, |
XNClientWindow, winPtr->window, |
681 |
XNFocusWindow, winPtr->window, NULL); |
XNFocusWindow, winPtr->window, NULL); |
682 |
} |
} |
683 |
winPtr->flags |= TK_CHECKED_IC; |
winPtr->flags |= TK_CHECKED_IC; |
684 |
} |
} |
685 |
if (XFilterEvent(eventPtr, None)) { |
if (XFilterEvent(eventPtr, None)) { |
686 |
goto done; |
goto done; |
687 |
} |
} |
688 |
} |
} |
689 |
#endif /* TK_USE_INPUT_METHODS */ |
#endif /* TK_USE_INPUT_METHODS */ |
690 |
|
|
691 |
/* |
/* |
692 |
* For events where it hasn't already been done, update the current |
* For events where it hasn't already been done, update the current |
693 |
* time in the display. |
* time in the display. |
694 |
*/ |
*/ |
695 |
|
|
696 |
if (eventPtr->type == PropertyNotify) { |
if (eventPtr->type == PropertyNotify) { |
697 |
winPtr->dispPtr->lastEventTime = eventPtr->xproperty.time; |
winPtr->dispPtr->lastEventTime = eventPtr->xproperty.time; |
698 |
} |
} |
699 |
|
|
700 |
/* |
/* |
701 |
* There's a potential interaction here with Tk_DeleteEventHandler. |
* There's a potential interaction here with Tk_DeleteEventHandler. |
702 |
* Read the documentation for pendingPtr. |
* Read the documentation for pendingPtr. |
703 |
*/ |
*/ |
704 |
|
|
705 |
ip.eventPtr = eventPtr; |
ip.eventPtr = eventPtr; |
706 |
ip.winPtr = winPtr; |
ip.winPtr = winPtr; |
707 |
ip.nextHandler = NULL; |
ip.nextHandler = NULL; |
708 |
ip.nextPtr = tsdPtr->pendingPtr; |
ip.nextPtr = tsdPtr->pendingPtr; |
709 |
tsdPtr->pendingPtr = &ip; |
tsdPtr->pendingPtr = &ip; |
710 |
if (mask == 0) { |
if (mask == 0) { |
711 |
if ((eventPtr->type == SelectionClear) |
if ((eventPtr->type == SelectionClear) |
712 |
|| (eventPtr->type == SelectionRequest) |
|| (eventPtr->type == SelectionRequest) |
713 |
|| (eventPtr->type == SelectionNotify)) { |
|| (eventPtr->type == SelectionNotify)) { |
714 |
TkSelEventProc((Tk_Window) winPtr, eventPtr); |
TkSelEventProc((Tk_Window) winPtr, eventPtr); |
715 |
} else if ((eventPtr->type == ClientMessage) |
} else if ((eventPtr->type == ClientMessage) |
716 |
&& (eventPtr->xclient.message_type == |
&& (eventPtr->xclient.message_type == |
717 |
Tk_InternAtom((Tk_Window) winPtr, "WM_PROTOCOLS"))) { |
Tk_InternAtom((Tk_Window) winPtr, "WM_PROTOCOLS"))) { |
718 |
TkWmProtocolEventProc(winPtr, eventPtr); |
TkWmProtocolEventProc(winPtr, eventPtr); |
719 |
} |
} |
720 |
} else { |
} else { |
721 |
for (handlerPtr = winPtr->handlerList; handlerPtr != NULL; ) { |
for (handlerPtr = winPtr->handlerList; handlerPtr != NULL; ) { |
722 |
if ((handlerPtr->mask & mask) != 0) { |
if ((handlerPtr->mask & mask) != 0) { |
723 |
ip.nextHandler = handlerPtr->nextPtr; |
ip.nextHandler = handlerPtr->nextPtr; |
724 |
(*(handlerPtr->proc))(handlerPtr->clientData, eventPtr); |
(*(handlerPtr->proc))(handlerPtr->clientData, eventPtr); |
725 |
handlerPtr = ip.nextHandler; |
handlerPtr = ip.nextHandler; |
726 |
} else { |
} else { |
727 |
handlerPtr = handlerPtr->nextPtr; |
handlerPtr = handlerPtr->nextPtr; |
728 |
} |
} |
729 |
} |
} |
730 |
|
|
731 |
/* |
/* |
732 |
* Pass the event to the "bind" command mechanism. But, don't |
* Pass the event to the "bind" command mechanism. But, don't |
733 |
* do this for SubstructureNotify events. The "bind" command |
* do this for SubstructureNotify events. The "bind" command |
734 |
* doesn't support them anyway, and it's easier to filter out |
* doesn't support them anyway, and it's easier to filter out |
735 |
* these events here than in the lower-level procedures. |
* these events here than in the lower-level procedures. |
736 |
*/ |
*/ |
737 |
|
|
738 |
if ((ip.winPtr != None) && (mask != SubstructureNotifyMask)) { |
if ((ip.winPtr != None) && (mask != SubstructureNotifyMask)) { |
739 |
TkBindEventProc(winPtr, eventPtr); |
TkBindEventProc(winPtr, eventPtr); |
740 |
} |
} |
741 |
} |
} |
742 |
tsdPtr->pendingPtr = ip.nextPtr; |
tsdPtr->pendingPtr = ip.nextPtr; |
743 |
done: |
done: |
744 |
|
|
745 |
/* |
/* |
746 |
* Release the interpreter for this window so that it can be potentially |
* Release the interpreter for this window so that it can be potentially |
747 |
* deleted if requested. |
* deleted if requested. |
748 |
*/ |
*/ |
749 |
|
|
750 |
if (interp != (Tcl_Interp *) NULL) { |
if (interp != (Tcl_Interp *) NULL) { |
751 |
Tcl_Release((ClientData) interp); |
Tcl_Release((ClientData) interp); |
752 |
} |
} |
753 |
} |
} |
754 |
|
|
755 |
/* |
/* |
756 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
757 |
* |
* |
758 |
* TkEventDeadWindow -- |
* TkEventDeadWindow -- |
759 |
* |
* |
760 |
* This procedure is invoked when it is determined that |
* This procedure is invoked when it is determined that |
761 |
* a window is dead. It cleans up event-related information |
* a window is dead. It cleans up event-related information |
762 |
* about the window. |
* about the window. |
763 |
* |
* |
764 |
* Results: |
* Results: |
765 |
* None. |
* None. |
766 |
* |
* |
767 |
* Side effects: |
* Side effects: |
768 |
* Various things get cleaned up and recycled. |
* Various things get cleaned up and recycled. |
769 |
* |
* |
770 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
771 |
*/ |
*/ |
772 |
|
|
773 |
void |
void |
774 |
TkEventDeadWindow(winPtr) |
TkEventDeadWindow(winPtr) |
775 |
TkWindow *winPtr; /* Information about the window |
TkWindow *winPtr; /* Information about the window |
776 |
* that is being deleted. */ |
* that is being deleted. */ |
777 |
{ |
{ |
778 |
register TkEventHandler *handlerPtr; |
register TkEventHandler *handlerPtr; |
779 |
register InProgress *ipPtr; |
register InProgress *ipPtr; |
780 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
781 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
782 |
|
|
783 |
/* |
/* |
784 |
* While deleting all the handlers, be careful to check for |
* While deleting all the handlers, be careful to check for |
785 |
* Tk_HandleEvent being about to process one of the deleted |
* Tk_HandleEvent being about to process one of the deleted |
786 |
* handlers. If it is, tell it to quit (all of the handlers |
* handlers. If it is, tell it to quit (all of the handlers |
787 |
* are being deleted). |
* are being deleted). |
788 |
*/ |
*/ |
789 |
|
|
790 |
while (winPtr->handlerList != NULL) { |
while (winPtr->handlerList != NULL) { |
791 |
handlerPtr = winPtr->handlerList; |
handlerPtr = winPtr->handlerList; |
792 |
winPtr->handlerList = handlerPtr->nextPtr; |
winPtr->handlerList = handlerPtr->nextPtr; |
793 |
for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; |
for (ipPtr = tsdPtr->pendingPtr; ipPtr != NULL; |
794 |
ipPtr = ipPtr->nextPtr) { |
ipPtr = ipPtr->nextPtr) { |
795 |
if (ipPtr->nextHandler == handlerPtr) { |
if (ipPtr->nextHandler == handlerPtr) { |
796 |
ipPtr->nextHandler = NULL; |
ipPtr->nextHandler = NULL; |
797 |
} |
} |
798 |
if (ipPtr->winPtr == winPtr) { |
if (ipPtr->winPtr == winPtr) { |
799 |
ipPtr->winPtr = None; |
ipPtr->winPtr = None; |
800 |
} |
} |
801 |
} |
} |
802 |
ckfree((char *) handlerPtr); |
ckfree((char *) handlerPtr); |
803 |
} |
} |
804 |
} |
} |
805 |
|
|
806 |
/* |
/* |
807 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
808 |
* |
* |
809 |
* TkCurrentTime -- |
* TkCurrentTime -- |
810 |
* |
* |
811 |
* Try to deduce the current time. "Current time" means the time |
* Try to deduce the current time. "Current time" means the time |
812 |
* of the event that led to the current code being executed, which |
* of the event that led to the current code being executed, which |
813 |
* means the time in the most recently-nested invocation of |
* means the time in the most recently-nested invocation of |
814 |
* Tk_HandleEvent. |
* Tk_HandleEvent. |
815 |
* |
* |
816 |
* Results: |
* Results: |
817 |
* The return value is the time from the current event, or |
* The return value is the time from the current event, or |
818 |
* CurrentTime if there is no current event or if the current |
* CurrentTime if there is no current event or if the current |
819 |
* event contains no time. |
* event contains no time. |
820 |
* |
* |
821 |
* Side effects: |
* Side effects: |
822 |
* None. |
* None. |
823 |
* |
* |
824 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
825 |
*/ |
*/ |
826 |
|
|
827 |
Time |
Time |
828 |
TkCurrentTime(dispPtr) |
TkCurrentTime(dispPtr) |
829 |
TkDisplay *dispPtr; /* Display for which the time is desired. */ |
TkDisplay *dispPtr; /* Display for which the time is desired. */ |
830 |
{ |
{ |
831 |
register XEvent *eventPtr; |
register XEvent *eventPtr; |
832 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
833 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
834 |
|
|
835 |
if (tsdPtr->pendingPtr == NULL) { |
if (tsdPtr->pendingPtr == NULL) { |
836 |
return dispPtr->lastEventTime; |
return dispPtr->lastEventTime; |
837 |
} |
} |
838 |
eventPtr = tsdPtr->pendingPtr->eventPtr; |
eventPtr = tsdPtr->pendingPtr->eventPtr; |
839 |
switch (eventPtr->type) { |
switch (eventPtr->type) { |
840 |
case ButtonPress: |
case ButtonPress: |
841 |
case ButtonRelease: |
case ButtonRelease: |
842 |
return eventPtr->xbutton.time; |
return eventPtr->xbutton.time; |
843 |
case KeyPress: |
case KeyPress: |
844 |
case KeyRelease: |
case KeyRelease: |
845 |
return eventPtr->xkey.time; |
return eventPtr->xkey.time; |
846 |
case MotionNotify: |
case MotionNotify: |
847 |
return eventPtr->xmotion.time; |
return eventPtr->xmotion.time; |
848 |
case EnterNotify: |
case EnterNotify: |
849 |
case LeaveNotify: |
case LeaveNotify: |
850 |
return eventPtr->xcrossing.time; |
return eventPtr->xcrossing.time; |
851 |
case PropertyNotify: |
case PropertyNotify: |
852 |
return eventPtr->xproperty.time; |
return eventPtr->xproperty.time; |
853 |
} |
} |
854 |
return dispPtr->lastEventTime; |
return dispPtr->lastEventTime; |
855 |
} |
} |
856 |
|
|
857 |
/* |
/* |
858 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
859 |
* |
* |
860 |
* Tk_RestrictEvents -- |
* Tk_RestrictEvents -- |
861 |
* |
* |
862 |
* This procedure is used to globally restrict the set of events |
* This procedure is used to globally restrict the set of events |
863 |
* that will be dispatched. The restriction is done by filtering |
* that will be dispatched. The restriction is done by filtering |
864 |
* all incoming X events through a procedure that determines |
* all incoming X events through a procedure that determines |
865 |
* whether they are to be processed immediately, deferred, or |
* whether they are to be processed immediately, deferred, or |
866 |
* discarded. |
* discarded. |
867 |
* |
* |
868 |
* Results: |
* Results: |
869 |
* The return value is the previous restriction procedure in effect, |
* The return value is the previous restriction procedure in effect, |
870 |
* if there was one, or NULL if there wasn't. |
* if there was one, or NULL if there wasn't. |
871 |
* |
* |
872 |
* Side effects: |
* Side effects: |
873 |
* From now on, proc will be called to determine whether to process, |
* From now on, proc will be called to determine whether to process, |
874 |
* defer or discard each incoming X event. |
* defer or discard each incoming X event. |
875 |
* |
* |
876 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
877 |
*/ |
*/ |
878 |
|
|
879 |
Tk_RestrictProc * |
Tk_RestrictProc * |
880 |
Tk_RestrictEvents(proc, arg, prevArgPtr) |
Tk_RestrictEvents(proc, arg, prevArgPtr) |
881 |
Tk_RestrictProc *proc; /* Procedure to call for each incoming |
Tk_RestrictProc *proc; /* Procedure to call for each incoming |
882 |
* event. */ |
* event. */ |
883 |
ClientData arg; /* Arbitrary argument to pass to proc. */ |
ClientData arg; /* Arbitrary argument to pass to proc. */ |
884 |
ClientData *prevArgPtr; /* Place to store information about previous |
ClientData *prevArgPtr; /* Place to store information about previous |
885 |
* argument. */ |
* argument. */ |
886 |
{ |
{ |
887 |
Tk_RestrictProc *prev; |
Tk_RestrictProc *prev; |
888 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
889 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
890 |
|
|
891 |
prev = tsdPtr->restrictProc; |
prev = tsdPtr->restrictProc; |
892 |
*prevArgPtr = tsdPtr->restrictArg; |
*prevArgPtr = tsdPtr->restrictArg; |
893 |
tsdPtr->restrictProc = proc; |
tsdPtr->restrictProc = proc; |
894 |
tsdPtr->restrictArg = arg; |
tsdPtr->restrictArg = arg; |
895 |
return prev; |
return prev; |
896 |
} |
} |
897 |
|
|
898 |
/* |
/* |
899 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
900 |
* |
* |
901 |
* Tk_QueueWindowEvent -- |
* Tk_QueueWindowEvent -- |
902 |
* |
* |
903 |
* Given an X-style window event, this procedure adds it to the |
* Given an X-style window event, this procedure adds it to the |
904 |
* Tcl event queue at the given position. This procedure also |
* Tcl event queue at the given position. This procedure also |
905 |
* performs mouse motion event collapsing if possible. |
* performs mouse motion event collapsing if possible. |
906 |
* |
* |
907 |
* Results: |
* Results: |
908 |
* None. |
* None. |
909 |
* |
* |
910 |
* Side effects: |
* Side effects: |
911 |
* Adds stuff to the event queue, which will eventually be |
* Adds stuff to the event queue, which will eventually be |
912 |
* processed. |
* processed. |
913 |
* |
* |
914 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
915 |
*/ |
*/ |
916 |
|
|
917 |
void |
void |
918 |
Tk_QueueWindowEvent(eventPtr, position) |
Tk_QueueWindowEvent(eventPtr, position) |
919 |
XEvent *eventPtr; /* Event to add to queue. This |
XEvent *eventPtr; /* Event to add to queue. This |
920 |
* procedures copies it before adding |
* procedures copies it before adding |
921 |
* it to the queue. */ |
* it to the queue. */ |
922 |
Tcl_QueuePosition position; /* Where to put it on the queue: |
Tcl_QueuePosition position; /* Where to put it on the queue: |
923 |
* TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, |
* TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, |
924 |
* or TCL_QUEUE_MARK. */ |
* or TCL_QUEUE_MARK. */ |
925 |
{ |
{ |
926 |
TkWindowEvent *wevPtr; |
TkWindowEvent *wevPtr; |
927 |
TkDisplay *dispPtr; |
TkDisplay *dispPtr; |
928 |
|
|
929 |
/* |
/* |
930 |
* Find our display structure for the event's display. |
* Find our display structure for the event's display. |
931 |
*/ |
*/ |
932 |
|
|
933 |
for (dispPtr = TkGetDisplayList(); ; dispPtr = dispPtr->nextPtr) { |
for (dispPtr = TkGetDisplayList(); ; dispPtr = dispPtr->nextPtr) { |
934 |
if (dispPtr == NULL) { |
if (dispPtr == NULL) { |
935 |
return; |
return; |
936 |
} |
} |
937 |
if (dispPtr->display == eventPtr->xany.display) { |
if (dispPtr->display == eventPtr->xany.display) { |
938 |
break; |
break; |
939 |
} |
} |
940 |
} |
} |
941 |
|
|
942 |
if ((dispPtr->delayedMotionPtr != NULL) && (position == TCL_QUEUE_TAIL)) { |
if ((dispPtr->delayedMotionPtr != NULL) && (position == TCL_QUEUE_TAIL)) { |
943 |
if ((eventPtr->type == MotionNotify) && (eventPtr->xmotion.window |
if ((eventPtr->type == MotionNotify) && (eventPtr->xmotion.window |
944 |
== dispPtr->delayedMotionPtr->event.xmotion.window)) { |
== dispPtr->delayedMotionPtr->event.xmotion.window)) { |
945 |
/* |
/* |
946 |
* The new event is a motion event in the same window as the |
* The new event is a motion event in the same window as the |
947 |
* saved motion event. Just replace the saved event with the |
* saved motion event. Just replace the saved event with the |
948 |
* new one. |
* new one. |
949 |
*/ |
*/ |
950 |
|
|
951 |
dispPtr->delayedMotionPtr->event = *eventPtr; |
dispPtr->delayedMotionPtr->event = *eventPtr; |
952 |
return; |
return; |
953 |
} else if ((eventPtr->type != GraphicsExpose) |
} else if ((eventPtr->type != GraphicsExpose) |
954 |
&& (eventPtr->type != NoExpose) |
&& (eventPtr->type != NoExpose) |
955 |
&& (eventPtr->type != Expose)) { |
&& (eventPtr->type != Expose)) { |
956 |
/* |
/* |
957 |
* The new event may conflict with the saved motion event. Queue |
* The new event may conflict with the saved motion event. Queue |
958 |
* the saved motion event now so that it will be processed before |
* the saved motion event now so that it will be processed before |
959 |
* the new event. |
* the new event. |
960 |
*/ |
*/ |
961 |
|
|
962 |
Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, position); |
Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, position); |
963 |
dispPtr->delayedMotionPtr = NULL; |
dispPtr->delayedMotionPtr = NULL; |
964 |
Tcl_CancelIdleCall(DelayedMotionProc, (ClientData) dispPtr); |
Tcl_CancelIdleCall(DelayedMotionProc, (ClientData) dispPtr); |
965 |
} |
} |
966 |
} |
} |
967 |
|
|
968 |
wevPtr = (TkWindowEvent *) ckalloc(sizeof(TkWindowEvent)); |
wevPtr = (TkWindowEvent *) ckalloc(sizeof(TkWindowEvent)); |
969 |
wevPtr->header.proc = WindowEventProc; |
wevPtr->header.proc = WindowEventProc; |
970 |
wevPtr->event = *eventPtr; |
wevPtr->event = *eventPtr; |
971 |
if ((eventPtr->type == MotionNotify) && (position == TCL_QUEUE_TAIL)) { |
if ((eventPtr->type == MotionNotify) && (position == TCL_QUEUE_TAIL)) { |
972 |
/* |
/* |
973 |
* The new event is a motion event so don't queue it immediately; |
* The new event is a motion event so don't queue it immediately; |
974 |
* save it around in case another motion event arrives that it can |
* save it around in case another motion event arrives that it can |
975 |
* be collapsed with. |
* be collapsed with. |
976 |
*/ |
*/ |
977 |
|
|
978 |
if (dispPtr->delayedMotionPtr != NULL) { |
if (dispPtr->delayedMotionPtr != NULL) { |
979 |
panic("Tk_QueueWindowEvent found unexpected delayed motion event"); |
panic("Tk_QueueWindowEvent found unexpected delayed motion event"); |
980 |
} |
} |
981 |
dispPtr->delayedMotionPtr = wevPtr; |
dispPtr->delayedMotionPtr = wevPtr; |
982 |
Tcl_DoWhenIdle(DelayedMotionProc, (ClientData) dispPtr); |
Tcl_DoWhenIdle(DelayedMotionProc, (ClientData) dispPtr); |
983 |
} else { |
} else { |
984 |
Tcl_QueueEvent(&wevPtr->header, position); |
Tcl_QueueEvent(&wevPtr->header, position); |
985 |
} |
} |
986 |
} |
} |
987 |
|
|
988 |
/* |
/* |
989 |
*--------------------------------------------------------------------------- |
*--------------------------------------------------------------------------- |
990 |
* |
* |
991 |
* TkQueueEventForAllChildren -- |
* TkQueueEventForAllChildren -- |
992 |
* |
* |
993 |
* Given an XEvent, recursively queue the event for this window and |
* Given an XEvent, recursively queue the event for this window and |
994 |
* all non-toplevel children of the given window. |
* all non-toplevel children of the given window. |
995 |
* |
* |
996 |
* Results: |
* Results: |
997 |
* None. |
* None. |
998 |
* |
* |
999 |
* Side effects: |
* Side effects: |
1000 |
* Events queued. |
* Events queued. |
1001 |
* |
* |
1002 |
*--------------------------------------------------------------------------- |
*--------------------------------------------------------------------------- |
1003 |
*/ |
*/ |
1004 |
|
|
1005 |
void |
void |
1006 |
TkQueueEventForAllChildren(winPtr, eventPtr) |
TkQueueEventForAllChildren(winPtr, eventPtr) |
1007 |
TkWindow *winPtr; /* Window to which event is sent. */ |
TkWindow *winPtr; /* Window to which event is sent. */ |
1008 |
XEvent *eventPtr; /* The event to be sent. */ |
XEvent *eventPtr; /* The event to be sent. */ |
1009 |
{ |
{ |
1010 |
TkWindow *childPtr; |
TkWindow *childPtr; |
1011 |
|
|
1012 |
eventPtr->xany.window = winPtr->window; |
eventPtr->xany.window = winPtr->window; |
1013 |
Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL); |
Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL); |
1014 |
|
|
1015 |
childPtr = winPtr->childList; |
childPtr = winPtr->childList; |
1016 |
while (childPtr != NULL) { |
while (childPtr != NULL) { |
1017 |
if (!Tk_IsTopLevel(childPtr)) { |
if (!Tk_IsTopLevel(childPtr)) { |
1018 |
TkQueueEventForAllChildren(childPtr, eventPtr); |
TkQueueEventForAllChildren(childPtr, eventPtr); |
1019 |
} |
} |
1020 |
childPtr = childPtr->nextPtr; |
childPtr = childPtr->nextPtr; |
1021 |
} |
} |
1022 |
} |
} |
1023 |
|
|
1024 |
/* |
/* |
1025 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
1026 |
* |
* |
1027 |
* WindowEventProc -- |
* WindowEventProc -- |
1028 |
* |
* |
1029 |
* This procedure is called by Tcl_DoOneEvent when a window event |
* This procedure is called by Tcl_DoOneEvent when a window event |
1030 |
* reaches the front of the event queue. This procedure is responsible |
* reaches the front of the event queue. This procedure is responsible |
1031 |
* for actually handling the event. |
* for actually handling the event. |
1032 |
* |
* |
1033 |
* Results: |
* Results: |
1034 |
* Returns 1 if the event was handled, meaning it should be removed |
* Returns 1 if the event was handled, meaning it should be removed |
1035 |
* from the queue. Returns 0 if the event was not handled, meaning |
* from the queue. Returns 0 if the event was not handled, meaning |
1036 |
* it should stay on the queue. The event isn't handled if the |
* it should stay on the queue. The event isn't handled if the |
1037 |
* TCL_WINDOW_EVENTS bit isn't set in flags, if a restrict proc |
* TCL_WINDOW_EVENTS bit isn't set in flags, if a restrict proc |
1038 |
* prevents the event from being handled. |
* prevents the event from being handled. |
1039 |
* |
* |
1040 |
* Side effects: |
* Side effects: |
1041 |
* Whatever the event handlers for the event do. |
* Whatever the event handlers for the event do. |
1042 |
* |
* |
1043 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
1044 |
*/ |
*/ |
1045 |
|
|
1046 |
static int |
static int |
1047 |
WindowEventProc(evPtr, flags) |
WindowEventProc(evPtr, flags) |
1048 |
Tcl_Event *evPtr; /* Event to service. */ |
Tcl_Event *evPtr; /* Event to service. */ |
1049 |
int flags; /* Flags that indicate what events to |
int flags; /* Flags that indicate what events to |
1050 |
* handle, such as TCL_WINDOW_EVENTS. */ |
* handle, such as TCL_WINDOW_EVENTS. */ |
1051 |
{ |
{ |
1052 |
TkWindowEvent *wevPtr = (TkWindowEvent *) evPtr; |
TkWindowEvent *wevPtr = (TkWindowEvent *) evPtr; |
1053 |
Tk_RestrictAction result; |
Tk_RestrictAction result; |
1054 |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
ThreadSpecificData *tsdPtr = (ThreadSpecificData *) |
1055 |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); |
1056 |
|
|
1057 |
if (!(flags & TCL_WINDOW_EVENTS)) { |
if (!(flags & TCL_WINDOW_EVENTS)) { |
1058 |
return 0; |
return 0; |
1059 |
} |
} |
1060 |
if (tsdPtr->restrictProc != NULL) { |
if (tsdPtr->restrictProc != NULL) { |
1061 |
result = (*tsdPtr->restrictProc)(tsdPtr->restrictArg, &wevPtr->event); |
result = (*tsdPtr->restrictProc)(tsdPtr->restrictArg, &wevPtr->event); |
1062 |
if (result != TK_PROCESS_EVENT) { |
if (result != TK_PROCESS_EVENT) { |
1063 |
if (result == TK_DEFER_EVENT) { |
if (result == TK_DEFER_EVENT) { |
1064 |
return 0; |
return 0; |
1065 |
} else { |
} else { |
1066 |
/* |
/* |
1067 |
* TK_DELETE_EVENT: return and say we processed the event, |
* TK_DELETE_EVENT: return and say we processed the event, |
1068 |
* even though we didn't do anything at all. |
* even though we didn't do anything at all. |
1069 |
*/ |
*/ |
1070 |
return 1; |
return 1; |
1071 |
} |
} |
1072 |
} |
} |
1073 |
} |
} |
1074 |
Tk_HandleEvent(&wevPtr->event); |
Tk_HandleEvent(&wevPtr->event); |
1075 |
return 1; |
return 1; |
1076 |
} |
} |
1077 |
|
|
1078 |
/* |
/* |
1079 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
1080 |
* |
* |
1081 |
* DelayedMotionProc -- |
* DelayedMotionProc -- |
1082 |
* |
* |
1083 |
* This procedure is invoked as an idle handler when a mouse motion |
* This procedure is invoked as an idle handler when a mouse motion |
1084 |
* event has been delayed. It queues the delayed event so that it |
* event has been delayed. It queues the delayed event so that it |
1085 |
* will finally be serviced. |
* will finally be serviced. |
1086 |
* |
* |
1087 |
* Results: |
* Results: |
1088 |
* None. |
* None. |
1089 |
* |
* |
1090 |
* Side effects: |
* Side effects: |
1091 |
* The delayed mouse motion event gets added to the Tcl event |
* The delayed mouse motion event gets added to the Tcl event |
1092 |
* queue for servicing. |
* queue for servicing. |
1093 |
* |
* |
1094 |
*---------------------------------------------------------------------- |
*---------------------------------------------------------------------- |
1095 |
*/ |
*/ |
1096 |
|
|
1097 |
static void |
static void |
1098 |
DelayedMotionProc(clientData) |
DelayedMotionProc(clientData) |
1099 |
ClientData clientData; /* Pointer to display containing a delayed |
ClientData clientData; /* Pointer to display containing a delayed |
1100 |
* motion event to be serviced. */ |
* motion event to be serviced. */ |
1101 |
{ |
{ |
1102 |
TkDisplay *dispPtr = (TkDisplay *) clientData; |
TkDisplay *dispPtr = (TkDisplay *) clientData; |
1103 |
|
|
1104 |
if (dispPtr->delayedMotionPtr == NULL) { |
if (dispPtr->delayedMotionPtr == NULL) { |
1105 |
panic("DelayedMotionProc found no delayed mouse motion event"); |
panic("DelayedMotionProc found no delayed mouse motion event"); |
1106 |
} |
} |
1107 |
Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, TCL_QUEUE_TAIL); |
Tcl_QueueEvent(&dispPtr->delayedMotionPtr->header, TCL_QUEUE_TAIL); |
1108 |
dispPtr->delayedMotionPtr = NULL; |
dispPtr->delayedMotionPtr = NULL; |
1109 |
} |
} |
1110 |
|
|
1111 |
/* |
/* |
1112 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
1113 |
* |
* |
1114 |
* Tk_MainLoop -- |
* Tk_MainLoop -- |
1115 |
* |
* |
1116 |
* Call Tcl_DoOneEvent over and over again in an infinite |
* Call Tcl_DoOneEvent over and over again in an infinite |
1117 |
* loop as long as there exist any main windows. |
* loop as long as there exist any main windows. |
1118 |
* |
* |
1119 |
* Results: |
* Results: |
1120 |
* None. |
* None. |
1121 |
* |
* |
1122 |
* Side effects: |
* Side effects: |
1123 |
* Arbitrary; depends on handlers for events. |
* Arbitrary; depends on handlers for events. |
1124 |
* |
* |
1125 |
*-------------------------------------------------------------- |
*-------------------------------------------------------------- |
1126 |
*/ |
*/ |
1127 |
|
|
1128 |
void |
void |
1129 |
Tk_MainLoop() |
Tk_MainLoop() |
1130 |
{ |
{ |
1131 |
while (Tk_GetNumMainWindows() > 0) { |
while (Tk_GetNumMainWindows() > 0) { |
1132 |
Tcl_DoOneEvent(0); |
Tcl_DoOneEvent(0); |
1133 |
} |
} |
1134 |
} |
} |
1135 |
|
|
1136 |
/* End of tkevent.c */ |
/* End of tkevent.c */ |