668 lines
16 KiB
C
668 lines
16 KiB
C
|
/*
|
|||
|
|
* tclXtNotify.c --
|
|||
|
|
*
|
|||
|
|
* This file contains the notifier driver implementation for the Xt
|
|||
|
|
* intrinsics.
|
|||
|
|
*
|
|||
|
|
* Copyright (c) 1997 by Sun Microsystems, Inc.
|
|||
|
|
*
|
|||
|
|
* See the file "license.terms" for information on usage and redistribution of
|
|||
|
|
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#ifndef USE_TCL_STUBS
|
|||
|
|
# define USE_TCL_STUBS
|
|||
|
|
#endif
|
|||
|
|
#include <X11/Intrinsic.h>
|
|||
|
|
#include "tclInt.h"
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* This structure is used to keep track of the notifier info for a a
|
|||
|
|
* registered file.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
typedef struct FileHandler {
|
|||
|
|
int fd;
|
|||
|
|
int mask; /* Mask of desired events: TCL_READABLE,
|
|||
|
|
* etc. */
|
|||
|
|
int readyMask; /* Events that have been seen since the last
|
|||
|
|
* time FileHandlerEventProc was called for
|
|||
|
|
* this file. */
|
|||
|
|
XtInputId read; /* Xt read callback handle. */
|
|||
|
|
XtInputId write; /* Xt write callback handle. */
|
|||
|
|
XtInputId except; /* Xt exception callback handle. */
|
|||
|
|
Tcl_FileProc *proc; /* Procedure to call, in the style of
|
|||
|
|
* Tcl_CreateFileHandler. */
|
|||
|
|
ClientData clientData; /* Argument to pass to proc. */
|
|||
|
|
struct FileHandler *nextPtr;/* Next in list of all files we care about. */
|
|||
|
|
} FileHandler;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* The following structure is what is added to the Tcl event queue when file
|
|||
|
|
* handlers are ready to fire.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
typedef struct FileHandlerEvent {
|
|||
|
|
Tcl_Event header; /* Information that is standard for all
|
|||
|
|
* events. */
|
|||
|
|
int fd; /* File descriptor that is ready. Used to find
|
|||
|
|
* the FileHandler structure for the file
|
|||
|
|
* (can't point directly to the FileHandler
|
|||
|
|
* structure because it could go away while
|
|||
|
|
* the event is queued). */
|
|||
|
|
} FileHandlerEvent;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* The following static structure contains the state information for the Xt
|
|||
|
|
* based implementation of the Tcl notifier.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static struct NotifierState {
|
|||
|
|
XtAppContext appContext; /* The context used by the Xt notifier. Can be
|
|||
|
|
* set with TclSetAppContext. */
|
|||
|
|
int appContextCreated; /* Was it created by us? */
|
|||
|
|
XtIntervalId currentTimeout;/* Handle of current timer. */
|
|||
|
|
FileHandler *firstFileHandlerPtr;
|
|||
|
|
/* Pointer to head of file handler list. */
|
|||
|
|
} notifier;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* The following static indicates whether this module has been initialized.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static int initialized = 0;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Static routines defined in this file.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static int FileHandlerEventProc(Tcl_Event *evPtr, int flags);
|
|||
|
|
static void FileProc(XtPointer clientData, int *source,
|
|||
|
|
XtInputId *id);
|
|||
|
|
static void NotifierExitHandler(ClientData clientData);
|
|||
|
|
static void TimerProc(XtPointer clientData, XtIntervalId *id);
|
|||
|
|
static void CreateFileHandler(int fd, int mask,
|
|||
|
|
Tcl_FileProc *proc, ClientData clientData);
|
|||
|
|
static void DeleteFileHandler(int fd);
|
|||
|
|
static void SetTimer(const Tcl_Time * timePtr);
|
|||
|
|
static int WaitForEvent(const Tcl_Time * timePtr);
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Functions defined in this file for use by users of the Xt Notifier:
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
MODULE_SCOPE void InitNotifier(void);
|
|||
|
|
MODULE_SCOPE XtAppContext TclSetAppContext(XtAppContext ctx);
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TclSetAppContext --
|
|||
|
|
*
|
|||
|
|
* Set the notifier application context.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Sets the application context used by the notifier. Panics if the
|
|||
|
|
* context is already set when called.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
XtAppContext
|
|||
|
|
TclSetAppContext(
|
|||
|
|
XtAppContext appContext)
|
|||
|
|
{
|
|||
|
|
if (!initialized) {
|
|||
|
|
InitNotifier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* If we already have a context we check whether we were asked to set a
|
|||
|
|
* new context. If so, we panic because we try to prevent switching
|
|||
|
|
* contexts by mistake. Otherwise, we return the one we have.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (notifier.appContext != NULL) {
|
|||
|
|
if (appContext != NULL) {
|
|||
|
|
/*
|
|||
|
|
* We already have a context. We do not allow switching contexts
|
|||
|
|
* after initialization, so we panic.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
Tcl_Panic("TclSetAppContext: multiple application contexts");
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
/*
|
|||
|
|
* If we get here we have not yet gotten a context, so either create
|
|||
|
|
* one or use the one supplied by our caller.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (appContext == NULL) {
|
|||
|
|
/*
|
|||
|
|
* We must create a new context and tell our caller what it is, so
|
|||
|
|
* she can use it too.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
notifier.appContext = XtCreateApplicationContext();
|
|||
|
|
notifier.appContextCreated = 1;
|
|||
|
|
} else {
|
|||
|
|
/*
|
|||
|
|
* Otherwise we remember the context that our caller gave us and
|
|||
|
|
* use it.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
notifier.appContextCreated = 0;
|
|||
|
|
notifier.appContext = appContext;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return notifier.appContext;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* InitNotifier --
|
|||
|
|
*
|
|||
|
|
* Initializes the notifier state.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Creates a new exit handler.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
InitNotifier(void)
|
|||
|
|
{
|
|||
|
|
Tcl_NotifierProcs np;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Only reinitialize if we are not in exit handling. The notifier can get
|
|||
|
|
* reinitialized after its own exit handler has run, because of exit
|
|||
|
|
* handlers for the I/O and timer sub-systems (order dependency).
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (TclInExit()) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
np.createFileHandlerProc = CreateFileHandler;
|
|||
|
|
np.deleteFileHandlerProc = DeleteFileHandler;
|
|||
|
|
np.setTimerProc = SetTimer;
|
|||
|
|
np.waitForEventProc = WaitForEvent;
|
|||
|
|
np.initNotifierProc = Tcl_InitNotifier;
|
|||
|
|
np.finalizeNotifierProc = Tcl_FinalizeNotifier;
|
|||
|
|
np.alertNotifierProc = Tcl_AlertNotifier;
|
|||
|
|
np.serviceModeHookProc = Tcl_ServiceModeHook;
|
|||
|
|
Tcl_SetNotifier(&np);
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* DO NOT create the application context yet; doing so would prevent
|
|||
|
|
* external applications from setting it for us to their own ones.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
initialized = 1;
|
|||
|
|
memset(&np, 0, sizeof(np));
|
|||
|
|
Tcl_CreateExitHandler(NotifierExitHandler, NULL);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* NotifierExitHandler --
|
|||
|
|
*
|
|||
|
|
* This function is called to cleanup the notifier state before Tcl is
|
|||
|
|
* unloaded.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Destroys the notifier window.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
NotifierExitHandler(
|
|||
|
|
ClientData clientData) /* Not used. */
|
|||
|
|
{
|
|||
|
|
if (notifier.currentTimeout != 0) {
|
|||
|
|
XtRemoveTimeOut(notifier.currentTimeout);
|
|||
|
|
}
|
|||
|
|
for (; notifier.firstFileHandlerPtr != NULL; ) {
|
|||
|
|
Tcl_DeleteFileHandler(notifier.firstFileHandlerPtr->fd);
|
|||
|
|
}
|
|||
|
|
if (notifier.appContextCreated) {
|
|||
|
|
XtDestroyApplicationContext(notifier.appContext);
|
|||
|
|
notifier.appContextCreated = 0;
|
|||
|
|
notifier.appContext = NULL;
|
|||
|
|
}
|
|||
|
|
initialized = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* SetTimer --
|
|||
|
|
*
|
|||
|
|
* This procedure sets the current notifier timeout value.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Replaces any previous timer.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
SetTimer(
|
|||
|
|
const Tcl_Time *timePtr) /* Timeout value, may be NULL. */
|
|||
|
|
{
|
|||
|
|
long timeout;
|
|||
|
|
|
|||
|
|
if (!initialized) {
|
|||
|
|
InitNotifier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TclSetAppContext(NULL);
|
|||
|
|
if (notifier.currentTimeout != 0) {
|
|||
|
|
XtRemoveTimeOut(notifier.currentTimeout);
|
|||
|
|
}
|
|||
|
|
if (timePtr) {
|
|||
|
|
timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
|
|||
|
|
notifier.currentTimeout = XtAppAddTimeOut(notifier.appContext,
|
|||
|
|
(unsigned long) timeout, TimerProc, NULL);
|
|||
|
|
} else {
|
|||
|
|
notifier.currentTimeout = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TimerProc --
|
|||
|
|
*
|
|||
|
|
* This procedure is the XtTimerCallbackProc used to handle timeouts.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Processes all queued events.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
TimerProc(
|
|||
|
|
XtPointer clientData, /* Not used. */
|
|||
|
|
XtIntervalId *id)
|
|||
|
|
{
|
|||
|
|
if (*id != notifier.currentTimeout) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
notifier.currentTimeout = 0;
|
|||
|
|
|
|||
|
|
Tcl_ServiceAll();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* CreateFileHandler --
|
|||
|
|
*
|
|||
|
|
* This procedure registers a file handler with the Xt notifier.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Creates a new file handler structure and registers one or more input
|
|||
|
|
* procedures with Xt.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
CreateFileHandler(
|
|||
|
|
int fd, /* Handle of stream to watch. */
|
|||
|
|
int mask, /* OR'ed combination of TCL_READABLE,
|
|||
|
|
* TCL_WRITABLE, and TCL_EXCEPTION: indicates
|
|||
|
|
* conditions under which proc should be
|
|||
|
|
* called. */
|
|||
|
|
Tcl_FileProc *proc, /* Procedure to call for each selected
|
|||
|
|
* event. */
|
|||
|
|
ClientData clientData) /* Arbitrary data to pass to proc. */
|
|||
|
|
{
|
|||
|
|
FileHandler *filePtr;
|
|||
|
|
|
|||
|
|
if (!initialized) {
|
|||
|
|
InitNotifier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TclSetAppContext(NULL);
|
|||
|
|
|
|||
|
|
for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
|
|||
|
|
filePtr = filePtr->nextPtr) {
|
|||
|
|
if (filePtr->fd == fd) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (filePtr == NULL) {
|
|||
|
|
filePtr = ckalloc(sizeof(FileHandler));
|
|||
|
|
filePtr->fd = fd;
|
|||
|
|
filePtr->read = 0;
|
|||
|
|
filePtr->write = 0;
|
|||
|
|
filePtr->except = 0;
|
|||
|
|
filePtr->readyMask = 0;
|
|||
|
|
filePtr->mask = 0;
|
|||
|
|
filePtr->nextPtr = notifier.firstFileHandlerPtr;
|
|||
|
|
notifier.firstFileHandlerPtr = filePtr;
|
|||
|
|
}
|
|||
|
|
filePtr->proc = proc;
|
|||
|
|
filePtr->clientData = clientData;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Register the file with the Xt notifier, if it hasn't been done yet.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (mask & TCL_READABLE) {
|
|||
|
|
if (!(filePtr->mask & TCL_READABLE)) {
|
|||
|
|
filePtr->read = XtAppAddInput(notifier.appContext, fd,
|
|||
|
|
INT2PTR(XtInputReadMask), FileProc, filePtr);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if (filePtr->mask & TCL_READABLE) {
|
|||
|
|
XtRemoveInput(filePtr->read);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (mask & TCL_WRITABLE) {
|
|||
|
|
if (!(filePtr->mask & TCL_WRITABLE)) {
|
|||
|
|
filePtr->write = XtAppAddInput(notifier.appContext, fd,
|
|||
|
|
INT2PTR(XtInputWriteMask), FileProc, filePtr);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if (filePtr->mask & TCL_WRITABLE) {
|
|||
|
|
XtRemoveInput(filePtr->write);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (mask & TCL_EXCEPTION) {
|
|||
|
|
if (!(filePtr->mask & TCL_EXCEPTION)) {
|
|||
|
|
filePtr->except = XtAppAddInput(notifier.appContext, fd,
|
|||
|
|
INT2PTR(XtInputExceptMask), FileProc, filePtr);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if (filePtr->mask & TCL_EXCEPTION) {
|
|||
|
|
XtRemoveInput(filePtr->except);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
filePtr->mask = mask;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* DeleteFileHandler --
|
|||
|
|
*
|
|||
|
|
* Cancel a previously-arranged callback arrangement for a file.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* If a callback was previously registered on file, remove it.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
DeleteFileHandler(
|
|||
|
|
int fd) /* Stream id for which to remove callback
|
|||
|
|
* procedure. */
|
|||
|
|
{
|
|||
|
|
FileHandler *filePtr, *prevPtr;
|
|||
|
|
|
|||
|
|
if (!initialized) {
|
|||
|
|
InitNotifier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TclSetAppContext(NULL);
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Find the entry for the given file (and return if there isn't one).
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
for (prevPtr = NULL, filePtr = notifier.firstFileHandlerPtr; ;
|
|||
|
|
prevPtr = filePtr, filePtr = filePtr->nextPtr) {
|
|||
|
|
if (filePtr == NULL) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (filePtr->fd == fd) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Clean up information in the callback record.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (prevPtr == NULL) {
|
|||
|
|
notifier.firstFileHandlerPtr = filePtr->nextPtr;
|
|||
|
|
} else {
|
|||
|
|
prevPtr->nextPtr = filePtr->nextPtr;
|
|||
|
|
}
|
|||
|
|
if (filePtr->mask & TCL_READABLE) {
|
|||
|
|
XtRemoveInput(filePtr->read);
|
|||
|
|
}
|
|||
|
|
if (filePtr->mask & TCL_WRITABLE) {
|
|||
|
|
XtRemoveInput(filePtr->write);
|
|||
|
|
}
|
|||
|
|
if (filePtr->mask & TCL_EXCEPTION) {
|
|||
|
|
XtRemoveInput(filePtr->except);
|
|||
|
|
}
|
|||
|
|
ckfree(filePtr);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* FileProc --
|
|||
|
|
*
|
|||
|
|
* These procedures are called by Xt when a file becomes readable,
|
|||
|
|
* writable, or has an exception.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Makes an entry on the Tcl event queue if the event is interesting.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
FileProc(
|
|||
|
|
XtPointer clientData,
|
|||
|
|
int *fd,
|
|||
|
|
XtInputId *id)
|
|||
|
|
{
|
|||
|
|
FileHandler *filePtr = (FileHandler *)clientData;
|
|||
|
|
FileHandlerEvent *fileEvPtr;
|
|||
|
|
int mask = 0;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Determine which event happened.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (*id == filePtr->read) {
|
|||
|
|
mask = TCL_READABLE;
|
|||
|
|
} else if (*id == filePtr->write) {
|
|||
|
|
mask = TCL_WRITABLE;
|
|||
|
|
} else if (*id == filePtr->except) {
|
|||
|
|
mask = TCL_EXCEPTION;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Ignore unwanted or duplicate events.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (!(filePtr->mask & mask) || (filePtr->readyMask & mask)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* This is an interesting event, so put it onto the event queue.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
filePtr->readyMask |= mask;
|
|||
|
|
fileEvPtr = ckalloc(sizeof(FileHandlerEvent));
|
|||
|
|
fileEvPtr->header.proc = FileHandlerEventProc;
|
|||
|
|
fileEvPtr->fd = filePtr->fd;
|
|||
|
|
Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Process events on the Tcl event queue before returning to Xt.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
Tcl_ServiceAll();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* FileHandlerEventProc --
|
|||
|
|
*
|
|||
|
|
* This procedure is called by Tcl_ServiceEvent when a file event reaches
|
|||
|
|
* the front of the event queue. This procedure is responsible for
|
|||
|
|
* actually handling the event by invoking the callback for the file
|
|||
|
|
* handler.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Returns 1 if the event was handled, meaning it should be removed from
|
|||
|
|
* the queue. Returns 0 if the event was not handled, meaning it should
|
|||
|
|
* stay on the queue. The only time the event isn't handled is if the
|
|||
|
|
* TCL_FILE_EVENTS flag bit isn't set.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Whatever the file handler's callback procedure does.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static int
|
|||
|
|
FileHandlerEventProc(
|
|||
|
|
Tcl_Event *evPtr, /* Event to service. */
|
|||
|
|
int flags) /* Flags that indicate what events to handle,
|
|||
|
|
* such as TCL_FILE_EVENTS. */
|
|||
|
|
{
|
|||
|
|
FileHandler *filePtr;
|
|||
|
|
FileHandlerEvent *fileEvPtr = (FileHandlerEvent *) evPtr;
|
|||
|
|
int mask;
|
|||
|
|
|
|||
|
|
if (!(flags & TCL_FILE_EVENTS)) {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Search through the file handlers to find the one whose handle matches
|
|||
|
|
* the event. We do this rather than keeping a pointer to the file handler
|
|||
|
|
* directly in the event, so that the handler can be deleted while the
|
|||
|
|
* event is queued without leaving a dangling pointer.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
|
|||
|
|
filePtr = filePtr->nextPtr) {
|
|||
|
|
if (filePtr->fd != fileEvPtr->fd) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* The code is tricky for two reasons:
|
|||
|
|
* 1. The file handler's desired events could have changed since the
|
|||
|
|
* time when the event was queued, so AND the ready mask with the
|
|||
|
|
* desired mask.
|
|||
|
|
* 2. The file could have been closed and re-opened since the time
|
|||
|
|
* when the event was queued. This is why the ready mask is stored
|
|||
|
|
* in the file handler rather than the queued event: it will be
|
|||
|
|
* zeroed when a new file handler is created for the newly opened
|
|||
|
|
* file.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
mask = filePtr->readyMask & filePtr->mask;
|
|||
|
|
filePtr->readyMask = 0;
|
|||
|
|
if (mask != 0) {
|
|||
|
|
filePtr->proc(filePtr->clientData, mask);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* 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 without blocking.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Returns 1 if an event was found, else 0. This ensures that
|
|||
|
|
* Tcl_DoOneEvent will return 1, even if the event is handled by non-Tcl
|
|||
|
|
* code.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Queues file events that are detected by the select.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static int
|
|||
|
|
WaitForEvent(
|
|||
|
|
const Tcl_Time *timePtr) /* Maximum block time, or NULL. */
|
|||
|
|
{
|
|||
|
|
int timeout;
|
|||
|
|
|
|||
|
|
if (!initialized) {
|
|||
|
|
InitNotifier();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TclSetAppContext(NULL);
|
|||
|
|
|
|||
|
|
if (timePtr) {
|
|||
|
|
timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
|
|||
|
|
if (timeout == 0) {
|
|||
|
|
if (XtAppPending(notifier.appContext)) {
|
|||
|
|
goto process;
|
|||
|
|
} else {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
Tcl_SetTimer(timePtr);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
process:
|
|||
|
|
XtAppProcessEvent(notifier.appContext, XtIMAll);
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Local Variables:
|
|||
|
|
* mode: c
|
|||
|
|
* c-basic-offset: 4
|
|||
|
|
* fill-column: 78
|
|||
|
|
* End:
|
|||
|
|
*/
|