shared_source/c_tk_base_7_5_w_mods/tkwinpointer.c

/* $Header$ */

/* 
 * tkWinPointer.c --
 *
 *      Windows specific mouse tracking code.
 *
 * Copyright (c) 1995-1997 Sun Microsystems, Inc.
 * Copyright (c) 1998-1999 by Scriptics Corporation.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tkwinpointer.c,v 1.1.1.1 2001/06/13 05:14:12 dtashley Exp $
 */

#include "tkWinInt.h"

/*
 * Check for enter/leave events every MOUSE_TIMER_INTERVAL milliseconds.
 */

#define MOUSE_TIMER_INTERVAL 250

/*
 * Declarations of static variables used in this file.
 */

static int captured = 0;                /* 1 if mouse is currently captured. */
static TkWindow *keyboardWinPtr = NULL; /* Current keyboard grab window. */
static Tcl_TimerToken mouseTimer;       /* Handle to the latest mouse timer. */
static int mouseTimerSet = 0;           /* 1 if the mouse timer is active. */

/*
 * Forward declarations of procedures used in this file.
 */

static void             MouseTimerProc _ANSI_ARGS_((ClientData clientData));

/*
 *----------------------------------------------------------------------
 *
 * TkWinGetModifierState --
 *
 *      Return the modifier state as of the last message.
 *
 * Results:
 *      Returns the X modifier mask.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
TkWinGetModifierState()
{
    int state = 0;

    if (GetKeyState(VK_SHIFT) & 0x8000) {
        state |= ShiftMask;
    }
    if (GetKeyState(VK_CONTROL) & 0x8000) {
        state |= ControlMask;
    }
    if (GetKeyState(VK_MENU) & 0x8000) {
        state |= ALT_MASK;
    }
    if (GetKeyState(VK_CAPITAL) & 0x0001) {
        state |= LockMask;
    }
    if (GetKeyState(VK_NUMLOCK) & 0x0001) {
        state |= Mod1Mask;
    }
    if (GetKeyState(VK_SCROLL) & 0x0001) {
        state |= Mod3Mask;
    }
    if (GetKeyState(VK_LBUTTON) & 0x8000) {
        state |= Button1Mask;
    }
    if (GetKeyState(VK_MBUTTON) & 0x8000) {
        state |= Button2Mask;
    }
    if (GetKeyState(VK_RBUTTON) & 0x8000) {
        state |= Button3Mask;
    }
    return state;
}

/*
 *----------------------------------------------------------------------
 *
 * Tk_PointerEvent --
 *
 *      This procedure is called for each pointer-related event.
 *      It converts the position to root coords and updates the
 *      global pointer state machine.  It also ensures that the
 *      mouse timer is scheduled.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      May queue events and change the grab state.
 *
 *----------------------------------------------------------------------
 */

