shared_source/c_tcl_base_7_5_w_mods/tclwinnotify.c

/* $Header$ */
/* 
 * tclWinNotify.c --
 *
 *      This file contains Windows-specific procedures for the notifier,
 *      which is the lowest-level part of the Tcl event loop.  This file
 *      works together with ../generic/tclNotify.c.
 *
 * Copyright (c) 1995-1997 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclwinnotify.c,v 1.1.1.1 2001/06/13 04:49:27 dtashley Exp $
 */

#include "tclWinInt.h"
#include <winsock.h>

/*
 * The follwing static indicates whether this module has been initialized.
 */

static int initialized = 0;

#define INTERVAL_TIMER 1        /* Handle of interval timer. */

#define WM_WAKEUP WM_USER       /* Message that is send by
                                 * Tcl_AlertNotifier. */
/*
 * The following static structure contains the state information for the
 * Windows implementation of the Tcl notifier.  One of these structures
 * is created for each thread that is using the notifier.  
 */

typedef struct ThreadSpecificData {
    CRITICAL_SECTION crit;      /* Monitor for this notifier. */
    DWORD thread;               /* Identifier for thread associated with this
                                 * notifier. */
    HANDLE event;               /* Event object used to wake up the notifier
                                 * thread. */
    int pending;                /* Alert message pending, this field is
                                 * locked by the notifierMutex. */
    HWND hwnd;                  /* Messaging window. */
    int timeout;                /* Current timeout value. */
    int timerActive;            /* 1 if interval timer is running. */
} ThreadSpecificData;

static Tcl_ThreadDataKey dataKey;

extern TclStubs tclStubs;
/*
 * The following static indicates the number of threads that have
 * initialized notifiers.  It controls the lifetime of the TclNotifier
 * window class.
 *
 * You must hold the notifierMutex lock before accessing this variable.
 */

static int notifierCount = 0;
TCL_DECLARE_MUTEX(notifierMutex)

/*
 * Static routines defined in this file.
 */

static LRESULT CALLBACK NotifierProc(HWND hwnd, UINT message,
                            WPARAM wParam, LPARAM lParam);


/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitNotifier --
 *
 *      Initializes the platform specific notifier state.
 *
 * Results:
 *      Returns a handle to the notifier state for this thread..
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

