static int MenuButtonWidgetObjCmd( ClientData clientData, /* Information about button widget. */ Tcl_Interp *interp, /* Current interpreter. */ int objc, /* Number of arguments. */ Tcl_Obj *const objv[]) /* Argument objects. */ { register TkMenuButton *mbPtr = clientData; int result, index; Tcl_Obj *objPtr; if (objc < 2) { Tcl_WrongNumArgs(interp, 1, objv, "option ?arg ...?"); return TCL_ERROR; } result = Tcl_GetIndexFromObj(interp, objv[1], commandNames, "option", 0, &index); if (result != TCL_OK) { return result; } Tcl_Preserve(mbPtr); switch (index) { case COMMAND_CGET: if (objc != 3) { Tcl_WrongNumArgs(interp, 1, objv, "cget option"); goto error; } objPtr = Tk_GetOptionValue(interp, (char *) mbPtr, mbPtr->optionTable, objv[2], mbPtr->tkwin); if (objPtr == NULL) { goto error; } Tcl_SetObjResult(interp, objPtr); break; case COMMAND_CONFIGURE: if (objc <= 3) { objPtr = Tk_GetOptionInfo(interp, (char *) mbPtr, mbPtr->optionTable, (objc == 3) ? objv[2] : NULL, mbPtr->tkwin); if (objPtr == NULL) { goto error; } Tcl_SetObjResult(interp, objPtr); } else { result = ConfigureMenuButton(interp, mbPtr, objc-2, objv+2); } break; } Tcl_Release(mbPtr); return result; error: Tcl_Release(mbPtr); return TCL_ERROR; }
static void LostSelection( ClientData clientData) /* Pointer to LostCommand structure. */ { LostCommand *lostPtr = clientData; Tcl_Interp *interp = lostPtr->interp; Tcl_InterpState savedState; int code; Tcl_Preserve(interp); /* * Execute the command. Save the interpreter's result, if any, and restore * it after executing the command. */ savedState = Tcl_SaveInterpState(interp, TCL_OK); Tcl_ResetResult(interp); code = Tcl_EvalObjEx(interp, lostPtr->cmdObj, TCL_EVAL_GLOBAL); if (code != TCL_OK) { Tcl_BackgroundException(interp, code); } (void) Tcl_RestoreInterpState(interp, savedState); /* * Free the storage for the command, since we're done with it now. */ Tcl_DecrRefCount(lostPtr->cmdObj); ckfree(lostPtr); Tcl_Release(interp); }
static void DeleteImage( ImageMaster *masterPtr) /* Pointer to main data structure for image. */ { Image *imagePtr; Tk_ImageType *typePtr; typePtr = masterPtr->typePtr; masterPtr->typePtr = NULL; if (typePtr != NULL) { for (imagePtr = masterPtr->instancePtr; imagePtr != NULL; imagePtr = imagePtr->nextPtr) { typePtr->freeProc(imagePtr->instanceData, imagePtr->display); imagePtr->changeProc(imagePtr->widgetClientData, 0, 0, masterPtr->width, masterPtr->height, masterPtr->width, masterPtr->height); } typePtr->deleteProc(masterPtr->masterData); } if (masterPtr->instancePtr == NULL) { if (masterPtr->hPtr != NULL) { Tcl_DeleteHashEntry(masterPtr->hPtr); } Tcl_Release(masterPtr->winPtr); ckfree(masterPtr); } else { masterPtr->deleted = 1; } }
static void plustot_env_evalfile(t_plustot_env *x, t_symbol *fname) { char buf1[MAXPDSTRING], buf2[MAXPDSTRING], *nameptr, *dir; int fd; dir = canvas_getdir(x->x_glist)->s_name; if ((fd = open_via_path(dir, fname->s_name, "", buf1, &nameptr, MAXPDSTRING, 0)) < 0) { loud_error((t_pd *)x, "file '%s' not found", fname->s_name); } else { Tcl_Interp *interp = plustin_getinterp(x->x_tin); FILE *fp; close(fd); strcpy(buf2, buf1); strcat(buf2, "/"); strcat(buf2, nameptr); sys_bashfilename(buf2, buf2); Tcl_Preserve(interp); if (Tcl_EvalFile(interp, buf2) != TCL_OK) { strcpy(buf1, "evaluation failed ("); strncat(buf1, buf2, MAXPDSTRING - strlen(buf1) - 2); strcat(buf1, ")"); plusloud_tclerror((t_pd *)x, interp, buf1); } Tcl_Release(interp); } }
static int InterpreterObjCmd( ClientData clientData, /* */ Tcl_Interp *interp, /* Current interpreter */ int objc, /* Number of arguments */ Tcl_Obj *const objv[]) /* Argument objects */ { int index, result = TCL_OK; static const char *const options[] = {"eval", "record", NULL}; enum option {OTHER_EVAL, OTHER_RECORD}; ConsoleInfo *info = clientData; Tcl_Interp *otherInterp = info->interp; if (objc < 2) { Tcl_WrongNumArgs(interp, 1, objv, "option arg"); return TCL_ERROR; } if (Tcl_GetIndexFromObj(interp, objv[1], options, "option", 0, &index) != TCL_OK) { return TCL_ERROR; } if (objc != 3) { Tcl_WrongNumArgs(interp, 2, objv, "script"); return TCL_ERROR; } if ((otherInterp == NULL) || Tcl_InterpDeleted(otherInterp)) { Tcl_AppendResult(interp, "no active master interp", NULL); return TCL_ERROR; } Tcl_Preserve(otherInterp); switch ((enum option) index) { case OTHER_EVAL: result = Tcl_GlobalEvalObj(otherInterp, objv[2]); /* * TODO: Should exceptions be filtered here? */ Tcl_SetReturnOptions(interp, Tcl_GetReturnOptions(otherInterp, result)); Tcl_SetObjResult(interp, Tcl_GetObjResult(otherInterp)); break; case OTHER_RECORD: Tcl_RecordAndEvalObj(otherInterp, objv[2], TCL_EVAL_GLOBAL); /* * By not setting result, we discard any exceptions or errors here and * always return TCL_OK. All the caller wants is the interp result to * display, whether that's result or error message. */ Tcl_SetObjResult(interp, Tcl_GetObjResult(otherInterp)); break; } Tcl_Release(otherInterp); return result; }
static void IvyDirectMsgCB(IvyClientPtr app, void *user_data, int id, char *msg) { filter_struct *filter = (filter_struct *) user_data; int result, size; char *script_to_call; char int_buffer[INTEGER_SPACE]; sprintf(int_buffer, "%d", id); size = strlen(filter->script) + 1; size += strlen(int_buffer) + 1; size += strlen(msg) + 1; script_to_call = ckalloc(size); strcpy(script_to_call, filter->script); strcat(script_to_call, " "); strcat(script_to_call, int_buffer); strcat(script_to_call, " \""); strcat(script_to_call, msg); strcat(script_to_call, "\""); Tcl_Preserve(filter->interp); result = Tcl_GlobalEval(filter->interp, script_to_call); ckfree(script_to_call); if (result != TCL_OK) { Tcl_BackgroundError(filter->interp); } Tcl_Release(filter->interp); }
static void CmdDeleteProc( ClientData clientData) { RegisteredInterp *riPtr = (RegisteredInterp *)clientData; /* * Lock the package structure in memory. */ Tcl_Preserve(clientData); /* * Revoke the ROT registration. */ RevokeObjectRegistration(riPtr); /* * Release the registration object. */ riPtr->obj->lpVtbl->Release(riPtr->obj); riPtr->obj = NULL; Tcl_DeleteAssocData(riPtr->interp, "tkWinSend::ri"); /* * Unlock the package data structure. */ Tcl_Release(clientData); ckfree(clientData); }
static void IvyDieCB(IvyClientPtr app, void *user_data, /* script a appeler */ int id) { filter_struct *filter = (filter_struct *) user_data; int result, size; char idstr[INTEGER_SPACE]; char *script_to_call; sprintf(idstr, "%d", id); size = strlen(filter->script) + INTEGER_SPACE + 1; script_to_call = ckalloc(size); strcpy(script_to_call, filter->script); strcat(script_to_call, " \""); strcat(script_to_call, idstr); strcat(script_to_call, "\""); Tcl_Preserve(filter->interp); result = Tcl_GlobalEval(filter->interp, script_to_call); ckfree(script_to_call); if (result != TCL_OK) { Tcl_BackgroundError(filter->interp); } Tcl_Release(filter->interp); }
void TkWmProtocolEventProc( TkWindow *winPtr, /* Window to which the event was sent. */ XEvent *eventPtr) /* X event. */ { WmInfo *wmPtr; ProtocolHandler *protPtr; Tcl_Interp *interp; Atom protocol; int result; wmPtr = winPtr->wmInfoPtr; if (wmPtr == NULL) { return; } protocol = (Atom) eventPtr->xclient.data.l[0]; for (protPtr = wmPtr->protPtr; protPtr != NULL; protPtr = protPtr->nextPtr) { if (protocol == protPtr->protocol) { Tcl_Preserve(protPtr); interp = protPtr->interp; Tcl_Preserve(interp); result = Tcl_EvalEx(interp, protPtr->command, -1, TCL_EVAL_GLOBAL); if (result != TCL_OK) { Tcl_AddErrorInfo(interp, "\n (command for \""); Tcl_AddErrorInfo(interp, Tk_GetAtomName((Tk_Window) winPtr, protocol)); Tcl_AddErrorInfo(interp, "\" window manager protocol)"); Tcl_BackgroundError(interp); } Tcl_Release(interp); Tcl_Release(protPtr); return; } } /* * No handler was present for this protocol. If this is a WM_DELETE_WINDOW * message then just destroy the window. */ if (protocol == Tk_InternAtom((Tk_Window) winPtr, "WM_DELETE_WINDOW")) { Tk_DestroyWindow((Tk_Window) winPtr); } }
static void IvyAppCB(IvyClientPtr app, void *user_data, /* script a appeler */ IvyApplicationEvent event) { static const char *app_event_str[] = { "Connected", "Disconnected" }; filter_struct *filter = (filter_struct *) user_data; int result, size, dummy; char *script_to_call; Tcl_HashEntry *entry; entry = Tcl_FindHashEntry(&app_table, IvyGetApplicationName(app)); if (event == IvyApplicationConnected) { if (!entry) { entry = Tcl_CreateHashEntry(&app_table, IvyGetApplicationName(app), &dummy); Tcl_SetHashValue(entry, (ClientData) app); } } size = strlen(filter->script) + INTEGER_SPACE; if (entry) { size += strlen(IvyGetApplicationName(app)) + 3; } else { size += 4; } script_to_call = ckalloc(size); strcpy(script_to_call, filter->script); strcat(script_to_call, " "); if (entry) { strcat(script_to_call, " \""); strcat(script_to_call, IvyGetApplicationName(app)); strcat(script_to_call, "\""); } else { strcat(script_to_call, "???"); } strcat(script_to_call, " \""); strcat(script_to_call, app_event_str[event%2]); strcat(script_to_call, "\""); Tcl_Preserve(filter->interp); result = Tcl_GlobalEval(filter->interp, script_to_call); ckfree(script_to_call); if (result != TCL_OK) { Tcl_BackgroundError(filter->interp); } Tcl_Release(filter->interp); if (event == IvyApplicationDisconnected) { if (entry) { Tcl_DeleteHashEntry(entry); } } }
static int PreprocessMenu( TkMenu *menuPtr) { int index, result, finished; ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); Tcl_Preserve((ClientData) menuPtr); /* * First, let's process the post command on ourselves. If this command * destroys this menu, or if there was an error, we are done. */ result = TkPostCommand(menuPtr); if ((result != TCL_OK) || (menuPtr->tkwin == NULL)) { goto done; } /* * Now, we go through structure and process all of the commands. Since the * structure is changing, we stop after we do one command, and start over. * When we get through without doing any, we are done. */ do { finished = 1; for (index = 0; index < menuPtr->numEntries; index++) { register TkMenuEntry *entryPtr = menuPtr->entries[index]; if ((entryPtr->type == CASCADE_ENTRY) && (entryPtr->namePtr != NULL) && (entryPtr->childMenuRefPtr != NULL) && (entryPtr->childMenuRefPtr->menuPtr != NULL)) { TkMenu *cascadeMenuPtr = entryPtr->childMenuRefPtr->menuPtr; if (cascadeMenuPtr->postCommandGeneration != tsdPtr->postCommandGeneration) { cascadeMenuPtr->postCommandGeneration = tsdPtr->postCommandGeneration; result = PreprocessMenu(cascadeMenuPtr); if (result != TCL_OK) { goto done; } finished = 0; break; } } } } while (!finished); done: Tcl_Release((ClientData) menuPtr); return result; }
static int ThreadEventProc( Tcl_Event *evPtr, /* Really ThreadEvent */ int mask) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); ThreadEvent *threadEventPtr = (ThreadEvent *)evPtr; ThreadEventResult *resultPtr = threadEventPtr->resultPtr; Tcl_Interp *interp = tsdPtr->interp; int code; const char *result, *errorCode, *errorInfo; if (interp == NULL) { code = TCL_ERROR; result = "no target interp!"; errorCode = "THREAD"; errorInfo = ""; } else { Tcl_Preserve((ClientData) interp); Tcl_ResetResult(interp); Tcl_CreateThreadExitHandler(ThreadFreeProc, (ClientData) threadEventPtr->script); code = Tcl_GlobalEval(interp, threadEventPtr->script); Tcl_DeleteThreadExitHandler(ThreadFreeProc, (ClientData) threadEventPtr->script); if (code != TCL_OK) { errorCode = Tcl_GetVar(interp, "errorCode", TCL_GLOBAL_ONLY); errorInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY); } else { errorCode = errorInfo = NULL; } result = Tcl_GetStringResult(interp); } ckfree(threadEventPtr->script); if (resultPtr) { Tcl_MutexLock(&threadMutex); resultPtr->code = code; resultPtr->result = ckalloc(strlen(result) + 1); strcpy(resultPtr->result, result); if (errorCode != NULL) { resultPtr->errorCode = ckalloc(strlen(errorCode) + 1); strcpy(resultPtr->errorCode, errorCode); } if (errorInfo != NULL) { resultPtr->errorInfo = ckalloc(strlen(errorInfo) + 1); strcpy(resultPtr->errorInfo, errorInfo); } Tcl_ConditionNotify(&resultPtr->done); Tcl_MutexUnlock(&threadMutex); } if (interp != NULL) { Tcl_Release((ClientData) interp); } return 1; }
/* UpdateScrollbar -- * Call the -scrollcommand callback to sync the scrollbar. * Returns: Whatever the -scrollcommand does. */ static int UpdateScrollbar(Tcl_Interp *interp, ScrollHandle h) { Scrollable *s = h->scrollPtr; WidgetCore *corePtr = h->corePtr; char arg1[TCL_DOUBLE_SPACE + 2]; char arg2[TCL_DOUBLE_SPACE + 2]; int code; h->flags &= ~SCROLL_UPDATE_REQUIRED; if (s->scrollCmd == NULL) { return TCL_OK; } arg1[0] = arg2[0] = ' '; Tcl_PrintDouble(interp, (double)s->first / s->total, arg1+1); Tcl_PrintDouble(interp, (double)s->last / s->total, arg2+1); Tcl_Preserve(corePtr); code = Tcl_VarEval(interp, s->scrollCmd, arg1, arg2, NULL); if (WidgetDestroyed(corePtr)) { Tcl_Release(corePtr); return TCL_ERROR; } Tcl_Release(corePtr); if (code != TCL_OK && !Tcl_InterpDeleted(interp)) { /* Disable the -scrollcommand, add to stack trace: */ ckfree(s->scrollCmd); s->scrollCmd = 0; Tcl_AddErrorInfo(interp, /* @@@ "horizontal" / "vertical" */ "\n (scrolling command executed by "); Tcl_AddErrorInfo(interp, Tk_PathName(h->corePtr->tkwin)); Tcl_AddErrorInfo(interp, ")"); } return code; }
static void FreeMainInterp( ClientData clientData) { Tcl_Interp *interp = clientData; /*if (TclInExit()) return;*/ if (!Tcl_InterpDeleted(interp)) { Tcl_DeleteInterp(interp); } Tcl_SetStartupScript(NULL, NULL); Tcl_Release(interp); }
/* UpdateScrollbarBG -- * Idle handler to update the scrollbar. */ static void UpdateScrollbarBG(ClientData clientData) { ScrollHandle h = (ScrollHandle)clientData; Tcl_Interp *interp = h->corePtr->interp; int code; h->flags &= ~SCROLL_UPDATE_PENDING; Tcl_Preserve((ClientData) interp); code = UpdateScrollbar(interp, h); if (code == TCL_ERROR && !Tcl_InterpDeleted(interp)) { Tcl_BackgroundError(interp); } Tcl_Release((ClientData) interp); }
static int ThreadEventProc(Tcl_Event *event, int mask) { int code; ThreadEvent *data = (ThreadEvent *)event; /* event is really a ThreadEvent */ Tcl_Preserve(data->interpreter); code = Tcl_EvalEx(data->interpreter, data->script, -1, TCL_EVAL_GLOBAL); Tcl_Free(data->script); if (code != TCL_OK) { ThreadErrorProc(data->interpreter); } Tcl_Release(data->interpreter); return 1; }
void EM_DeleteInterp(Tcl_Interp *interp) { #if WITH_DEBUGGING_INIT ErrorLogger( NO_ERR_START, LOC, _proc_EM_DeleteInterp, NULL); #endif /* * avoid freeing storage when in use, now release */ Tcl_Release(interp); Tcl_DeleteInterp(interp); } /** End of 'EM_DeleteInterp' **/
void TkClipCleanup( TkDisplay *dispPtr) /* Display associated with clipboard */ { if (dispPtr->clipWindow != NULL) { Tk_DeleteSelHandler(dispPtr->clipWindow, dispPtr->clipboardAtom, dispPtr->applicationAtom); Tk_DeleteSelHandler(dispPtr->clipWindow, dispPtr->clipboardAtom, dispPtr->windowAtom); Tk_DestroyWindow(dispPtr->clipWindow); Tcl_Release((ClientData) dispPtr->clipWindow); dispPtr->clipWindow = NULL; } }
static int stateHandlerInvoke(Tcl_Event* p, int flags) { /* called from Tcl event loop, when the connection status changes */ connectionEvent *cev =(connectionEvent *) p; pvInfo *info = cev->info; Tcl_Obj *script = Tcl_DuplicateObj(info->connectprefix); Tcl_IncrRefCount(script); /* append cmd of PV and up/down */ Tcl_Obj *cmdname = Tcl_NewObj(); Tcl_GetCommandFullName(info->interp, info->cmd, cmdname); int code = Tcl_ListObjAppendElement(info->interp, script, cmdname); if (code != TCL_OK) { goto bgerr; } if (cev->op == CA_OP_CONN_UP) { info->connected = 1; /* Retrieve information about type and number of elements */ info->nElem = ca_element_count(info->id); info->type = ca_field_type(info->id); } else { info->connected = 0; } code = Tcl_ListObjAppendElement(info->interp, script, Tcl_NewBooleanObj(info->connected)); if (code != TCL_OK) { goto bgerr; } Tcl_Preserve(info->interp); code = Tcl_EvalObjEx(info->interp, script, TCL_EVAL_GLOBAL); if (code != TCL_OK) { goto bgerr; } Tcl_Release(info->interp); Tcl_DecrRefCount(script); /* this event was successfully handled */ return 1; bgerr: /* put error in background */ Tcl_AddErrorInfo(info->interp, "\n (epics connection callback script)"); Tcl_BackgroundException(info->interp, code); /* this event was successfully handled */ return 1; }
static void AfterProc( ClientData clientData) /* Describes command to execute. */ { AfterInfo *afterPtr = clientData; AfterAssocData *assocPtr = afterPtr->assocPtr; AfterInfo *prevPtr; int result; Tcl_Interp *interp; /* * First remove the callback from our list of callbacks; otherwise someone * could delete the callback while it's being executed, which could cause * a core dump. */ if (assocPtr->firstAfterPtr == afterPtr) { assocPtr->firstAfterPtr = afterPtr->nextPtr; } else { for (prevPtr = assocPtr->firstAfterPtr; prevPtr->nextPtr != afterPtr; prevPtr = prevPtr->nextPtr) { /* Empty loop body. */ } prevPtr->nextPtr = afterPtr->nextPtr; } /* * Execute the callback. */ interp = assocPtr->interp; Tcl_Preserve(interp); result = Tcl_EvalObjEx(interp, afterPtr->commandPtr, TCL_EVAL_GLOBAL); if (result != TCL_OK) { Tcl_AddErrorInfo(interp, "\n (\"after\" script)"); Tcl_BackgroundException(interp, result); } Tcl_Release(interp); /* * Free the memory for the callback. */ Tcl_DecrRefCount(afterPtr->commandPtr); ckfree(afterPtr); }
static pascal void ScaleActionProc( ControlRef theControl, /* Handle to scrollbat control */ ControlPartCode partCode) /* Part of scrollbar that was "hit" */ { int value; TkScale *scalePtr = (TkScale *) GetControlReference(theControl); #ifdef TK_MAC_DEBUG_SCALE TkMacOSXDbgMsg("ScaleActionProc"); #endif value = GetControlValue(theControl); TkScaleSetValue(scalePtr, value, 1, 1); Tcl_Preserve((ClientData) scalePtr); TkMacOSXRunTclEventLoop(); Tcl_Release((ClientData) scalePtr); }
pure_expr *tk(const char *s) { char *result = NULL; if (tk_start(&result)) { bool res; /* Make sure that we don't pull the rug under ourselves. */ Tcl_Interp* _interp = interp; Tcl_Preserve(_interp); res = tk_eval(s, &result); Tcl_Release(_interp); if (res) return (result&&*result)?pure_string(result):pure_tuplel(0); else return tk_error(result); } else return tk_error(result); }
static int SendEventProc( Tcl_Event *eventPtr, int flags) { SendEvent *evPtr = (SendEvent *)eventPtr; TRACE("SendEventProc\n"); Tcl_EvalObjEx(evPtr->interp, evPtr->cmdPtr, TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL); Tcl_DecrRefCount(evPtr->cmdPtr); Tcl_Release(evPtr->interp); return 1; /* 1 to indicate the event has been handled */ }
static HRESULT Send( TkWinSendCom *obj, VARIANT vCmd, VARIANT *pvResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { HRESULT hr = S_OK; int result = TCL_OK; VARIANT v; register Tcl_Interp *interp = obj->interp; Tcl_Obj *scriptPtr; if (interp == NULL) { return S_OK; } VariantInit(&v); hr = VariantChangeType(&v, &vCmd, 0, VT_BSTR); if (!SUCCEEDED(hr)) { return hr; } scriptPtr = Tcl_NewUnicodeObj(v.bstrVal, (int) SysStringLen(v.bstrVal)); Tcl_Preserve(interp); Tcl_IncrRefCount(scriptPtr); result = Tcl_EvalObjEx(interp, scriptPtr, TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL); Tcl_DecrRefCount(scriptPtr); if (pvResult != NULL) { VariantInit(pvResult); pvResult->vt = VT_BSTR; pvResult->bstrVal = SysAllocString(Tcl_GetUnicode( Tcl_GetObjResult(interp))); } if (result == TCL_ERROR) { hr = DISP_E_EXCEPTION; TkWinSend_SetExcepInfo(interp, pExcepInfo); } Tcl_Release(interp); VariantClear(&v); return hr; }
int TkBackgroundEvalObjv( Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, int flags) { Tcl_InterpState state; int n, r = TCL_OK; /* * Record the state of the interpreter. */ Tcl_Preserve(interp); state = Tcl_SaveInterpState(interp, TCL_OK); /* * Evaluate the command and handle any error. */ for (n = 0; n < objc; ++n) { Tcl_IncrRefCount(objv[n]); } r = Tcl_EvalObjv(interp, objc, objv, flags); for (n = 0; n < objc; ++n) { Tcl_DecrRefCount(objv[n]); } if (r == TCL_ERROR) { Tcl_AddErrorInfo(interp, "\n (background event handler)"); Tcl_BackgroundException(interp, r); } /* * Restore the state of the interpreter. */ (void) Tcl_RestoreInterpState(interp, state); Tcl_Release(interp); return r; }
int TnmSnmpEvalBinding(Tcl_Interp *interp, TnmSnmp *session, TnmSnmpPdu *pdu, int event) { int code = TCL_OK; TnmSnmpBinding *bindPtr = session->bindPtr; while (bindPtr) { if (bindPtr->event == event) break; bindPtr = bindPtr->nextPtr; } if (bindPtr && bindPtr->command) { Tcl_Preserve((ClientData) session); code = TnmSnmpEvalCallback(interp, session, pdu, bindPtr->command, NULL, NULL, NULL, NULL); Tcl_Release((ClientData) session); } return code; }
void Tk_FreeImage( Tk_Image image) /* Token for image that is no longer needed by * a widget. */ { Image *imagePtr = (Image *) image; ImageMaster *masterPtr = imagePtr->masterPtr; Image *prevPtr; /* * Clean up the particular instance. */ if (masterPtr->typePtr != NULL) { masterPtr->typePtr->freeProc(imagePtr->instanceData, imagePtr->display); } prevPtr = masterPtr->instancePtr; if (prevPtr == imagePtr) { masterPtr->instancePtr = imagePtr->nextPtr; } else { while (prevPtr->nextPtr != imagePtr) { prevPtr = prevPtr->nextPtr; } prevPtr->nextPtr = imagePtr->nextPtr; } ckfree(imagePtr); /* * If there are no more instances left for the master, and if the master * image has been deleted, then delete the master too. */ if ((masterPtr->typePtr == NULL) && (masterPtr->instancePtr == NULL)) { if (masterPtr->hPtr != NULL) { Tcl_DeleteHashEntry(masterPtr->hPtr); } Tcl_Release(masterPtr->winPtr); ckfree(masterPtr); } }
void Destroy(void) { CallBinds(Type_Unload, NULL, NULL, 0, NULL); Tcl_FreeEncoding(g_Encoding); Tcl_DeleteInterp(g_Interp); Tcl_Release(g_Interp); g_Interp = NULL; Tcl_Finalize(); int i = 0; while (hash_t<CTclSocket*>* p = g_TclListeners->Iterate(i)) { static_cast<CSocketEvents*>(p->Value)->Destroy(); } delete g_TclListeners; i = 0; while (hash_t<CTclClientSocket*>* p = g_TclClientSockets->Iterate(i++)) { p->Value->Destroy(); } delete g_TclClientSockets; for (int a = 0; a < g_TimerCount; a++) { if (g_Timers[a]) { g_Timers[a]->timer->Destroy(); free(g_Timers[a]->proc); free(g_Timers[a]->param); } } delete this; }
static void Tk_MapEmbeddedWindow( TkWindow *winPtr) /* Top-level window that's about to be * mapped. */ { if(!(winPtr->flags & TK_ALREADY_DEAD)) { HWND hwnd = (HWND)winPtr->privatePtr; int state = SendMessage(hwnd, TK_STATE, -1, -1) - 1; if (state < 0 || state > 3) { state = NormalState; } while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) { /* empty body */ } TkpWmSetState(winPtr, state); TkWmMapWindow(winPtr); } Tcl_Release((ClientData)winPtr); }
static void IvyMsgCB(IvyClientPtr app, void *user_data, int argc, char **argv) { filter_struct *filter = (filter_struct *) user_data; int result, i, size; char *script_to_call; size = strlen(filter->script) + 3; for (i = 0; i < argc; i++) { size += strlen(argv[i]) + 3; } size ++; size += strlen(IvyGetApplicationName(app))+4; script_to_call = ckalloc(size); strcpy(script_to_call, filter->script); strcat(script_to_call, " \""); strcat(script_to_call, IvyGetApplicationName(app)); strcat(script_to_call, "\""); /* strcat(script_to_call, " {"); */ for (i = 0; i < argc; i++) { strcat(script_to_call, " \""); strcat(script_to_call, argv[i]); strcat(script_to_call, "\""); } /* strcat(script_to_call, " }"); */ Tcl_Preserve(filter->interp); result = Tcl_GlobalEval(filter->interp, script_to_call); ckfree(script_to_call); if (result != TCL_OK) { Tcl_BackgroundError(filter->interp); } Tcl_Release(filter->interp); }