void
Tk_PointerEvent(hwnd, x, y)
    HWND hwnd;                          /* Window for coords, or NULL for
                                         * the root window. */
    int x, y;                           /* Coords relative to hwnd, or screen
                                         * if hwnd is NULL. */
{
    POINT pos;
    int state;
    Tk_Window tkwin;

    pos.x = x;
    pos.y = y;

    /*
     * Convert client coords to root coords if we were given a window.
     */

    if (hwnd) {
        ClientToScreen(hwnd, &pos);
    }

    /*
     * If the mouse is captured, Windows will report all pointer
     * events to the capture window.  So, we need to determine which
     * window the mouse is really over and change the event.  Note
     * that the computed hwnd may point to a window not owned by Tk,
     * or a toplevel decorative frame, so tkwin can be NULL.
     */

    if (captured || hwnd == NULL) {
        hwnd = WindowFromPoint(pos);
    }
    tkwin = Tk_HWNDToWindow(hwnd);

    state = TkWinGetModifierState();

    Tk_UpdatePointer(tkwin, pos.x, pos.y, state);

    if ((captured || tkwin) && !mouseTimerSet) {
        mouseTimerSet = 1;
        mouseTimer = Tcl_CreateTimerHandler(MOUSE_TIMER_INTERVAL,
                MouseTimerProc, NULL);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XGrabKeyboard --
 *
 *      Simulates a keyboard grab by setting the focus.
 *
 * Results:
 *      Always returns GrabSuccess.
 *
 * Side effects:
 *      Sets the keyboard focus to the specified window.
 *
 *----------------------------------------------------------------------
 */

int
XGrabKeyboard(display, grab_window, owner_events, pointer_mode,
        keyboard_mode, time)
    Display* display;
    Window grab_window;
    Bool owner_events;
    int pointer_mode;
    int keyboard_mode;
    Time time;
{
    keyboardWinPtr = TkWinGetWinPtr(grab_window);
    return GrabSuccess;
}

/*
 *----------------------------------------------------------------------
 *
 * XUngrabKeyboard --
 *
 *      Releases the simulated keyboard grab.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Sets the keyboard focus back to the value before the grab.
 *
 *----------------------------------------------------------------------
 */

void
XUngrabKeyboard(display, time)
    Display* display;
    Time time;
{
    keyboardWinPtr = NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * MouseTimerProc --
 *
 *      Check the current mouse position and look for enter/leave 
 *      events.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      May schedule a new timer and/or generate enter/leave events.
 *
 *----------------------------------------------------------------------
 */

void
MouseTimerProc(clientData)
    ClientData clientData;
{
    POINT pos;

    mouseTimerSet = 0;

    /*
     * Get the current mouse position and window.  Don't do anything
     * if the mouse hasn't moved since the last time we looked.
     */

    GetCursorPos(&pos);
    Tk_PointerEvent(NULL, pos.x, pos.y);
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinCancelMouseTimer --
 *
 *    If the mouse timer is set, cancel it.
 *
 * Results:
 *    None.
 *
 * Side effects:
 *    May cancel the mouse timer.
 *
 *----------------------------------------------------------------------
 */

void
TkWinCancelMouseTimer()
{
    if (mouseTimerSet) {
        Tcl_DeleteTimerHandler(mouseTimer);
        mouseTimerSet = 0;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkGetPointerCoords --
 *
 *      Fetch the position of the mouse pointer.
 *
 * Results:
 *      *xPtr and *yPtr are filled in with the root coordinates
 *      of the mouse pointer for the display.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
TkGetPointerCoords(tkwin, xPtr, yPtr)
    Tk_Window tkwin;            /* Window that identifies screen on which
                                 * lookup is to be done. */
    int *xPtr, *yPtr;           /* Store pointer coordinates here. */
{
    POINT point;

    GetCursorPos(&point);
    *xPtr = point.x;
    *yPtr = point.y;
}

/*
 *----------------------------------------------------------------------
 *
 * XQueryPointer --
 *
 *      Check the current state of the mouse.  This is not a complete
 *      implementation of this function.  It only computes the root
 *      coordinates and the current mask.
 *
 * Results:
 *      Sets root_x_return, root_y_return, and mask_return.  Returns
 *      true on success.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

Bool
XQueryPointer(display, w, root_return, child_return, root_x_return,
        root_y_return, win_x_return, win_y_return, mask_return)
    Display* display;
    Window w;
    Window* root_return;
    Window* child_return;
    int* root_x_return;
    int* root_y_return;
    int* win_x_return;
    int* win_y_return;
    unsigned int* mask_return;
{
    display->request++;
    TkGetPointerCoords(NULL, root_x_return, root_y_return);
    *mask_return = TkWinGetModifierState();
    return True;
}

/*
 *----------------------------------------------------------------------
 *
 * XWarpPointer --
 *
 *      Move pointer to new location.  This is not a complete
 *      implementation of this function.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Mouse pointer changes position on screen.
 *
 *----------------------------------------------------------------------
 */

void
XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width,
        src_height, dest_x, dest_y)
    Display* display;
    Window src_w;
    Window dest_w;
    int src_x;
    int src_y;
    unsigned int src_width;
    unsigned int src_height;
    int dest_x;
    int dest_y;
{
    RECT r;

    GetWindowRect(Tk_GetHWND(dest_w), &r);
    SetCursorPos(r.left+dest_x, r.top+dest_y);    
}

/*
 *----------------------------------------------------------------------
 *
 * XGetInputFocus --
 *
 *      Retrieves the current keyboard focus window.
 *
 * Results:
 *      Returns the current focus window.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
XGetInputFocus(display, focus_return, revert_to_return)
    Display *display;
    Window *focus_return;
    int *revert_to_return;
{
    Tk_Window tkwin = Tk_HWNDToWindow(GetFocus());
    *focus_return = tkwin ? Tk_WindowId(tkwin) : None;
    *revert_to_return = RevertToParent;
    display->request++;
}

/*
 *----------------------------------------------------------------------
 *
 * XSetInputFocus --
 *
 *      Set the current focus window.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Changes the keyboard focus and causes the selected window to
 *      be activated.
 *
 *----------------------------------------------------------------------
 */

void
XSetInputFocus(display, focus, revert_to, time)
    Display* display;
    Window focus;
    int revert_to;
    Time time;
{
    display->request++;
    if (focus != None) {
        SetFocus(Tk_GetHWND(focus));
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkpChangeFocus --
 *
 *      This procedure is invoked to move the system focus from
 *      one window to another.
 *
 * Results:
 *      The return value is the serial number of the command that
 *      changed the focus.  It may be needed by the caller to filter
 *      out focus change events that were queued before the command.
 *      If the procedure doesn't actually change the focus then
 *      it returns 0.
 *
 * Side effects:
 *      The official Windows focus window changes;  the application's focus
 *      window isn't changed by this procedure.
 *
 *----------------------------------------------------------------------
 */

int
TkpChangeFocus(winPtr, force)
    TkWindow *winPtr;           /* Window that is to receive the X focus. */
    int force;                  /* Non-zero means claim the focus even
                                 * if it didn't originally belong to
                                 * topLevelPtr's application. */
{
    TkDisplay *dispPtr = winPtr->dispPtr;
    Window focusWindow;
    int dummy, serial;
    TkWindow *winPtr2;

    if (!force) {
        XGetInputFocus(dispPtr->display, &focusWindow, &dummy);
        winPtr2 = (TkWindow *) Tk_IdToWindow(dispPtr->display, focusWindow);
        if ((winPtr2 == NULL) || (winPtr2->mainPtr != winPtr->mainPtr)) {
            return 0;
        }
    }

    if (winPtr->window == None) {
        panic("ChangeXFocus got null X window");
    }
 
    /*
     * Change the foreground window so the focus window is raised to the top of
     * the system stacking order and gets the keyboard focus.
     */

    if (force) {
        TkWinSetForegroundWindow(winPtr);
    }
    XSetInputFocus(dispPtr->display, winPtr->window, RevertToParent,
            CurrentTime);

    /*
     * Remember the current serial number for the X server and issue
     * a dummy server request.  This marks the position at which we
     * changed the focus, so we can distinguish FocusIn and FocusOut
     * events on either side of the mark.
     */

    serial = NextRequest(winPtr->display);
    XNoOp(winPtr->display);
    return serial;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpSetCapture --
 *
 *      This function captures the mouse so that all future events
 *      will be reported to this window, even if the mouse is outside
 *      the window.  If the specified window is NULL, then the mouse
 *      is released. 
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Sets the capture flag and captures the mouse.
 *
 *----------------------------------------------------------------------
 */

void
TkpSetCapture(winPtr)
    TkWindow *winPtr;                   /* Capture window, or NULL. */
{
    if (winPtr) {
        SetCapture(Tk_GetHWND(Tk_WindowId(winPtr)));
        captured = 1;
    } else {
        captured = 0;
        ReleaseCapture();
    }
}

/* End of tkwinpointer.c */
1	/* $Header$ */
2
3	/*
4	* tkWinPointer.c --
5	*
6	* Windows specific mouse tracking code.
7	*
8	* Copyright (c) 1995-1997 Sun Microsystems, Inc.
9	* Copyright (c) 1998-1999 by Scriptics Corporation.
10	*
11	* See the file "license.terms" for information on usage and redistribution
12	* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13	*
14	* RCS: @(#) $Id: tkwinpointer.c,v 1.1.1.1 2001/06/13 05:14:12 dtashley Exp $
15	*/
16
17	#include "tkWinInt.h"
18
19	/*
20	* Check for enter/leave events every MOUSE_TIMER_INTERVAL milliseconds.
21	*/
22
23	#define MOUSE_TIMER_INTERVAL 250
24
25	/*
26	* Declarations of static variables used in this file.
27	*/
28
29	static int captured = 0; /* 1 if mouse is currently captured. */
30	static TkWindow keyboardWinPtr = NULL; / Current keyboard grab window. */
31	static Tcl_TimerToken mouseTimer; /* Handle to the latest mouse timer. */
32	static int mouseTimerSet = 0; /* 1 if the mouse timer is active. */
33
34	/*
35	* Forward declarations of procedures used in this file.
36	*/
37
38	static void MouseTimerProc _ANSI_ARGS_((ClientData clientData));
39
40	/*
41	*----------------------------------------------------------------------
42	*
43	* TkWinGetModifierState --
44	*
45	* Return the modifier state as of the last message.
46	*
47	* Results:
48	* Returns the X modifier mask.
49	*
50	* Side effects:
51	* None.
52	*
53	*----------------------------------------------------------------------
54	*/
55
56	int
57	TkWinGetModifierState()
58	{
59	int state = 0;
60
61	if (GetKeyState(VK_SHIFT) & 0x8000) {
62	state \|= ShiftMask;
63	}
64	if (GetKeyState(VK_CONTROL) & 0x8000) {
65	state \|= ControlMask;
66	}
67	if (GetKeyState(VK_MENU) & 0x8000) {
68	state \|= ALT_MASK;
69	}
70	if (GetKeyState(VK_CAPITAL) & 0x0001) {
71	state \|= LockMask;
72	}
73	if (GetKeyState(VK_NUMLOCK) & 0x0001) {
74	state \|= Mod1Mask;
75	}
76	if (GetKeyState(VK_SCROLL) & 0x0001) {
77	state \|= Mod3Mask;
78	}
79	if (GetKeyState(VK_LBUTTON) & 0x8000) {
80	state \|= Button1Mask;
81	}
82	if (GetKeyState(VK_MBUTTON) & 0x8000) {
83	state \|= Button2Mask;
84	}
85	if (GetKeyState(VK_RBUTTON) & 0x8000) {
86	state \|= Button3Mask;
87	}
88	return state;
89	}
90
91	/*
92	*----------------------------------------------------------------------
93	*
94	* Tk_PointerEvent --
95	*
96	* This procedure is called for each pointer-related event.
97	* It converts the position to root coords and updates the
98	* global pointer state machine. It also ensures that the
99	* mouse timer is scheduled.
100	*
101	* Results:
102	* None.
103	*
104	* Side effects:
105	* May queue events and change the grab state.
106	*
107	*----------------------------------------------------------------------
108	*/
109
110	void
111	Tk_PointerEvent(hwnd, x, y)
112	HWND hwnd; /* Window for coords, or NULL for
113	* the root window. */
114	int x, y; /* Coords relative to hwnd, or screen
115	* if hwnd is NULL. */
116	{
117	POINT pos;
118	int state;
119	Tk_Window tkwin;
120
121	pos.x = x;
122	pos.y = y;
123
124	/*
125	* Convert client coords to root coords if we were given a window.
126	*/
127
128	if (hwnd) {
129	ClientToScreen(hwnd, &pos);
130	}
131
132	/*
133	* If the mouse is captured, Windows will report all pointer
134	* events to the capture window. So, we need to determine which
135	* window the mouse is really over and change the event. Note
136	* that the computed hwnd may point to a window not owned by Tk,
137	* or a toplevel decorative frame, so tkwin can be NULL.
138	*/
139
140	if (captured \|\| hwnd == NULL) {
141	hwnd = WindowFromPoint(pos);
142	}
143	tkwin = Tk_HWNDToWindow(hwnd);
144
145	state = TkWinGetModifierState();
146
147	Tk_UpdatePointer(tkwin, pos.x, pos.y, state);
148
149	if ((captured \|\| tkwin) && !mouseTimerSet) {
150	mouseTimerSet = 1;
151	mouseTimer = Tcl_CreateTimerHandler(MOUSE_TIMER_INTERVAL,
152	MouseTimerProc, NULL);
153	}
154	}
155
156	/*
157	*----------------------------------------------------------------------
158	*
159	* XGrabKeyboard --
160	*
161	* Simulates a keyboard grab by setting the focus.
162	*
163	* Results:
164	* Always returns GrabSuccess.
165	*
166	* Side effects:
167	* Sets the keyboard focus to the specified window.
168	*
169	*----------------------------------------------------------------------
170	*/
171
172	int
173	XGrabKeyboard(display, grab_window, owner_events, pointer_mode,
174	keyboard_mode, time)
175	Display* display;
176	Window grab_window;
177	Bool owner_events;
178	int pointer_mode;
179	int keyboard_mode;
180	Time time;
181	{
182	keyboardWinPtr = TkWinGetWinPtr(grab_window);
183	return GrabSuccess;
184	}
185
186	/*
187	*----------------------------------------------------------------------
188	*
189	* XUngrabKeyboard --
190	*
191	* Releases the simulated keyboard grab.
192	*
193	* Results:
194	* None.
195	*
196	* Side effects:
197	* Sets the keyboard focus back to the value before the grab.
198	*
199	*----------------------------------------------------------------------
200	*/
201
202	void
203	XUngrabKeyboard(display, time)
204	Display* display;
205	Time time;
206	{
207	keyboardWinPtr = NULL;
208	}
209
210	/*
211	*----------------------------------------------------------------------
212	*
213	* MouseTimerProc --
214	*
215	* Check the current mouse position and look for enter/leave
216	* events.
217	*
218	* Results:
219	* None.
220	*
221	* Side effects:
222	* May schedule a new timer and/or generate enter/leave events.
223	*
224	*----------------------------------------------------------------------
225	*/
226
227	void
228	MouseTimerProc(clientData)
229	ClientData clientData;
230	{
231	POINT pos;
232
233	mouseTimerSet = 0;
234
235	/*
236	* Get the current mouse position and window. Don't do anything
237	* if the mouse hasn't moved since the last time we looked.
238	*/
239
240	GetCursorPos(&pos);
241	Tk_PointerEvent(NULL, pos.x, pos.y);
242	}
243
244	/*
245	*----------------------------------------------------------------------
246	*
247	* TkWinCancelMouseTimer --
248	*
249	* If the mouse timer is set, cancel it.
250	*
251	* Results:
252	* None.
253	*
254	* Side effects:
255	* May cancel the mouse timer.
256	*
257	*----------------------------------------------------------------------
258	*/
259
260	void
261	TkWinCancelMouseTimer()
262	{
263	if (mouseTimerSet) {
264	Tcl_DeleteTimerHandler(mouseTimer);
265	mouseTimerSet = 0;
266	}
267	}
268
269	/*
270	*----------------------------------------------------------------------
271	*
272	* TkGetPointerCoords --
273	*
274	* Fetch the position of the mouse pointer.
275	*
276	* Results:
277	* xPtr and yPtr are filled in with the root coordinates
278	* of the mouse pointer for the display.
279	*
280	* Side effects:
281	* None.
282	*
283	*----------------------------------------------------------------------
284	*/
285
286	void
287	TkGetPointerCoords(tkwin, xPtr, yPtr)
288	Tk_Window tkwin; /* Window that identifies screen on which
289	* lookup is to be done. */
290	int xPtr, yPtr; /* Store pointer coordinates here. */
291	{
292	POINT point;
293
294	GetCursorPos(&point);
295	*xPtr = point.x;
296	*yPtr = point.y;
297	}
298
299	/*
300	*----------------------------------------------------------------------
301	*
302	* XQueryPointer --
303	*
304	* Check the current state of the mouse. This is not a complete
305	* implementation of this function. It only computes the root
306	* coordinates and the current mask.
307	*
308	* Results:
309	* Sets root_x_return, root_y_return, and mask_return. Returns
310	* true on success.
311	*
312	* Side effects:
313	* None.
314	*
315	*----------------------------------------------------------------------
316	*/
317
318	Bool
319	XQueryPointer(display, w, root_return, child_return, root_x_return,
320	root_y_return, win_x_return, win_y_return, mask_return)
321	Display* display;
322	Window w;
323	Window* root_return;
324	Window* child_return;
325	int* root_x_return;
326	int* root_y_return;
327	int* win_x_return;
328	int* win_y_return;
329	unsigned int* mask_return;
330	{
331	display->request++;
332	TkGetPointerCoords(NULL, root_x_return, root_y_return);
333	*mask_return = TkWinGetModifierState();
334	return True;
335	}
336
337	/*
338	*----------------------------------------------------------------------
339	*
340	* XWarpPointer --
341	*
342	* Move pointer to new location. This is not a complete
343	* implementation of this function.
344	*
345	* Results:
346	* None.
347	*
348	* Side effects:
349	* Mouse pointer changes position on screen.
350	*
351	*----------------------------------------------------------------------
352	*/
353
354	void
355	XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width,
356	src_height, dest_x, dest_y)
357	Display* display;
358	Window src_w;
359	Window dest_w;
360	int src_x;
361	int src_y;
362	unsigned int src_width;
363	unsigned int src_height;
364	int dest_x;
365	int dest_y;
366	{
367	RECT r;
368
369	GetWindowRect(Tk_GetHWND(dest_w), &r);
370	SetCursorPos(r.left+dest_x, r.top+dest_y);
371	}
372
373	/*
374	*----------------------------------------------------------------------
375	*
376	* XGetInputFocus --
377	*
378	* Retrieves the current keyboard focus window.
379	*
380	* Results:
381	* Returns the current focus window.
382	*
383	* Side effects:
384	* None.
385	*
386	*----------------------------------------------------------------------
387	*/
388
389	void
390	XGetInputFocus(display, focus_return, revert_to_return)
391	Display *display;
392	Window *focus_return;
393	int *revert_to_return;
394	{
395	Tk_Window tkwin = Tk_HWNDToWindow(GetFocus());
396	*focus_return = tkwin ? Tk_WindowId(tkwin) : None;
397	*revert_to_return = RevertToParent;
398	display->request++;
399	}
400
401	/*
402	*----------------------------------------------------------------------
403	*
404	* XSetInputFocus --
405	*
406	* Set the current focus window.
407	*
408	* Results:
409	* None.
410	*
411	* Side effects:
412	* Changes the keyboard focus and causes the selected window to
413	* be activated.
414	*
415	*----------------------------------------------------------------------
416	*/
417
418	void
419	XSetInputFocus(display, focus, revert_to, time)
420	Display* display;
421	Window focus;
422	int revert_to;
423	Time time;
424	{
425	display->request++;
426	if (focus != None) {
427	SetFocus(Tk_GetHWND(focus));
428	}
429	}
430
431	/*
432	*----------------------------------------------------------------------
433	*
434	* TkpChangeFocus --
435	*
436	* This procedure is invoked to move the system focus from
437	* one window to another.
438	*
439	* Results:
440	* The return value is the serial number of the command that
441	* changed the focus. It may be needed by the caller to filter
442	* out focus change events that were queued before the command.
443	* If the procedure doesn't actually change the focus then
444	* it returns 0.
445	*
446	* Side effects:
447	* The official Windows focus window changes; the application's focus
448	* window isn't changed by this procedure.
449	*
450	*----------------------------------------------------------------------
451	*/
452
453	int
454	TkpChangeFocus(winPtr, force)
455	TkWindow winPtr; / Window that is to receive the X focus. */
456	int force; /* Non-zero means claim the focus even
457	* if it didn't originally belong to
458	* topLevelPtr's application. */
459	{
460	TkDisplay *dispPtr = winPtr->dispPtr;
461	Window focusWindow;
462	int dummy, serial;
463	TkWindow *winPtr2;
464
465	if (!force) {
466	XGetInputFocus(dispPtr->display, &focusWindow, &dummy);
467	winPtr2 = (TkWindow *) Tk_IdToWindow(dispPtr->display, focusWindow);
468	if ((winPtr2 == NULL) \|\| (winPtr2->mainPtr != winPtr->mainPtr)) {
469	return 0;
470	}
471	}
472
473	if (winPtr->window == None) {
474	panic("ChangeXFocus got null X window");
475	}
476
477	/*
478	* Change the foreground window so the focus window is raised to the top of
479	* the system stacking order and gets the keyboard focus.
480	*/
481
482	if (force) {
483	TkWinSetForegroundWindow(winPtr);
484	}
485	XSetInputFocus(dispPtr->display, winPtr->window, RevertToParent,
486	CurrentTime);
487
488	/*
489	* Remember the current serial number for the X server and issue
490	* a dummy server request. This marks the position at which we
491	* changed the focus, so we can distinguish FocusIn and FocusOut
492	* events on either side of the mark.
493	*/
494
495	serial = NextRequest(winPtr->display);
496	XNoOp(winPtr->display);
497	return serial;
498	}
499
500	/*
501	*----------------------------------------------------------------------
502	*
503	* TkpSetCapture --
504	*
505	* This function captures the mouse so that all future events
506	* will be reported to this window, even if the mouse is outside
507	* the window. If the specified window is NULL, then the mouse
508	* is released.
509	*
510	* Results:
511	* None.
512	*
513	* Side effects:
514	* Sets the capture flag and captures the mouse.
515	*
516	*----------------------------------------------------------------------
517	*/
518
519	void
520	TkpSetCapture(winPtr)
521	TkWindow winPtr; / Capture window, or NULL. */
522	{
523	if (winPtr) {
524	SetCapture(Tk_GetHWND(Tk_WindowId(winPtr)));
525	captured = 1;
526	} else {
527	captured = 0;
528	ReleaseCapture();
529	}
530	}
531
532	/* End of tkwinpointer.c */