ClientData
Tcl_InitNotifier()
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    WNDCLASS class;

    /*
     * Register Notifier window class if this is the first thread to
     * use this module.
     */

    Tcl_MutexLock(&notifierMutex);
    if (notifierCount == 0) {
        class.style = 0;
        class.cbClsExtra = 0;
        class.cbWndExtra = 0;
        class.hInstance = TclWinGetTclInstance();
        class.hbrBackground = NULL;
        class.lpszMenuName = NULL;
        class.lpszClassName = "TclNotifier";
        class.lpfnWndProc = NotifierProc;
        class.hIcon = NULL;
        class.hCursor = NULL;

        if (!RegisterClassA(&class)) {
            panic("Unable to register TclNotifier window class");
        }
    }
    notifierCount++;
    Tcl_MutexUnlock(&notifierMutex);

    tsdPtr->pending = 0;
    tsdPtr->timerActive = 0;

    InitializeCriticalSection(&tsdPtr->crit);

    tsdPtr->hwnd = NULL;
    tsdPtr->thread = GetCurrentThreadId();
    tsdPtr->event = CreateEvent(NULL, TRUE /* manual */,
            FALSE /* !signaled */, NULL);

    return (ClientData) tsdPtr;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FinalizeNotifier --
 *
 *      This function is called to cleanup the notifier state before
 *      a thread is terminated.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      May dispose of the notifier window and class.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_FinalizeNotifier(clientData)
    ClientData clientData;      /* Pointer to notifier data. */
{
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData;

    DeleteCriticalSection(&tsdPtr->crit);
    CloseHandle(tsdPtr->event);

    /*
     * Clean up the timer and messaging window for this thread.
     */

    if (tsdPtr->hwnd) {
        KillTimer(tsdPtr->hwnd, INTERVAL_TIMER);
        DestroyWindow(tsdPtr->hwnd);
    }

    /*
     * If this is the last thread to use the notifier, unregister
     * the notifier window class.
     */

    Tcl_MutexLock(&notifierMutex);
    notifierCount--;
    if (notifierCount == 0) {
        UnregisterClassA("TclNotifier", TclWinGetTclInstance());
    }
    Tcl_MutexUnlock(&notifierMutex);
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AlertNotifier --
 *
 *      Wake up the specified notifier from any thread. This routine
 *      is called by the platform independent notifier code whenever
 *      the Tcl_ThreadAlert routine is called.  This routine is
 *      guaranteed not to be called on a given notifier after
 *      Tcl_FinalizeNotifier is called for that notifier.  This routine
 *      is typically called from a thread other than the notifier's
 *      thread.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Sends a message to the messaging window for the notifier
 *      if there isn't already one pending.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_AlertNotifier(clientData)
    ClientData clientData;      /* Pointer to thread data. */
{
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData;

    /*
     * Note that we do not need to lock around access to the hwnd
     * because the race condition has no effect since any race condition
     * implies that the notifier thread is already awake.
     */

    if (tsdPtr->hwnd) {
        /*
         * We do need to lock around access to the pending flag.
         */

        EnterCriticalSection(&tsdPtr->crit);
        if (!tsdPtr->pending) {
            PostMessage(tsdPtr->hwnd, WM_WAKEUP, 0, 0);
        }
        tsdPtr->pending = 1;
        LeaveCriticalSection(&tsdPtr->crit);
    } else {
        SetEvent(tsdPtr->event);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetTimer --
 *
 *      This procedure sets the current notifier timer value.  The
 *      notifier will ensure that Tcl_ServiceAll() is called after
 *      the specified interval, even if no events have occurred.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Replaces any previous timer.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_SetTimer(
    Tcl_Time *timePtr)          /* Maximum block time, or NULL. */
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    UINT timeout;

    /*
     * Allow the notifier to be hooked.  This may not make sense
     * on Windows, but mirrors the UNIX hook.
     */

    if (tclStubs.tcl_SetTimer != Tcl_SetTimer) {
        tclStubs.tcl_SetTimer(timePtr);
        return;
    }

    /*
     * We only need to set up an interval timer if we're being called
     * from an external event loop.  If we don't have a window handle
     * then we just return immediately and let Tcl_WaitForEvent handle
     * timeouts.
     */

    if (!tsdPtr->hwnd) {
        return;
    }

    if (!timePtr) {
        timeout = 0;
    } else {
        /*
         * Make sure we pass a non-zero value into the timeout argument.
         * Windows seems to get confused by zero length timers.
         */

        timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
        if (timeout == 0) {
            timeout = 1;
        }
    }
    tsdPtr->timeout = timeout;
    if (timeout != 0) {
        tsdPtr->timerActive = 1;
        SetTimer(tsdPtr->hwnd, INTERVAL_TIMER,
                    (unsigned long) tsdPtr->timeout, NULL);
    } else {
        tsdPtr->timerActive = 0;
        KillTimer(tsdPtr->hwnd, INTERVAL_TIMER);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceModeHook --
 *
 *      This function is invoked whenever the service mode changes.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      If this is the first time the notifier is set into
 *      TCL_SERVICE_ALL, then the communication window is created.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_ServiceModeHook(mode)
    int mode;                   /* Either TCL_SERVICE_ALL, or
                                 * TCL_SERVICE_NONE. */
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    /*
     * If this is the first time that the notifier has been used from a
     * modal loop, then create a communication window.  Note that after
     * this point, the application needs to service events in a timely
     * fashion or Windows will hang waiting for the window to respond
     * to synchronous system messages.  At some point, we may want to
     * consider destroying the window if we leave the modal loop, but
     * for now we'll leave it around.
     */

    if (mode == TCL_SERVICE_ALL && !tsdPtr->hwnd) {
        tsdPtr->hwnd = CreateWindowA("TclNotifier", "TclNotifier", WS_TILED,
                0, 0, 0, 0, NULL, NULL, TclWinGetTclInstance(), NULL);
        /*
         * Send an initial message to the window to ensure that we wake up the
         * notifier once we get into the modal loop.  This will force the
         * notifier to recompute the timeout value and schedule a timer
         * if one is needed.
         */

        Tcl_AlertNotifier((ClientData)tsdPtr);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * NotifierProc --
 *
 *      This procedure is invoked by Windows to process events on
 *      the notifier window.  Messages will be sent to this window
 *      in response to external timer events or calls to
 *      TclpAlertTsdPtr->
 *
 * Results:
 *      A standard windows result.
 *
 * Side effects:
 *      Services any pending events.
 *
 *----------------------------------------------------------------------
 */

static LRESULT CALLBACK
NotifierProc(
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    if (message == WM_WAKEUP) {
        EnterCriticalSection(&tsdPtr->crit);
        tsdPtr->pending = 0;
        LeaveCriticalSection(&tsdPtr->crit);
    } else if (message != WM_TIMER) {
        return DefWindowProc(hwnd, message, wParam, lParam);
    }
        
    /*
     * Process all of the runnable events.
     */

    Tcl_ServiceAll();
    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WaitForEvent --
 *
 *      This function is called by Tcl_DoOneEvent to wait for new
 *      events on the message queue.  If the block time is 0, then
 *      Tcl_WaitForEvent just polls the event queue without blocking.
 *
 * Results:
 *      Returns -1 if a WM_QUIT message is detected, returns 1 if
 *      a message was dispatched, otherwise returns 0.
 *
 * Side effects:
 *      Dispatches a message to a window procedure, which could do
 *      anything.
 *
 *----------------------------------------------------------------------
 */

int
Tcl_WaitForEvent(
    Tcl_Time *timePtr)          /* Maximum block time, or NULL. */
{
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    MSG msg;
    DWORD timeout, result;
    int status;

    /*
     * Allow the notifier to be hooked.  This may not make
     * sense on windows, but mirrors the UNIX hook.
     */

    if (tclStubs.tcl_WaitForEvent != Tcl_WaitForEvent) {
        return tclStubs.tcl_WaitForEvent(timePtr);
    }

    /*
     * Compute the timeout in milliseconds.
     */

    if (timePtr) {
        timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
    } else {
        timeout = INFINITE;
    }

    /*
     * Check to see if there are any messages in the queue before waiting
     * because MsgWaitForMultipleObjects will not wake up if there are events
     * currently sitting in the queue.
     */

    if (!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
        /*
         * Wait for something to happen (a signal from another thread, a
         * message, or timeout).
         */

        result = MsgWaitForMultipleObjects(1, &tsdPtr->event, FALSE, timeout,
                QS_ALLINPUT);
    }

    /*
     * Check to see if there are any messages to process.
     */

    if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
        /*
         * Retrieve and dispatch the first message.
         */

        result = GetMessage(&msg, NULL, 0, 0);
        if (result == 0) {
            /*
             * We received a request to exit this thread (WM_QUIT), so
             * propagate the quit message and start unwinding.
             */

            PostQuitMessage(msg.wParam);
            status = -1;
        } else if (result == -1) {
            /*
             * We got an error from the system.  I have no idea why this would
             * happen, so we'll just unwind.
             */

            status = -1;
        } else {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
            status = 1;
        }
    } else {
        status = 0;
    }

    ResetEvent(tsdPtr->event);
    return status;
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Sleep --
 *
 *      Delay execution for the specified number of milliseconds.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Time passes.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_Sleep(ms)
    int ms;                     /* Number of milliseconds to sleep. */
{
    Sleep(ms);
}

/* End of tclwinnotify.c */
1	/* $Header$ */
2	/*
3	* tclWinNotify.c --
4	*
5	* This file contains Windows-specific procedures for the notifier,
6	* which is the lowest-level part of the Tcl event loop. This file
7	* works together with ../generic/tclNotify.c.
8	*
9	* Copyright (c) 1995-1997 Sun Microsystems, Inc.
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: tclwinnotify.c,v 1.1.1.1 2001/06/13 04:49:27 dtashley Exp $
15	*/
16
17	#include "tclWinInt.h"
18	#include <winsock.h>
19
20	/*
21	* The follwing static indicates whether this module has been initialized.
22	*/
23
24	static int initialized = 0;
25
26	#define INTERVAL_TIMER 1 /* Handle of interval timer. */
27
28	#define WM_WAKEUP WM_USER /* Message that is send by
29	* Tcl_AlertNotifier. */
30	/*
31	* The following static structure contains the state information for the
32	* Windows implementation of the Tcl notifier. One of these structures
33	* is created for each thread that is using the notifier.
34	*/
35
36	typedef struct ThreadSpecificData {
37	CRITICAL_SECTION crit; /* Monitor for this notifier. */
38	DWORD thread; /* Identifier for thread associated with this
39	* notifier. */
40	HANDLE event; /* Event object used to wake up the notifier
41	* thread. */
42	int pending; /* Alert message pending, this field is
43	* locked by the notifierMutex. */
44	HWND hwnd; /* Messaging window. */
45	int timeout; /* Current timeout value. */
46	int timerActive; /* 1 if interval timer is running. */
47	} ThreadSpecificData;
48
49	static Tcl_ThreadDataKey dataKey;
50
51	extern TclStubs tclStubs;
52	/*
53	* The following static indicates the number of threads that have
54	* initialized notifiers. It controls the lifetime of the TclNotifier
55	* window class.
56	*
57	* You must hold the notifierMutex lock before accessing this variable.
58	*/
59
60	static int notifierCount = 0;
61	TCL_DECLARE_MUTEX(notifierMutex)
62
63	/*
64	* Static routines defined in this file.
65	*/
66
67	static LRESULT CALLBACK NotifierProc(HWND hwnd, UINT message,
68	WPARAM wParam, LPARAM lParam);
69
70
71	/*
72	*----------------------------------------------------------------------
73	*
74	* Tcl_InitNotifier --
75	*
76	* Initializes the platform specific notifier state.
77	*
78	* Results:
79	* Returns a handle to the notifier state for this thread..
80	*
81	* Side effects:
82	* None.
83	*
84	*----------------------------------------------------------------------
85	*/
86
87	ClientData
88	Tcl_InitNotifier()
89	{
90	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
91	WNDCLASS class;
92
93	/*
94	* Register Notifier window class if this is the first thread to
95	* use this module.
96	*/
97
98	Tcl_MutexLock(&notifierMutex);
99	if (notifierCount == 0) {
100	class.style = 0;
101	class.cbClsExtra = 0;
102	class.cbWndExtra = 0;
103	class.hInstance = TclWinGetTclInstance();
104	class.hbrBackground = NULL;
105	class.lpszMenuName = NULL;
106	class.lpszClassName = "TclNotifier";
107	class.lpfnWndProc = NotifierProc;
108	class.hIcon = NULL;
109	class.hCursor = NULL;
110
111	if (!RegisterClassA(&class)) {
112	panic("Unable to register TclNotifier window class");
113	}
114	}
115	notifierCount++;
116	Tcl_MutexUnlock(&notifierMutex);
117
118	tsdPtr->pending = 0;
119	tsdPtr->timerActive = 0;
120
121	InitializeCriticalSection(&tsdPtr->crit);
122
123	tsdPtr->hwnd = NULL;
124	tsdPtr->thread = GetCurrentThreadId();
125	tsdPtr->event = CreateEvent(NULL, TRUE /* manual */,
126	FALSE /* !signaled */, NULL);
127
128	return (ClientData) tsdPtr;
129	}
130
131	/*
132	*----------------------------------------------------------------------
133	*
134	* Tcl_FinalizeNotifier --
135	*
136	* This function is called to cleanup the notifier state before
137	* a thread is terminated.
138	*
139	* Results:
140	* None.
141	*
142	* Side effects:
143	* May dispose of the notifier window and class.
144	*
145	*----------------------------------------------------------------------
146	*/
147
148	void
149	Tcl_FinalizeNotifier(clientData)
150	ClientData clientData; /* Pointer to notifier data. */
151	{
152	ThreadSpecificData tsdPtr = (ThreadSpecificData ) clientData;
153
154	DeleteCriticalSection(&tsdPtr->crit);
155	CloseHandle(tsdPtr->event);
156
157	/*
158	* Clean up the timer and messaging window for this thread.
159	*/
160
161	if (tsdPtr->hwnd) {
162	KillTimer(tsdPtr->hwnd, INTERVAL_TIMER);
163	DestroyWindow(tsdPtr->hwnd);
164	}
165
166	/*
167	* If this is the last thread to use the notifier, unregister
168	* the notifier window class.
169	*/
170
171	Tcl_MutexLock(&notifierMutex);
172	notifierCount--;
173	if (notifierCount == 0) {
174	UnregisterClassA("TclNotifier", TclWinGetTclInstance());
175	}
176	Tcl_MutexUnlock(&notifierMutex);
177	}
178
179	/*
180	*----------------------------------------------------------------------
181	*
182	* Tcl_AlertNotifier --
183	*
184	* Wake up the specified notifier from any thread. This routine
185	* is called by the platform independent notifier code whenever
186	* the Tcl_ThreadAlert routine is called. This routine is
187	* guaranteed not to be called on a given notifier after
188	* Tcl_FinalizeNotifier is called for that notifier. This routine
189	* is typically called from a thread other than the notifier's
190	* thread.
191	*
192	* Results:
193	* None.
194	*
195	* Side effects:
196	* Sends a message to the messaging window for the notifier
197	* if there isn't already one pending.
198	*
199	*----------------------------------------------------------------------
200	*/
201
202	void
203	Tcl_AlertNotifier(clientData)
204	ClientData clientData; /* Pointer to thread data. */
205	{
206	ThreadSpecificData tsdPtr = (ThreadSpecificData ) clientData;
207
208	/*
209	* Note that we do not need to lock around access to the hwnd
210	* because the race condition has no effect since any race condition
211	* implies that the notifier thread is already awake.
212	*/
213
214	if (tsdPtr->hwnd) {
215	/*
216	* We do need to lock around access to the pending flag.
217	*/
218
219	EnterCriticalSection(&tsdPtr->crit);
220	if (!tsdPtr->pending) {
221	PostMessage(tsdPtr->hwnd, WM_WAKEUP, 0, 0);
222	}
223	tsdPtr->pending = 1;
224	LeaveCriticalSection(&tsdPtr->crit);
225	} else {
226	SetEvent(tsdPtr->event);
227	}
228	}
229
230	/*
231	*----------------------------------------------------------------------
232	*
233	* Tcl_SetTimer --
234	*
235	* This procedure sets the current notifier timer value. The
236	* notifier will ensure that Tcl_ServiceAll() is called after
237	* the specified interval, even if no events have occurred.
238	*
239	* Results:
240	* None.
241	*
242	* Side effects:
243	* Replaces any previous timer.
244	*
245	*----------------------------------------------------------------------
246	*/
247
248	void
249	Tcl_SetTimer(
250	Tcl_Time timePtr) / Maximum block time, or NULL. */
251	{
252	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
253	UINT timeout;
254
255	/*
256	* Allow the notifier to be hooked. This may not make sense
257	* on Windows, but mirrors the UNIX hook.
258	*/
259
260	if (tclStubs.tcl_SetTimer != Tcl_SetTimer) {
261	tclStubs.tcl_SetTimer(timePtr);
262	return;
263	}
264
265	/*
266	* We only need to set up an interval timer if we're being called
267	* from an external event loop. If we don't have a window handle
268	* then we just return immediately and let Tcl_WaitForEvent handle
269	* timeouts.
270	*/
271
272	if (!tsdPtr->hwnd) {
273	return;
274	}
275
276	if (!timePtr) {
277	timeout = 0;
278	} else {
279	/*
280	* Make sure we pass a non-zero value into the timeout argument.
281	* Windows seems to get confused by zero length timers.
282	*/
283
284	timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
285	if (timeout == 0) {
286	timeout = 1;
287	}
288	}
289	tsdPtr->timeout = timeout;
290	if (timeout != 0) {
291	tsdPtr->timerActive = 1;
292	SetTimer(tsdPtr->hwnd, INTERVAL_TIMER,
293	(unsigned long) tsdPtr->timeout, NULL);
294	} else {
295	tsdPtr->timerActive = 0;
296	KillTimer(tsdPtr->hwnd, INTERVAL_TIMER);
297	}
298	}
299
300	/*
301	*----------------------------------------------------------------------
302	*
303	* Tcl_ServiceModeHook --
304	*
305	* This function is invoked whenever the service mode changes.
306	*
307	* Results:
308	* None.
309	*
310	* Side effects:
311	* If this is the first time the notifier is set into
312	* TCL_SERVICE_ALL, then the communication window is created.
313	*
314	*----------------------------------------------------------------------
315	*/
316
317	void
318	Tcl_ServiceModeHook(mode)
319	int mode; /* Either TCL_SERVICE_ALL, or
320	* TCL_SERVICE_NONE. */
321	{
322	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
323
324	/*
325	* If this is the first time that the notifier has been used from a
326	* modal loop, then create a communication window. Note that after
327	* this point, the application needs to service events in a timely
328	* fashion or Windows will hang waiting for the window to respond
329	* to synchronous system messages. At some point, we may want to
330	* consider destroying the window if we leave the modal loop, but
331	* for now we'll leave it around.
332	*/
333
334	if (mode == TCL_SERVICE_ALL && !tsdPtr->hwnd) {
335	tsdPtr->hwnd = CreateWindowA("TclNotifier", "TclNotifier", WS_TILED,
336	0, 0, 0, 0, NULL, NULL, TclWinGetTclInstance(), NULL);
337	/*
338	* Send an initial message to the window to ensure that we wake up the
339	* notifier once we get into the modal loop. This will force the
340	* notifier to recompute the timeout value and schedule a timer
341	* if one is needed.
342	*/
343
344	Tcl_AlertNotifier((ClientData)tsdPtr);
345	}
346	}
347
348	/*
349	*----------------------------------------------------------------------
350	*
351	* NotifierProc --
352	*
353	* This procedure is invoked by Windows to process events on
354	* the notifier window. Messages will be sent to this window
355	* in response to external timer events or calls to
356	* TclpAlertTsdPtr->
357	*
358	* Results:
359	* A standard windows result.
360	*
361	* Side effects:
362	* Services any pending events.
363	*
364	*----------------------------------------------------------------------
365	*/
366
367	static LRESULT CALLBACK
368	NotifierProc(
369	HWND hwnd,
370	UINT message,
371	WPARAM wParam,
372	LPARAM lParam)
373	{
374	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
375
376	if (message == WM_WAKEUP) {
377	EnterCriticalSection(&tsdPtr->crit);
378	tsdPtr->pending = 0;
379	LeaveCriticalSection(&tsdPtr->crit);
380	} else if (message != WM_TIMER) {
381	return DefWindowProc(hwnd, message, wParam, lParam);
382	}
383
384	/*
385	* Process all of the runnable events.
386	*/
387
388	Tcl_ServiceAll();
389	return 0;
390	}
391
392	/*
393	*----------------------------------------------------------------------
394	*
395	* Tcl_WaitForEvent --
396	*
397	* This function is called by Tcl_DoOneEvent to wait for new
398	* events on the message queue. If the block time is 0, then
399	* Tcl_WaitForEvent just polls the event queue without blocking.
400	*
401	* Results:
402	* Returns -1 if a WM_QUIT message is detected, returns 1 if
403	* a message was dispatched, otherwise returns 0.
404	*
405	* Side effects:
406	* Dispatches a message to a window procedure, which could do
407	* anything.
408	*
409	*----------------------------------------------------------------------
410	*/
411
412	int
413	Tcl_WaitForEvent(
414	Tcl_Time timePtr) / Maximum block time, or NULL. */
415	{
416	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
417	MSG msg;
418	DWORD timeout, result;
419	int status;
420
421	/*
422	* Allow the notifier to be hooked. This may not make
423	* sense on windows, but mirrors the UNIX hook.
424	*/
425
426	if (tclStubs.tcl_WaitForEvent != Tcl_WaitForEvent) {
427	return tclStubs.tcl_WaitForEvent(timePtr);
428	}
429
430	/*
431	* Compute the timeout in milliseconds.
432	*/
433
434	if (timePtr) {
435	timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
436	} else {
437	timeout = INFINITE;
438	}
439
440	/*
441	* Check to see if there are any messages in the queue before waiting
442	* because MsgWaitForMultipleObjects will not wake up if there are events
443	* currently sitting in the queue.
444	*/
445
446	if (!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
447	/*
448	* Wait for something to happen (a signal from another thread, a
449	* message, or timeout).
450	*/
451
452	result = MsgWaitForMultipleObjects(1, &tsdPtr->event, FALSE, timeout,
453	QS_ALLINPUT);
454	}
455
456	/*
457	* Check to see if there are any messages to process.
458	*/
459
460	if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
461	/*
462	* Retrieve and dispatch the first message.
463	*/
464
465	result = GetMessage(&msg, NULL, 0, 0);
466	if (result == 0) {
467	/*
468	* We received a request to exit this thread (WM_QUIT), so
469	* propagate the quit message and start unwinding.
470	*/
471
472	PostQuitMessage(msg.wParam);
473	status = -1;
474	} else if (result == -1) {
475	/*
476	* We got an error from the system. I have no idea why this would
477	* happen, so we'll just unwind.
478	*/
479
480	status = -1;
481	} else {
482	TranslateMessage(&msg);
483	DispatchMessage(&msg);
484	status = 1;
485	}
486	} else {
487	status = 0;
488	}
489
490	ResetEvent(tsdPtr->event);
491	return status;
492	}
493
494	/*
495	*----------------------------------------------------------------------
496	*
497	* Tcl_Sleep --
498	*
499	* Delay execution for the specified number of milliseconds.
500	*
501	* Results:
502	* None.
503	*
504	* Side effects:
505	* Time passes.
506	*
507	*----------------------------------------------------------------------
508	*/
509
510	void
511	Tcl_Sleep(ms)
512	int ms; /* Number of milliseconds to sleep. */
513	{
514	Sleep(ms);
515	}
516
517	/* End of tclwinnotify.c */