From 135594648fce77f748f01146f1f04b05172b0c57 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20v=2E=20L=C3=B6wis?= Date: Wed, 11 Dec 2002 19:55:48 +0000 Subject: This is not used anymore. --- Modules/license.terms | 39 -- Modules/tclNotify.c | 964 -------------------------------------------------- 2 files changed, 1003 deletions(-) delete mode 100644 Modules/license.terms delete mode 100644 Modules/tclNotify.c diff --git a/Modules/license.terms b/Modules/license.terms deleted file mode 100644 index 96ad966..0000000 --- a/Modules/license.terms +++ /dev/null @@ -1,39 +0,0 @@ -This software is copyrighted by the Regents of the University of -California, Sun Microsystems, Inc., and other parties. The following -terms apply to all files associated with the software unless explicitly -disclaimed in individual files. - -The authors hereby grant permission to use, copy, modify, distribute, -and license this software and its documentation for any purpose, provided -that existing copyright notices are retained in all copies and that this -notice is included verbatim in any distributions. No written agreement, -license, or royalty fee is required for any of the authorized uses. -Modifications to this software may be copyrighted by their authors -and need not follow the licensing terms described here, provided that -the new terms are clearly indicated on the first page of each file where -they apply. - -IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY -FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES -ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY -DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. - -THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE -IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE -NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR -MODIFICATIONS. - -GOVERNMENT USE: If you are acquiring this software on behalf of the -U.S. government, the Government shall have only "Restricted Rights" -in the software and related documentation as defined in the Federal -Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you -are acquiring the software on behalf of the Department of Defense, the -software shall be classified as "Commercial Computer Software" and the -Government shall have only "Restricted Rights" as defined in Clause -252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the -authors grant the U.S. Government and others acting in its behalf -permission to use and distribute the software in accordance with the -terms specified in this license. diff --git a/Modules/tclNotify.c b/Modules/tclNotify.c deleted file mode 100644 index 7a4e7c0..0000000 --- a/Modules/tclNotify.c +++ /dev/null @@ -1,964 +0,0 @@ -/* - * This is a modified version of tclNotify.c from Sun's Tcl 8.0 - * distribution. The purpose of the modification is to provide an - * interface to the internals of the notifier that make it possible to - * write safe multi-threaded Python programs that use Tkinter. - * - * Original comments follow. The file license.terms from the Tcl 8.0 - * distribution is contained in this directory, as required. - */ - -/* - * tclNotify.c -- - * - * This file implements the generic portion of the Tcl notifier. - * The notifier is lowest-level part of the event system. It - * manages an event queue that holds Tcl_Event structures. The - * platform specific portion of the notifier is defined in the - * tcl*Notify.c files in each platform directory. - * - * 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. - * - * SCCS: @(#) tclNotify.c 1.15 97/06/18 17:14:04 - */ - -#include "tclInt.h" -#include "tclPort.h" - -/* - * The following static indicates whether this module has been initialized. - */ - -static int initialized = 0; - -/* - * For each event source (created with Tcl_CreateEventSource) there - * is a structure of the following type: - */ - -typedef struct EventSource { - Tcl_EventSetupProc *setupProc; - Tcl_EventCheckProc *checkProc; - ClientData clientData; - struct EventSource *nextPtr; -} EventSource; - -/* - * The following structure keeps track of the state of the notifier. - * The first three elements keep track of the event queue. In addition to - * the first (next to be serviced) and last events in the queue, we keep - * track of a "marker" event. This provides a simple priority mechanism - * whereby events can be inserted at the front of the queue but behind all - * other high-priority events already in the queue (this is used for things - * like a sequence of Enter and Leave events generated during a grab in - * Tk). - */ - -static struct { - Tcl_Event *firstEventPtr; /* First pending event, or NULL if none. */ - Tcl_Event *lastEventPtr; /* Last pending event, or NULL if none. */ - Tcl_Event *markerEventPtr; /* Last high-priority event in queue, or - * NULL if none. */ - int serviceMode; /* One of TCL_SERVICE_NONE or - * TCL_SERVICE_ALL. */ - int blockTimeSet; /* 0 means there is no maximum block - * time: block forever. */ - Tcl_Time blockTime; /* If blockTimeSet is 1, gives the - * maximum elapsed time for the next block. */ - int inTraversal; /* 1 if Tcl_SetMaxBlockTime is being - * called during an event source traversal. */ - EventSource *firstEventSourcePtr; - /* Pointer to first event source in - * global list of event sources. */ -} notifier; - -/* - * Declarations for functions used in this file. - */ - -static void InitNotifier _ANSI_ARGS_((void)); -static void NotifierExitHandler _ANSI_ARGS_((ClientData clientData)); - - -/* - *---------------------------------------------------------------------- - * - * InitNotifier -- - * - * This routine is called to initialize the notifier module. - * - * Results: - * None. - * - * Side effects: - * Creates an exit handler and initializes static data. - * - *---------------------------------------------------------------------- - */ - -static void -InitNotifier(void) -{ - initialized = 1; - memset(¬ifier, 0, sizeof(notifier)); - notifier.serviceMode = TCL_SERVICE_NONE; - Tcl_CreateExitHandler(NotifierExitHandler, NULL); -} - -/* - *---------------------------------------------------------------------- - * - * NotifierExitHandler -- - * - * This routine is called during Tcl finalization. - * - * Results: - * None. - * - * Side effects: - * Clears the notifier initialization flag. - * - *---------------------------------------------------------------------- - */ - -static void -NotifierExitHandler(clientData) - ClientData clientData; /* Not used. */ -{ - initialized = 0; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_CreateEventSource -- - * - * This procedure is invoked to create a new source of events. - * The source is identified by a procedure that gets invoked - * during Tcl_DoOneEvent to check for events on that source - * and queue them. - * - * - * Results: - * None. - * - * Side effects: - * SetupProc and checkProc will be invoked each time that Tcl_DoOneEvent - * runs out of things to do. SetupProc will be invoked before - * Tcl_DoOneEvent calls select or whatever else it uses to wait - * for events. SetupProc typically calls functions like Tcl_WatchFile - * or Tcl_SetMaxBlockTime to indicate what to wait for. - * - * CheckProc is called after select or whatever operation was actually - * used to wait. It figures out whether anything interesting actually - * happened (e.g. by calling Tcl_FileReady), and then calls - * Tcl_QueueEvent to queue any events that are ready. - * - * Each of these procedures is passed two arguments, e.g. - * (*checkProc)(ClientData clientData, int flags)); - * ClientData is the same as the clientData argument here, and flags - * is a combination of things like TCL_FILE_EVENTS that indicates - * what events are of interest: setupProc and checkProc use flags - * to figure out whether their events are relevant or not. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_CreateEventSource(setupProc, checkProc, clientData) - Tcl_EventSetupProc *setupProc; /* Procedure to invoke to figure out - * what to wait for. */ - Tcl_EventCheckProc *checkProc; /* Procedure to call after waiting - * to see what happened. */ - ClientData clientData; /* One-word argument to pass to - * setupProc and checkProc. */ -{ - EventSource *sourcePtr; - - if (!initialized) { - InitNotifier(); - } - - sourcePtr = (EventSource *) ckalloc(sizeof(EventSource)); - sourcePtr->setupProc = setupProc; - sourcePtr->checkProc = checkProc; - sourcePtr->clientData = clientData; - sourcePtr->nextPtr = notifier.firstEventSourcePtr; - notifier.firstEventSourcePtr = sourcePtr; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_DeleteEventSource -- - * - * This procedure is invoked to delete the source of events - * given by proc and clientData. - * - * Results: - * None. - * - * Side effects: - * The given event source is canceled, so its procedure will - * never again be called. If no such source exists, nothing - * happens. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_DeleteEventSource(setupProc, checkProc, clientData) - Tcl_EventSetupProc *setupProc; /* Procedure to invoke to figure out - * what to wait for. */ - Tcl_EventCheckProc *checkProc; /* Procedure to call after waiting - * to see what happened. */ - ClientData clientData; /* One-word argument to pass to - * setupProc and checkProc. */ -{ - EventSource *sourcePtr, *prevPtr; - - for (sourcePtr = notifier.firstEventSourcePtr, prevPtr = NULL; - sourcePtr != NULL; - prevPtr = sourcePtr, sourcePtr = sourcePtr->nextPtr) { - if ((sourcePtr->setupProc != setupProc) - || (sourcePtr->checkProc != checkProc) - || (sourcePtr->clientData != clientData)) { - continue; - } - if (prevPtr == NULL) { - notifier.firstEventSourcePtr = sourcePtr->nextPtr; - } else { - prevPtr->nextPtr = sourcePtr->nextPtr; - } - ckfree((char *) sourcePtr); - return; - } -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_QueueEvent -- - * - * Insert an event into the Tk event queue at one of three - * positions: the head, the tail, or before a floating marker. - * Events inserted before the marker will be processed in - * first-in-first-out order, but before any events inserted at - * the tail of the queue. Events inserted at the head of the - * queue will be processed in last-in-first-out order. - * - * Results: - * None. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_QueueEvent(evPtr, position) - Tcl_Event* evPtr; /* Event to add to queue. The storage - * space must have been allocated the caller - * with malloc (ckalloc), and it becomes - * the property of the event queue. It - * will be freed after the event has been - * handled. */ - Tcl_QueuePosition position; /* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, - * TCL_QUEUE_MARK. */ -{ - if (!initialized) { - InitNotifier(); - } - - if (position == TCL_QUEUE_TAIL) { - /* - * Append the event on the end of the queue. - */ - - evPtr->nextPtr = NULL; - if (notifier.firstEventPtr == NULL) { - notifier.firstEventPtr = evPtr; - } else { - notifier.lastEventPtr->nextPtr = evPtr; - } - notifier.lastEventPtr = evPtr; - } else if (position == TCL_QUEUE_HEAD) { - /* - * Push the event on the head of the queue. - */ - - evPtr->nextPtr = notifier.firstEventPtr; - if (notifier.firstEventPtr == NULL) { - notifier.lastEventPtr = evPtr; - } - notifier.firstEventPtr = evPtr; - } else if (position == TCL_QUEUE_MARK) { - /* - * Insert the event after the current marker event and advance - * the marker to the new event. - */ - - if (notifier.markerEventPtr == NULL) { - evPtr->nextPtr = notifier.firstEventPtr; - notifier.firstEventPtr = evPtr; - } else { - evPtr->nextPtr = notifier.markerEventPtr->nextPtr; - notifier.markerEventPtr->nextPtr = evPtr; - } - notifier.markerEventPtr = evPtr; - if (evPtr->nextPtr == NULL) { - notifier.lastEventPtr = evPtr; - } - } -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_DeleteEvents -- - * - * Calls a procedure for each event in the queue and deletes those - * for which the procedure returns 1. Events for which the - * procedure returns 0 are left in the queue. - * - * Results: - * None. - * - * Side effects: - * Potentially removes one or more events from the event queue. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_DeleteEvents(proc, clientData) - Tcl_EventDeleteProc *proc; /* The procedure to call. */ - ClientData clientData; /* type-specific data. */ -{ - Tcl_Event *evPtr, *prevPtr, *hold; - - if (!initialized) { - InitNotifier(); - } - - for (prevPtr = (Tcl_Event *) NULL, evPtr = notifier.firstEventPtr; - evPtr != (Tcl_Event *) NULL; - ) { - if ((*proc) (evPtr, clientData) == 1) { - if (notifier.firstEventPtr == evPtr) { - notifier.firstEventPtr = evPtr->nextPtr; - if (evPtr->nextPtr == (Tcl_Event *) NULL) { - notifier.lastEventPtr = (Tcl_Event *) NULL; - } - } else { - prevPtr->nextPtr = evPtr->nextPtr; - } - hold = evPtr; - evPtr = evPtr->nextPtr; - ckfree((char *) hold); - } else { - prevPtr = evPtr; - evPtr = evPtr->nextPtr; - } - } -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_ServiceEvent -- - * - * Process one event from the event queue, or invoke an - * asynchronous event handler. - * - * Results: - * The return value is 1 if the procedure actually found an event - * to process. If no processing occurred, then 0 is returned. - * - * Side effects: - * Invokes all of the event handlers for the highest priority - * event in the event queue. May collapse some events into a - * single event or discard stale events. - * - *---------------------------------------------------------------------- - */ - -int -Tcl_ServiceEvent(flags) - int flags; /* Indicates what events should be processed. - * May be any combination of TCL_WINDOW_EVENTS - * TCL_FILE_EVENTS, TCL_TIMER_EVENTS, or other - * flags defined elsewhere. Events not - * matching this will be skipped for processing - * later. */ -{ - Tcl_Event *evPtr, *prevPtr; - Tcl_EventProc *proc; - - if (!initialized) { - InitNotifier(); - } - - /* - * Asynchronous event handlers are considered to be the highest - * priority events, and so must be invoked before we process events - * on the event queue. - */ - - if (Tcl_AsyncReady()) { - (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0); - return 1; - } - - /* - * No event flags is equivalent to TCL_ALL_EVENTS. - */ - - if ((flags & TCL_ALL_EVENTS) == 0) { - flags |= TCL_ALL_EVENTS; - } - - /* - * Loop through all the events in the queue until we find one - * that can actually be handled. - */ - - for (evPtr = notifier.firstEventPtr; evPtr != NULL; - evPtr = evPtr->nextPtr) { - /* - * Call the handler for the event. If it actually handles the - * event then free the storage for the event. There are two - * tricky things here, but stemming from the fact that the event - * code may be re-entered while servicing the event: - * - * 1. Set the "proc" field to NULL. This is a signal to ourselves - * that we shouldn't reexecute the handler if the event loop - * is re-entered. - * 2. When freeing the event, must search the queue again from the - * front to find it. This is because the event queue could - * change almost arbitrarily while handling the event, so we - * can't depend on pointers found now still being valid when - * the handler returns. - */ - - proc = evPtr->proc; - evPtr->proc = NULL; - if ((proc != NULL) && (*proc)(evPtr, flags)) { - if (notifier.firstEventPtr == evPtr) { - notifier.firstEventPtr = evPtr->nextPtr; - if (evPtr->nextPtr == NULL) { - notifier.lastEventPtr = NULL; - } - if (notifier.markerEventPtr == evPtr) { - notifier.markerEventPtr = NULL; - } - } else { - for (prevPtr = notifier.firstEventPtr; - prevPtr->nextPtr != evPtr; prevPtr = prevPtr->nextPtr) { - /* Empty loop body. */ - } - prevPtr->nextPtr = evPtr->nextPtr; - if (evPtr->nextPtr == NULL) { - notifier.lastEventPtr = prevPtr; - } - if (notifier.markerEventPtr == evPtr) { - notifier.markerEventPtr = prevPtr; - } - } - ckfree((char *) evPtr); - return 1; - } else { - /* - * The event wasn't actually handled, so we have to restore - * the proc field to allow the event to be attempted again. - */ - - evPtr->proc = proc; - } - - /* - * The handler for this event asked to defer it. Just go on to - * the next event. - */ - - continue; - } - return 0; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_GetServiceMode -- - * - * This routine returns the current service mode of the notifier. - * - * Results: - * Returns either TCL_SERVICE_ALL or TCL_SERVICE_NONE. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -int -Tcl_GetServiceMode(void) -{ - if (!initialized) { - InitNotifier(); - } - - return notifier.serviceMode; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_SetServiceMode -- - * - * This routine sets the current service mode of the notifier. - * - * Results: - * Returns the previous service mode. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -int -Tcl_SetServiceMode(mode) - int mode; /* New service mode: TCL_SERVICE_ALL or - * TCL_SERVICE_NONE */ -{ - int oldMode; - - if (!initialized) { - InitNotifier(); - } - - oldMode = notifier.serviceMode; - notifier.serviceMode = mode; - return oldMode; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_SetMaxBlockTime -- - * - * This procedure is invoked by event sources to tell the notifier - * how long it may block the next time it blocks. The timePtr - * argument gives a maximum time; the actual time may be less if - * some other event source requested a smaller time. - * - * Results: - * None. - * - * Side effects: - * May reduce the length of the next sleep in the notifier. - * - *---------------------------------------------------------------------- - */ - -void -Tcl_SetMaxBlockTime(timePtr) - Tcl_Time *timePtr; /* Specifies a maximum elapsed time for - * the next blocking operation in the - * event notifier. */ -{ - if (!initialized) { - InitNotifier(); - } - - if (!notifier.blockTimeSet || (timePtr->sec < notifier.blockTime.sec) - || ((timePtr->sec == notifier.blockTime.sec) - && (timePtr->usec < notifier.blockTime.usec))) { - notifier.blockTime = *timePtr; - notifier.blockTimeSet = 1; - } - - /* - * If we are called outside an event source traversal, set the - * timeout immediately. - */ - - if (!notifier.inTraversal) { - if (notifier.blockTimeSet) { - Tcl_SetTimer(¬ifier.blockTime); - } else { - Tcl_SetTimer(NULL); - } - } -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_DoOneEvent -- - * - * Process a single event of some sort. If there's no work to - * do, wait for an event to occur, then process it. - * - * Results: - * The return value is 1 if the procedure actually found an event - * to process. If no processing occurred, then 0 is returned (this - * can happen if the TCL_DONT_WAIT flag is set or if there are no - * event handlers to wait for in the set specified by flags). - * - * Side effects: - * May delay execution of process while waiting for an event, - * unless TCL_DONT_WAIT is set in the flags argument. Event - * sources are invoked to check for and queue events. Event - * handlers may produce arbitrary side effects. - * - *---------------------------------------------------------------------- - */ - -int -Tcl_DoOneEvent(flags) - int flags; /* Miscellaneous flag values: may be any - * combination of TCL_DONT_WAIT, - * TCL_WINDOW_EVENTS, TCL_FILE_EVENTS, - * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or - * others defined by event sources. */ -{ - int result = 0, oldMode; - EventSource *sourcePtr; - Tcl_Time *timePtr; - - if (!initialized) { - InitNotifier(); - } - - /* - * The first thing we do is to service any asynchronous event - * handlers. - */ - - if (Tcl_AsyncReady()) { - (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0); - return 1; - } - - /* - * No event flags is equivalent to TCL_ALL_EVENTS. - */ - - if ((flags & TCL_ALL_EVENTS) == 0) { - flags |= TCL_ALL_EVENTS; - } - - /* - * Set the service mode to none so notifier event routines won't - * try to service events recursively. - */ - - oldMode = notifier.serviceMode; - notifier.serviceMode = TCL_SERVICE_NONE; - - /* - * The core of this procedure is an infinite loop, even though - * we only service one event. The reason for this is that we - * may be processing events that don't do anything inside of Tcl. - */ - - while (1) { - - /* - * If idle events are the only things to service, skip the - * main part of the loop and go directly to handle idle - * events (i.e. don't wait even if TCL_DONT_WAIT isn't set). - */ - - if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) { - flags = TCL_IDLE_EVENTS|TCL_DONT_WAIT; - goto idleEvents; - } - - /* - * Ask Tcl to service a queued event, if there are any. - */ - - if (Tcl_ServiceEvent(flags)) { - result = 1; - break; - } - - /* - * If TCL_DONT_WAIT is set, be sure to poll rather than - * blocking, otherwise reset the block time to infinity. - */ - - if (flags & TCL_DONT_WAIT) { - notifier.blockTime.sec = 0; - notifier.blockTime.usec = 0; - notifier.blockTimeSet = 1; - } else { - notifier.blockTimeSet = 0; - } - - /* - * Set up all the event sources for new events. This will - * cause the block time to be updated if necessary. - */ - - notifier.inTraversal = 1; - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->setupProc) { - (sourcePtr->setupProc)(sourcePtr->clientData, flags); - } - } - notifier.inTraversal = 0; - - if ((flags & TCL_DONT_WAIT) || notifier.blockTimeSet) { - timePtr = ¬ifier.blockTime; - } else { - timePtr = NULL; - } - - /* - * Wait for a new event or a timeout. If Tcl_WaitForEvent - * returns -1, we should abort Tcl_DoOneEvent. - */ - - result = Tcl_WaitForEvent(timePtr); - if (result < 0) { - result = 0; - break; - } - - /* - * Check all the event sources for new events. - */ - - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->checkProc) { - (sourcePtr->checkProc)(sourcePtr->clientData, flags); - } - } - - /* - * Check for events queued by the notifier or event sources. - */ - - if (Tcl_ServiceEvent(flags)) { - result = 1; - break; - } - - /* - * We've tried everything at this point, but nobody we know - * about had anything to do. Check for idle events. If none, - * either quit or go back to the top and try again. - */ - - idleEvents: - if (flags & TCL_IDLE_EVENTS) { - if (TclServiceIdle()) { - result = 1; - break; - } - } - if (flags & TCL_DONT_WAIT) { - break; - } - } - - notifier.serviceMode = oldMode; - return result; -} - -/* - *---------------------------------------------------------------------- - * - * Tcl_ServiceAll -- - * - * This routine checks all of the event sources, processes - * events that are on the Tcl event queue, and then calls the - * any idle handlers. Platform specific notifier callbacks that - * generate events should call this routine before returning to - * the system in order to ensure that Tcl gets a chance to - * process the new events. - * - * Results: - * Returns 1 if an event or idle handler was invoked, else 0. - * - * Side effects: - * Anything that an event or idle handler may do. - * - *---------------------------------------------------------------------- - */ - -int -Tcl_ServiceAll(void) -{ - int result = 0; - EventSource *sourcePtr; - - if (!initialized) { - InitNotifier(); - } - - if (notifier.serviceMode == TCL_SERVICE_NONE) { - return result; - } - - /* - * We need to turn off event servicing like we to in Tcl_DoOneEvent, - * to avoid recursive calls. - */ - - notifier.serviceMode = TCL_SERVICE_NONE; - - /* - * Check async handlers first. - */ - - if (Tcl_AsyncReady()) { - (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0); - } - - /* - * Make a single pass through all event sources, queued events, - * and idle handlers. Note that we wait to update the notifier - * timer until the end so we can avoid multiple changes. - */ - - notifier.inTraversal = 1; - notifier.blockTimeSet = 0; - - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->setupProc) { - (sourcePtr->setupProc)(sourcePtr->clientData, TCL_ALL_EVENTS); - } - } - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->checkProc) { - (sourcePtr->checkProc)(sourcePtr->clientData, TCL_ALL_EVENTS); - } - } - - while (Tcl_ServiceEvent(0)) { - result = 1; - } - if (TclServiceIdle()) { - result = 1; - } - - if (!notifier.blockTimeSet) { - Tcl_SetTimer(NULL); - } else { - Tcl_SetTimer(¬ifier.blockTime); - } - notifier.inTraversal = 0; - notifier.serviceMode = TCL_SERVICE_ALL; - return result; -} - -/* - *---------------------------------------------------------------------- - * - * PyTcl_WaitUntilEvent -- - * - * New function to wait until a Tcl event is ready without - * actually handling the event. This is different than - * TclWaitForEvent(): that function doesn't call the event - * check routines, which is necessary for our purpose. - * We also can't use Tcl_DoOneEvent(TCL_DONT_WAIT), since that - * does too much: it handles the event. We want the *handling* - * of the event to be done with the Python lock held, but the - * *waiting* with the lock released. - * - * Since the event administration is not exported, our only - * choice is to use a modified copy of the file tclNotify.c, - * containing this additional function that makes the desired - * functionality available. It is mostly a stripped down version - * of the code in Tcl_DoOneEvent(). - * - * This requires that you link with a static version of the Tcl - * library. On Windows/Mac, a custom compilation of Tcl may be - * required (I haven't tried this yet). - * - *---------------------------------------------------------------------- - */ - -int -PyTcl_WaitUntilEvent(void) -{ - int flags = TCL_ALL_EVENTS; - int result = 0, oldMode; - EventSource *sourcePtr; - Tcl_Time *timePtr; - - if (!initialized) { - InitNotifier(); - } - - /* - * The first thing we do is to service any asynchronous event - * handlers. - */ - - if (Tcl_AsyncReady()) - return 1; - - /* - * Set the service mode to none so notifier event routines won't - * try to service events recursively. - */ - - oldMode = notifier.serviceMode; - notifier.serviceMode = TCL_SERVICE_NONE; - - notifier.blockTimeSet = 0; - - /* - * Set up all the event sources for new events. This will - * cause the block time to be updated if necessary. - */ - - notifier.inTraversal = 1; - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->setupProc) { - (sourcePtr->setupProc)(sourcePtr->clientData, flags); - } - } - notifier.inTraversal = 0; - - timePtr = NULL; - - /* - * Wait for a new event or a timeout. If Tcl_WaitForEvent - * returns -1, we should abort Tcl_DoOneEvent. - */ - - result = Tcl_WaitForEvent(timePtr); - if (result < 0) - return 0; - - /* - * Check all the event sources for new events. - */ - - for (sourcePtr = notifier.firstEventSourcePtr; sourcePtr != NULL; - sourcePtr = sourcePtr->nextPtr) { - if (sourcePtr->checkProc) { - (sourcePtr->checkProc)(sourcePtr->clientData, flags); - } - } - - notifier.serviceMode = oldMode; - return result; -} -- cgit v0.12