static int
rcClose (ClientData cd_, Tcl_Interp* interp)
{
ReflectingChannel* chan = (ReflectingChannel*) cd_;
int n = -1;
Tcl_SavedResult sr;
Tcl_Obj* cmd = rcBuildCmdList(chan, Tcl_NewStringObj("close", -1));
Tcl_Interp* ip = chan->_interp;
Tcl_SaveResult(ip, &sr);
if (Tcl_EvalObjEx(ip, cmd, TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT) == TCL_OK)
Tcl_GetIntFromObj(NULL, Tcl_GetObjResult(ip), &n);
Tcl_RestoreResult(ip, &sr);
Tcl_DecrRefCount(cmd);
if (chan->_timer != NULL) {
Tcl_DeleteTimerHandler(chan->_timer);
chan->_timer = NULL;
}
Tcl_DecrRefCount(chan->_context);
Tcl_DecrRefCount(chan->_seek);
Tcl_DecrRefCount(chan->_read);
Tcl_DecrRefCount(chan->_write);
Tcl_DecrRefCount(chan->_name);
Tcl_Free((char*) chan);
return TCL_OK;
}
static int
TransformCloseProc(
ClientData instanceData,
Tcl_Interp *interp)
{
TransformChannelData *dataPtr = instanceData;
/*
* Important: In this procedure 'dataPtr->self' already points to the
* underlying channel.
*
* There is no need to cancel an existing channel handler, this is already
* done. Either by 'Tcl_UnstackChannel' or by the general cleanup in
* 'Tcl_Close'.
*
* But we have to cancel an active timer to prevent it from firing on the
* removed channel.
*/
if (dataPtr->timer != NULL) {
Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = NULL;
}
/*
* Now flush data waiting in internal buffers to output and input. The
* input must be done despite the fact that there is no real receiver for
* it anymore. But the scripts might have sideeffects other parts of the
* system rely on (f.e. signaling the close to interested parties).
*/
if (dataPtr->mode & TCL_WRITABLE) {
ExecuteCallback(dataPtr, interp, A_FLUSH_WRITE, NULL, 0,
TRANSMIT_DOWN, P_PRESERVE);
}
if ((dataPtr->mode & TCL_READABLE) && !dataPtr->readIsFlushed) {
dataPtr->readIsFlushed = 1;
ExecuteCallback(dataPtr, interp, A_FLUSH_READ, NULL, 0, TRANSMIT_IBUF,
P_PRESERVE);
}
if (dataPtr->mode & TCL_WRITABLE) {
ExecuteCallback(dataPtr, interp, A_DELETE_WRITE, NULL, 0,
TRANSMIT_DONT, P_PRESERVE);
}
if (dataPtr->mode & TCL_READABLE) {
ExecuteCallback(dataPtr, interp, A_DELETE_READ, NULL, 0,
TRANSMIT_DONT, P_PRESERVE);
}
/*
* General cleanup.
*/
ResultClear(&dataPtr->result);
Tcl_DecrRefCount(dataPtr->command);
ckfree((char *) dataPtr);
return TCL_OK;
}
static int
TransformNotifyProc(
ClientData clientData, /* The state of the notified
* transformation. */
int mask) /* The mask of occuring events. */
{
TransformChannelData *dataPtr = clientData;
/*
* An event occured in the underlying channel. This transformation doesn't
* process such events thus returns the incoming mask unchanged.
*/
if (dataPtr->timer != NULL) {
/*
* Delete an existing timer. It was not fired, yet we are here, so the
* channel below generated such an event and we don't have to. The
* renewal of the interest after the execution of channel handlers
* will eventually cause us to recreate the timer (in
* TransformWatchProc).
*/
Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = NULL;
}
return mask;
}
/* ARGSUSED */
static void
TransformWatchProc(
ClientData instanceData, /* Channel to watch. */
int mask) /* Events of interest. */
{
TransformChannelData *dataPtr = instanceData;
Tcl_Channel downChan;
/*
* The caller expressed interest in events occuring for this channel. We
* are forwarding the call to the underlying channel now.
*/
dataPtr->watchMask = mask;
/*
* No channel handlers any more. We will be notified automatically about
* events on the channel below via a call to our 'TransformNotifyProc'.
* But we have to pass the interest down now. We are allowed to add
* additional 'interest' to the mask if we want to. But this
* transformation has no such interest. It just passes the request down,
* unchanged.
*/
if (dataPtr->self == NULL) {
return;
}
downChan = Tcl_GetStackedChannel(dataPtr->self);
Tcl_GetChannelType(downChan)->watchProc(
Tcl_GetChannelInstanceData(downChan), mask);
/*
* Management of the internal timer.
*/
if ((dataPtr->timer != NULL) &&
(!(mask & TCL_READABLE) || ResultEmpty(&dataPtr->result))) {
/*
* A pending timer exists, but either is there no (more) interest in
* the events it generates or nothing is available for reading, so
* remove it.
*/
Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = NULL;
}
if ((dataPtr->timer == NULL) && (mask & TCL_READABLE)
&& !ResultEmpty(&dataPtr->result)) {
/*
* There is no pending timer, but there is interest in readable events
* and we actually have data waiting, so generate a timer to flush
* that.
*/
dataPtr->timer = Tcl_CreateTimerHandler(FLUSH_DELAY,
TransformChannelHandlerTimer, dataPtr);
}
}
void DBus_RemoveTimeout(DBusTimeout *timeout, void *data)
{
Tcl_TimerToken token;
token = dbus_timeout_get_data(timeout);
Tcl_DeleteTimerHandler(token);
}
void
TkWinCancelMouseTimer(void)
{
if (mouseTimerSet) {
Tcl_DeleteTimerHandler(mouseTimer);
mouseTimerSet = 0;
}
}
/* CursorManagerDeleteProc --
* InterpDeleteProc for cursor manager.
*/
static void CursorManagerDeleteProc(ClientData clientData, Tcl_Interp *interp)
{
CursorManager *cm = (CursorManager*)clientData;
if (cm->timer) {
Tcl_DeleteTimerHandler(cm->timer);
}
ckfree(clientData);
}
void
TkpDestroyButton(
TkButton *butPtr)
{
MacButton *mbPtr = (MacButton *) butPtr; /* Mac button. */
if (mbPtr->defaultPulseHandler) {
Tcl_DeleteTimerHandler(mbPtr->defaultPulseHandler);
}
}
static void
rcTimerProc (ClientData cd_)
{
ReflectingChannel* chan = (ReflectingChannel*) cd_;
if (chan->_timer != NULL)
Tcl_DeleteTimerHandler(chan->_timer);
chan->_timer = NULL;
Tcl_NotifyChannel(chan->_chan, chan->_watchMask);
}
static void timer_call(ClientData data) {
struct timer_handler * const timer = (struct timer_handler *) data;
struct timer_handler **ptr;
Tcl_DeleteTimerHandler(timer->token);
for (ptr = &list; timer != *ptr; ptr = &(*ptr)->next) ;
*ptr = timer->next;
/* BUG: What if !OOP_CONTINUE? */
timer->f(oop_signal_source(sig),timer->t,timer->d);
oop_free(timer);
}
static void cancel_time(oop_source *x,struct timeval t,oop_call_time *f,void *d) {
struct timer_handler **timer;
for (timer = &list; NULL != *timer; timer = &(*timer)->next)
if ((*timer)->d == d && (*timer)->f == f
&& (*timer)->t.tv_sec == t.tv_sec
&& (*timer)->t.tv_usec == t.tv_usec) {
struct timer_handler *dead = *timer;
*timer = dead->next;
Tcl_DeleteTimerHandler(dead->token);
oop_free(dead);
return;
}
}
value caml_Tcl_DeleteTimerHandler(value descriptor) {
timerhandler *h;
CAMLparam1(descriptor);
h = (timerhandler *) descriptor;
Tcl_DeleteTimerHandler(h->token);
remove_global_root(&(h->callback_fn));
free(h);
CAMLreturn(Val_int(0));
}
/* LoseCursor --
* Turn cursor off, disable blink timer.
*/
static void LoseCursor(CursorManager *cm, WidgetCore *corePtr)
{
if (corePtr->flags & CURSOR_ON) {
corePtr->flags &= ~CURSOR_ON;
TtkRedisplayWidget(corePtr);
}
if (cm->owner == corePtr) {
cm->owner = NULL;
}
if (cm->timer) {
Tcl_DeleteTimerHandler(cm->timer);
cm->timer = 0;
}
}
static void
rcWatchChannel (ClientData cd_, int mask)
{
ReflectingChannel* chan = (ReflectingChannel*) cd_;
/* Dec 2001: adopting logic used in Andreas Kupries' memchan, i.e. timers */
if (mask) {
chan->_watchMask = mask & chan->_validMask;
if (chan->_watchMask && chan->_timer == NULL)
chan->_timer = Tcl_CreateTimerHandler(5, rcTimerProc, cd_);
} else if (chan->_timer != NULL) {
Tcl_DeleteTimerHandler(chan->_timer);
chan->_timer = NULL;
}
}
/* ARGSUSED */
static void
AfterCleanupProc(
ClientData clientData, /* Points to AfterAssocData for the
* interpreter. */
Tcl_Interp *interp) /* Interpreter that is being deleted. */
{
AfterAssocData *assocPtr = clientData;
AfterInfo *afterPtr;
while (assocPtr->firstAfterPtr != NULL) {
afterPtr = assocPtr->firstAfterPtr;
assocPtr->firstAfterPtr = afterPtr->nextPtr;
if (afterPtr->token != NULL) {
Tcl_DeleteTimerHandler(afterPtr->token);
} else {
Tcl_CancelIdleCall(AfterProc, afterPtr);
}
Tcl_DecrRefCount(afterPtr->commandPtr);
ckfree(afterPtr);
}
ckfree(assocPtr);
}
void
TnmSnmpDeleteSession(TnmSnmp *session)
{
TnmSnmpRequest **rPtrPtr;
if (! session) return;
rPtrPtr = &queueHead;
while (*rPtrPtr) {
if ((*rPtrPtr)->session == session) {
TnmSnmpRequest *request = *rPtrPtr;
*rPtrPtr = (*rPtrPtr)->nextPtr;
if (request->timer) {
Tcl_DeleteTimerHandler(request->timer);
}
Tcl_EventuallyFree((ClientData) request, RequestDestroyProc);
} else {
rPtrPtr = &(*rPtrPtr)->nextPtr;
}
}
Tcl_EventuallyFree((ClientData) session, SessionDestroyProc);
}
void
TnmSnmpDeleteRequest(TnmSnmpRequest *request)
{
TnmSnmpRequest *rPtr, **rPtrPtr;
TnmSnmp *session;
/*
* Check whether the request still exists. It may have been
* removed because the session for this request has been
* destroyed during callback processing.
*/
for (rPtr = queueHead; rPtr; rPtr = rPtr->nextPtr) {
if (rPtr == request) break;
}
if (! rPtr) return;
/*
* Check whether the session is still in the session list.
* We sometimes get called when the session has already been
* destroyed as a side effect of evaluating callbacks.
*/
for (session = tnmSnmpList; session; session = session->nextPtr) {
if (session == request->session) break;
}
if (session) {
if (request->sends) {
session->active--;
} else {
session->waiting--;
}
}
/*
* Remove the request from the list of outstanding requests.
* and free the resources allocated for this request.
*/
rPtrPtr = &queueHead;
while (*rPtrPtr && *rPtrPtr != request) {
rPtrPtr = &(*rPtrPtr)->nextPtr;
}
if (*rPtrPtr) {
*rPtrPtr = request->nextPtr;
if (request->timer) {
Tcl_DeleteTimerHandler(request->timer);
request->timer = NULL;
}
Tcl_EventuallyFree((ClientData) request, RequestDestroyProc);
}
/*
* Update the request queue. This will activate async requests
* that have been queued because of the window size.
*/
if (session) {
TnmSnmpQueueRequest(session, NULL);
}
}
static void
TkMacOSXComputeButtonParams(
TkButton * butPtr,
ThemeButtonKind* btnkind,
HIThemeButtonDrawInfo *drawinfo)
{
MacButton *mbPtr = (MacButton *)butPtr;
if (butPtr->borderWidth <= 2) {
*btnkind = kThemeSmallBevelButton;
} else if (butPtr->borderWidth == 3) {
*btnkind = kThemeBevelButton;
} else if (butPtr->borderWidth == 4) {
*btnkind = kThemeRoundedBevelButton;
} else {
*btnkind = kThemePushButton;
}
if ((butPtr->image == None) && (butPtr->bitmap == None)) {
switch (butPtr->type) {
case TYPE_BUTTON:
*btnkind = kThemePushButton;
break;
case TYPE_RADIO_BUTTON:
if (butPtr->borderWidth <= 1) {
*btnkind = kThemeSmallRadioButton;
} else {
*btnkind = kThemeRadioButton;
}
break;
case TYPE_CHECK_BUTTON:
if (butPtr->borderWidth <= 1) {
*btnkind = kThemeSmallCheckBox;
} else {
*btnkind = kThemeCheckBox;
}
break;
}
}
if (butPtr->indicatorOn) {
switch (butPtr->type) {
case TYPE_RADIO_BUTTON:
if (butPtr->borderWidth <= 1) {
*btnkind = kThemeSmallRadioButton;
} else {
*btnkind = kThemeRadioButton;
}
break;
case TYPE_CHECK_BUTTON:
if (butPtr->borderWidth <= 1) {
*btnkind = kThemeSmallCheckBox;
} else {
*btnkind = kThemeCheckBox;
}
break;
}
} else {
if (butPtr->type == TYPE_RADIO_BUTTON ||
butPtr->type == TYPE_CHECK_BUTTON
) {
if (*btnkind == kThemePushButton) {
*btnkind = kThemeBevelButton;
}
}
}
if (butPtr->flags & SELECTED) {
drawinfo->value = kThemeButtonOn;
} else if (butPtr->flags & TRISTATED) {
drawinfo->value = kThemeButtonMixed;
} else {
drawinfo->value = kThemeButtonOff;
}
if ((mbPtr->flags & FIRST_DRAW) != 0) {
mbPtr->flags &= ~FIRST_DRAW;
if (Tk_MacOSXIsAppInFront()) {
mbPtr->flags |= ACTIVE;
}
}
drawinfo->state = kThemeStateInactive;
if ((mbPtr->flags & ACTIVE) == 0) {
if (butPtr->state == STATE_DISABLED) {
drawinfo->state = kThemeStateUnavailableInactive;
} else {
drawinfo->state = kThemeStateInactive;
}
} else if (butPtr->state == STATE_DISABLED) {
drawinfo->state = kThemeStateUnavailable;
} else if (butPtr->state == STATE_ACTIVE) {
drawinfo->state = kThemeStatePressed;
} else {
drawinfo->state = kThemeStateActive;
}
drawinfo->adornment = kThemeAdornmentNone;
if (butPtr->defaultState == DEFAULT_ACTIVE) {
drawinfo->adornment |= kThemeAdornmentDefault;
if (!mbPtr->defaultPulseHandler) {
mbPtr->defaultPulseHandler = Tcl_CreateTimerHandler(
PULSE_TIMER_MSECS, PulseDefaultButtonProc,
(ClientData) butPtr);
}
} else if (mbPtr->defaultPulseHandler) {
Tcl_DeleteTimerHandler(mbPtr->defaultPulseHandler);
}
if (butPtr->highlightWidth >= 3) {
if ((butPtr->flags & GOT_FOCUS)) {
drawinfo->adornment |= kThemeAdornmentFocus;
}
}
}
CAMLprim value camltk_rem_timer(value token)
{
Tcl_DeleteTimerHandler((Tcl_TimerToken) Long_val(token));
return Val_unit;
}
/* ARGSUSED */
int
Tcl_AfterObjCmd(
ClientData clientData, /* Unused */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument objects. */
{
Tcl_WideInt ms = 0; /* Number of milliseconds to wait */
Tcl_Time wakeup;
AfterInfo *afterPtr;
AfterAssocData *assocPtr;
int length;
int index;
static const char *const afterSubCmds[] = {
"cancel", "idle", "info", NULL
};
enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
ThreadSpecificData *tsdPtr = InitTimer();
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "option ?arg ...?");
return TCL_ERROR;
}
/*
* Create the "after" information associated for this interpreter, if it
* doesn't already exist.
*/
assocPtr = Tcl_GetAssocData(interp, "tclAfter", NULL);
if (assocPtr == NULL) {
assocPtr = ckalloc(sizeof(AfterAssocData));
assocPtr->interp = interp;
assocPtr->firstAfterPtr = NULL;
Tcl_SetAssocData(interp, "tclAfter", AfterCleanupProc, assocPtr);
}
/*
* First lets see if the command was passed a number as the first argument.
*/
if (objv[1]->typePtr == &tclIntType
#ifndef TCL_WIDE_INT_IS_LONG
|| objv[1]->typePtr == &tclWideIntType
#endif
|| objv[1]->typePtr == &tclBignumType
|| (Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0,
&index) != TCL_OK)) {
index = -1;
if (Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK) {
const char *arg = Tcl_GetString(objv[1]);
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"bad argument \"%s\": must be"
" cancel, idle, info, or an integer", arg));
Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "INDEX", "argument",
arg, NULL);
return TCL_ERROR;
}
}
/*
* At this point, either index = -1 and ms contains the number of ms
* to wait, or else index is the index of a subcommand.
*/
switch (index) {
case -1: {
if (ms < 0) {
ms = 0;
}
if (objc == 2) {
return AfterDelay(interp, ms);
}
afterPtr = ckalloc(sizeof(AfterInfo));
afterPtr->assocPtr = assocPtr;
if (objc == 3) {
afterPtr->commandPtr = objv[2];
} else {
afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
}
Tcl_IncrRefCount(afterPtr->commandPtr);
/*
* The variable below is used to generate unique identifiers for after
* commands. This id can wrap around, which can potentially cause
* problems. However, there are not likely to be problems in practice,
* because after commands can only be requested to about a month in
* the future, and wrap-around is unlikely to occur in less than about
* 1-10 years. Thus it's unlikely that any old ids will still be
* around when wrap-around occurs.
*/
afterPtr->id = tsdPtr->afterId;
tsdPtr->afterId += 1;
Tcl_GetTime(&wakeup);
wakeup.sec += (long)(ms / 1000);
wakeup.usec += ((long)(ms % 1000)) * 1000;
if (wakeup.usec > 1000000) {
wakeup.sec++;
wakeup.usec -= 1000000;
}
afterPtr->token = TclCreateAbsoluteTimerHandler(&wakeup,
AfterProc, afterPtr);
afterPtr->nextPtr = assocPtr->firstAfterPtr;
assocPtr->firstAfterPtr = afterPtr;
Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
return TCL_OK;
}
case AFTER_CANCEL: {
Tcl_Obj *commandPtr;
const char *command, *tempCommand;
int tempLength;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 2, objv, "id|command");
return TCL_ERROR;
}
if (objc == 3) {
commandPtr = objv[2];
} else {
commandPtr = Tcl_ConcatObj(objc-2, objv+2);;
}
command = TclGetStringFromObj(commandPtr, &length);
for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
afterPtr = afterPtr->nextPtr) {
tempCommand = TclGetStringFromObj(afterPtr->commandPtr,
&tempLength);
if ((length == tempLength)
&& !memcmp(command, tempCommand, (unsigned) length)) {
break;
}
}
if (afterPtr == NULL) {
afterPtr = GetAfterEvent(assocPtr, commandPtr);
}
if (objc != 3) {
Tcl_DecrRefCount(commandPtr);
}
if (afterPtr != NULL) {
if (afterPtr->token != NULL) {
Tcl_DeleteTimerHandler(afterPtr->token);
} else {
Tcl_CancelIdleCall(AfterProc, afterPtr);
}
FreeAfterPtr(afterPtr);
}
break;
}
case AFTER_IDLE:
if (objc < 3) {
Tcl_WrongNumArgs(interp, 2, objv, "script ?script ...?");
return TCL_ERROR;
}
afterPtr = ckalloc(sizeof(AfterInfo));
afterPtr->assocPtr = assocPtr;
if (objc == 3) {
afterPtr->commandPtr = objv[2];
} else {
afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
}
Tcl_IncrRefCount(afterPtr->commandPtr);
afterPtr->id = tsdPtr->afterId;
tsdPtr->afterId += 1;
afterPtr->token = NULL;
afterPtr->nextPtr = assocPtr->firstAfterPtr;
assocPtr->firstAfterPtr = afterPtr;
Tcl_DoWhenIdle(AfterProc, afterPtr);
Tcl_SetObjResult(interp, Tcl_ObjPrintf("after#%d", afterPtr->id));
break;
case AFTER_INFO:
if (objc == 2) {
Tcl_Obj *resultObj = Tcl_NewObj();
for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
afterPtr = afterPtr->nextPtr) {
if (assocPtr->interp == interp) {
Tcl_ListObjAppendElement(NULL, resultObj, Tcl_ObjPrintf(
"after#%d", afterPtr->id));
}
}
Tcl_SetObjResult(interp, resultObj);
return TCL_OK;
}
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "?id?");
return TCL_ERROR;
}
afterPtr = GetAfterEvent(assocPtr, objv[2]);
if (afterPtr == NULL) {
const char *eventStr = TclGetString(objv[2]);
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"event \"%s\" doesn't exist", eventStr));
Tcl_SetErrorCode(interp, "TCL","LOOKUP","EVENT", eventStr, NULL);
return TCL_ERROR;
} else {
Tcl_Obj *resultListPtr = Tcl_NewObj();
Tcl_ListObjAppendElement(interp, resultListPtr,
afterPtr->commandPtr);
Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
(afterPtr->token == NULL) ? "idle" : "timer", -1));
Tcl_SetObjResult(interp, resultListPtr);
}
break;
default:
Tcl_Panic("Tcl_AfterObjCmd: bad subcommand index to afterSubCmds");
}
return TCL_OK;
}
static void
TlsWatchProc(ClientData instanceData, /* The socket state. */
int mask) /* Events of interest; an OR-ed
* combination of TCL_READABLE,
* TCL_WRITABLE and TCL_EXCEPTION. */
{
State *statePtr = (State *) instanceData;
dprintf(stderr, "TlsWatchProc(0x%x)\n", mask);
/* Pretend to be dead as long as the verify callback is running.
* Otherwise that callback could be invoked recursively. */
if (statePtr->flags & TLS_TCL_CALLBACK) { return; }
if (channelTypeVersion == TLS_CHANNEL_VERSION_2) {
Tcl_Channel downChan;
statePtr->watchMask = mask;
/* No channel handlers any more. We will be notified automatically
* about events on the channel below via a call to our
* 'TransformNotifyProc'. But we have to pass the interest down now.
* We are allowed to add additional 'interest' to the mask if we want
* to. But this transformation has no such interest. It just passes
* the request down, unchanged.
*/
downChan = Tls_GetParent(statePtr);
(Tcl_GetChannelType(downChan))
->watchProc(Tcl_GetChannelInstanceData(downChan), mask);
/*
* Management of the internal timer.
*/
if (statePtr->timer != (Tcl_TimerToken) NULL) {
Tcl_DeleteTimerHandler(statePtr->timer);
statePtr->timer = (Tcl_TimerToken) NULL;
}
if ((mask & TCL_READABLE) && Tcl_InputBuffered(statePtr->self) > 0) {
/*
* There is interest in readable events and we actually have
* data waiting, so generate a timer to flush that.
*/
statePtr->timer = Tcl_CreateTimerHandler(TLS_TCL_DELAY,
TlsChannelHandlerTimer, (ClientData) statePtr);
}
} else {
if (mask == statePtr->watchMask)
return;
if (statePtr->watchMask) {
/*
* Remove event handler to underlying channel, this could
* be because we are closing for real, or being "unstacked".
*/
Tcl_DeleteChannelHandler(Tls_GetParent(statePtr),
TlsChannelHandler, (ClientData) statePtr);
}
statePtr->watchMask = mask;
if (statePtr->watchMask) {
/*
* Setup active monitor for events on underlying Channel.
*/
Tcl_CreateChannelHandler(Tls_GetParent(statePtr),
statePtr->watchMask, TlsChannelHandler,
(ClientData) statePtr);
}
}
}
