static void FreeCursor( TkCursor *cursorPtr) /* Cursor to be released. */ { TkCursor *prevPtr; cursorPtr->resourceRefCount--; if (cursorPtr->resourceRefCount > 0) { return; } Tcl_DeleteHashEntry(cursorPtr->idHashPtr); prevPtr = (TkCursor *) Tcl_GetHashValue(cursorPtr->hashPtr); if (prevPtr == cursorPtr) { if (cursorPtr->nextPtr == NULL) { Tcl_DeleteHashEntry(cursorPtr->hashPtr); } else { Tcl_SetHashValue(cursorPtr->hashPtr, cursorPtr->nextPtr); } } else { while (prevPtr->nextPtr != cursorPtr) { prevPtr = prevPtr->nextPtr; } prevPtr->nextPtr = cursorPtr->nextPtr; } TkpFreeCursor(cursorPtr); if (cursorPtr->objRefCount == 0) { ckfree((char *) cursorPtr); } }
void TkGCCleanup( TkDisplay *dispPtr) /* display to clean up resources in */ { Tcl_HashEntry *entryPtr; Tcl_HashSearch search; TkGC *gcPtr; for (entryPtr = Tcl_FirstHashEntry(&dispPtr->gcIdTable, &search); entryPtr != NULL; entryPtr = Tcl_NextHashEntry(&search)) { gcPtr = Tcl_GetHashValue(entryPtr); /* * This call is not needed, as it is only used on Unix to restore the * Id to the stack pool, and we don't want to use them anymore. * Tk_FreeXId(gcPtr->display, (XID) XGContextFromGC(gcPtr->gc)); */ XFreeGC(gcPtr->display, gcPtr->gc); Tcl_DeleteHashEntry(gcPtr->valueHashPtr); Tcl_DeleteHashEntry(entryPtr); ckfree(gcPtr); } Tcl_DeleteHashTable(&dispPtr->gcValueTable); Tcl_DeleteHashTable(&dispPtr->gcIdTable); dispPtr->gcInit = -1; }
int DBus_SignalCleanup(Tcl_Interp *interp, Tcl_HashTable *members) { Tcl_HashTable *interps; Tcl_HashEntry *memberPtr, *interpPtr; Tcl_HashSearch search; Tcl_DBusSignalData *signal; for (memberPtr = Tcl_FirstHashEntry(members, &search); memberPtr != NULL; memberPtr = Tcl_NextHashEntry(&search)) { interps = Tcl_GetHashValue(memberPtr); interpPtr = Tcl_FindHashEntry(interps, (char *) interp); if (interpPtr != NULL) { signal = Tcl_GetHashValue(interpPtr); Tcl_DecrRefCount(signal->script); ckfree((char *) signal); Tcl_DeleteHashEntry(interpPtr); if (Tcl_CheckHashEmpty(interps)) { Tcl_DeleteHashTable(interps); ckfree((char *) interps); Tcl_DeleteHashEntry(memberPtr); } } } return Tcl_CheckHashEmpty(members); }
static void FreeBitmap( TkBitmap *bitmapPtr) /* Bitmap to be released. */ { TkBitmap *prevPtr; bitmapPtr->resourceRefCount--; if (bitmapPtr->resourceRefCount > 0) { return; } Tk_FreePixmap(bitmapPtr->display, bitmapPtr->bitmap); Tcl_DeleteHashEntry(bitmapPtr->idHashPtr); prevPtr = Tcl_GetHashValue(bitmapPtr->nameHashPtr); if (prevPtr == bitmapPtr) { if (bitmapPtr->nextPtr == NULL) { Tcl_DeleteHashEntry(bitmapPtr->nameHashPtr); } else { Tcl_SetHashValue(bitmapPtr->nameHashPtr, bitmapPtr->nextPtr); } } else { while (prevPtr->nextPtr != bitmapPtr) { prevPtr = prevPtr->nextPtr; } prevPtr->nextPtr = bitmapPtr->nextPtr; } if (bitmapPtr->objRefCount == 0) { ckfree(bitmapPtr); } }
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; } }
void XOTclProfilePrintTable(Tcl_HashTable* table) { Tcl_HashEntry* topValueHPtr; long int* topValue; do { Tcl_HashSearch hSrch; Tcl_HashEntry* hPtr = table ? Tcl_FirstHashEntry(table, &hSrch) : 0; char* topKey = 0; topValueHPtr = 0; topValue = 0; for (; hPtr != 0; hPtr = Tcl_NextHashEntry(&hSrch)) { long int *val = (long int*) Tcl_GetHashValue(hPtr); if (val && (!topValue || (topValue && *val >= *topValue))) { topValue = val; topValueHPtr = hPtr; topKey = Tcl_GetHashKey(table, hPtr); } } if (topValueHPtr) { fprintf(stderr, " %15ld %s\n", *topValue, topKey); ckfree((char*) topValue); Tcl_DeleteHashEntry(topValueHPtr); } } while (topValueHPtr); }
//////////////////////////////////////////////////// // cleanup any leftover registration //////////////////////////////////////////////////// static int bonjour_register_cleanup( ClientData clientData ) { Tcl_HashTable *registerRegistrations = (Tcl_HashTable *)clientData; Tcl_HashEntry *hashEntry = NULL; Tcl_HashSearch searchToken; active_registration *activeRegister = NULL; // run through the remaining entries in the hash table for(hashEntry = Tcl_FirstHashEntry(registerRegistrations, &searchToken); hashEntry != NULL; hashEntry = Tcl_NextHashEntry(&searchToken)) { activeRegister = (active_registration *)Tcl_GetHashValue(hashEntry); // deallocate the service reference DNSServiceRefDeallocate(activeRegister->sdRef); // clean up the memory used by activeRegister ckfree(activeRegister->regtype); ckfree((void *)activeRegister); // deallocate the hash entry Tcl_DeleteHashEntry(hashEntry); } Tcl_DeleteHashTable(registerRegistrations); return(TCL_OK); }
static AP_Result tcl_delete(AP_World *w, AP_Obj interp_name) { Tcl_HashEntry *entry; Tcl_Interp *interp; if (AP_ObjType(w, interp_name) != AP_ATOM) { return AP_SetStandardError(w, AP_TYPE_ERROR, AP_NewSymbolFromStr(w, "atom"), interp_name); } entry = Tcl_FindHashEntry(&tcl_interp_name_table, AP_GetAtomStr(w, interp_name)); if (!entry) { return AP_SetStandardError(w, AP_DOMAIN_ERROR, AP_NewSymbolFromStr(w, "tcl_interpreter"), interp_name); } interp = Tcl_GetHashValue(entry); Tcl_DeleteInterp(interp); Tcl_DeleteHashEntry(entry); return AP_SUCCESS; }
static void EmbWinStructureProc( ClientData clientData, /* Pointer to record describing window item. */ XEvent *eventPtr) /* Describes what just happened. */ { TkTextEmbWindowClient *client = clientData; TkTextSegment *ewPtr = client->parent; TkTextIndex index; Tcl_HashEntry *hPtr; if (eventPtr->type != DestroyNotify) { return; } hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable, Tk_PathName(client->tkwin)); if (hPtr != NULL) { /* * This may not exist if the entire widget is being deleted. */ Tcl_DeleteHashEntry(hPtr); } ewPtr->body.ew.tkwin = NULL; client->tkwin = NULL; index.tree = ewPtr->body.ew.sharedTextPtr->tree; index.linePtr = ewPtr->body.ew.linePtr; index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr); TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index); TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL, index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); }
void Tk_FreeColor( XColor *colorPtr) /* Color to be released. Must have been * allocated by Tk_GetColor or * Tk_GetColorByValue. */ { TkColor *tkColPtr = (TkColor *) colorPtr; Screen *screen = tkColPtr->screen; TkColor *prevPtr; /* * Do a quick sanity check to make sure this color was really allocated by * Tk_GetColor. */ if (tkColPtr->magic != COLOR_MAGIC) { Tcl_Panic("Tk_FreeColor called with bogus color"); } tkColPtr->resourceRefCount--; if (tkColPtr->resourceRefCount > 0) { return; } /* * This color is no longer being actively used, so free the color * resources associated with it and remove it from the hash table. No * longer any objects referencing it. */ if (tkColPtr->gc != None) { XFreeGC(DisplayOfScreen(screen), tkColPtr->gc); tkColPtr->gc = None; } TkpFreeColor(tkColPtr); prevPtr = Tcl_GetHashValue(tkColPtr->hashPtr); if (prevPtr == tkColPtr) { if (tkColPtr->nextPtr == NULL) { Tcl_DeleteHashEntry(tkColPtr->hashPtr); } else { Tcl_SetHashValue(tkColPtr->hashPtr, tkColPtr->nextPtr); } } else { while (prevPtr->nextPtr != tkColPtr) { prevPtr = prevPtr->nextPtr; } prevPtr->nextPtr = tkColPtr->nextPtr; } /* * Free the TkColor structure if there are no objects referencing it. * However, if there are objects referencing it then keep the structure * around; it will get freed when the last reference is cleared */ if (tkColPtr->objRefCount == 0) { ckfree((char *) tkColPtr); } }
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); } } }
void ObjToRepMap::erase (Tcl_Obj *pObj) { Tcl_HashEntry *pEntry = Tcl_FindHashEntry( &m_objMap, reinterpret_cast<char *>(pObj)); if (pEntry != 0) { Tcl_DeleteHashEntry(pEntry); } }
extern int XOTclUnsetObjectData(XOTclObject* obj, XOTclClass* cl) { Tcl_HashEntry *hPtr; if (!cl->opt || !cl->opt->objectdata) return 0; hPtr = Tcl_FindHashEntry(cl->opt->objectdata, (char*)obj); if (hPtr) Tcl_DeleteHashEntry(hPtr); return hPtr != 0; }
SWIG_Tcl_Disown(void *ptr) { Tcl_HashEntry *entryPtr; if (!swigobjectTableinit) return 0; entryPtr = Tcl_FindHashEntry(&swigobjectTable, (char *) ptr); if (entryPtr) { Tcl_DeleteHashEntry(entryPtr); return 1; } return 0; }
void Tfp_ArrayDelete( Tfp_ArrayType *arr, char *key ) { Tcl_HashEntry *p; p = Tcl_FindHashEntry( arr->table, key ); if (p == (Tcl_HashEntry *) NULL) { return; } (*arr->cleanProc) ( Tcl_GetHashValue( p ) ); Tcl_DeleteHashEntry( p ); }
static void PkguaDeleteTokens( Tcl_Interp *interp) { Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&interpTokenMap, (char *) interp); if (entryPtr) { Tcl_Free((char *) Tcl_GetHashValue(entryPtr)); Tcl_DeleteHashEntry(entryPtr); } }
void Tk_Free3DBorder( Tk_3DBorder border) /* Token for border to be released. */ { TkBorder *borderPtr = (TkBorder *) border; Display *display = DisplayOfScreen(borderPtr->screen); TkBorder *prevPtr; borderPtr->resourceRefCount--; if (borderPtr->resourceRefCount > 0) { return; } prevPtr = (TkBorder *) Tcl_GetHashValue(borderPtr->hashPtr); TkpFreeBorder(borderPtr); if (borderPtr->bgColorPtr != NULL) { Tk_FreeColor(borderPtr->bgColorPtr); } if (borderPtr->darkColorPtr != NULL) { Tk_FreeColor(borderPtr->darkColorPtr); } if (borderPtr->lightColorPtr != NULL) { Tk_FreeColor(borderPtr->lightColorPtr); } if (borderPtr->shadow != None) { Tk_FreeBitmap(display, borderPtr->shadow); } if (borderPtr->bgGC != None) { Tk_FreeGC(display, borderPtr->bgGC); } if (borderPtr->darkGC != None) { Tk_FreeGC(display, borderPtr->darkGC); } if (borderPtr->lightGC != None) { Tk_FreeGC(display, borderPtr->lightGC); } if (prevPtr == borderPtr) { if (borderPtr->nextPtr == NULL) { Tcl_DeleteHashEntry(borderPtr->hashPtr); } else { Tcl_SetHashValue(borderPtr->hashPtr, borderPtr->nextPtr); } } else { while (prevPtr->nextPtr != borderPtr) { prevPtr = prevPtr->nextPtr; } prevPtr->nextPtr = borderPtr->nextPtr; } if (borderPtr->objRefCount == 0) { ckfree((char *) borderPtr); } }
void DBus_Disconnect(Tcl_Interp *interp, Tcl_HashEntry *busPtr) { Tcl_DBusBus *data; Tcl_HashEntry *hPtr; Tcl_DBusMonitorData *snoop; data = Tcl_GetHashValue(busPtr); /* Find all paths with handlers registered by the interp */ DBus_InterpCleanup(interp, data->conn, "/"); /* Find all handlers of the interp without a path */ if (data->fallback != NULL) { if (DBus_HandlerCleanup(interp, data->fallback)) { ckfree((char *)data->fallback); data->fallback = NULL; } } /* Find snoop handlers */ hPtr = Tcl_FindHashEntry(data->snoop, (char *) interp); if (hPtr != NULL) { snoop = Tcl_GetHashValue(hPtr); if (snoop != NULL) { /* Uninstall the monitor script */ dbus_connection_remove_filter(data->conn, DBus_Monitor, snoop); Tcl_DecrRefCount(snoop->script); ckfree((char *) snoop); } Tcl_DeleteHashEntry(hPtr); if (Tcl_CheckHashEmpty(data->snoop)) { /* Last interpreter that was connected to the dbus */ Tcl_DeleteHashTable(data->snoop); ckfree((char *) data->snoop); if (data->type == N_BUS_TYPES) dbus_connection_unref(data->conn); ckfree((char *) data); if (defaultbus == data) defaultbus = NULL; Tcl_DeleteHashEntry(busPtr); } } }
int mpsa_RemoveListFromHash( char *ListName ) { Tcl_HashEntry *Entry; Entry = Tcl_FindHashEntry(&mpsa_ListHashTable, ListName); if(Entry == NULL) { return MPSA_FAIL; } else { Tcl_DeleteHashEntry(Entry); } return MPSA_OKAY; }
void tn_delete (TNPtr n) { T* t = n->tree; /* We assume that the node either has no parent or siblings anymore, * or that their presence does not matter. The node may still have * children. They are deleted recursively. That is the situation * where the parent/sibling information does not matter anymore, and * can be ignored. */ tn_notleaf (n); tn_notnode (n); Tcl_DecrRefCount (n->name); n->name = NULL; Tcl_DeleteHashEntry (n->he); n->he = NULL; if (n->child) { int i; for (i = 0; i < n->nchildren; i++) { ASSERT_BOUNDS (i, n->nchildren); tn_delete (n->child [i]); n->child [i] = NULL; } ckfree ((char*) n->child); n->child = NULL; n->nchildren = 0; n->maxchildren = 0; } if (n->attr) { Tcl_HashSearch hs; Tcl_HashEntry* he; for(he = Tcl_FirstHashEntry(n->attr, &hs); he != NULL; he = Tcl_NextHashEntry(&hs)) { Tcl_DecrRefCount ((Tcl_Obj*) Tcl_GetHashValue(he)); } Tcl_DeleteHashTable(n->attr); ckfree ((char*) n->attr); n->attr = NULL; } ckfree ((char*) n); }
void Tk_FreeGC( Display *display, /* Display for which gc was allocated. */ GC gc) /* Graphics context to be released. */ { Tcl_HashEntry *idHashPtr; register TkGC *gcPtr; TkDisplay *dispPtr = TkGetDisplay(display); if (!dispPtr->gcInit) { Tcl_Panic("Tk_FreeGC called before Tk_GetGC"); } if (dispPtr->gcInit < 0) { /* * The GCCleanup has been called, and remaining GCs have been freed. * This may still get called by other things shutting down, but the * GCs should no longer be in use. */ return; } idHashPtr = Tcl_FindHashEntry(&dispPtr->gcIdTable, (char *) gc); if (idHashPtr == NULL) { Tcl_Panic("Tk_FreeGC received unknown gc argument"); } gcPtr = Tcl_GetHashValue(idHashPtr); gcPtr->refCount--; if (gcPtr->refCount == 0) { Tk_FreeXId(gcPtr->display, (XID) XGContextFromGC(gcPtr->gc)); XFreeGC(gcPtr->display, gcPtr->gc); Tcl_DeleteHashEntry(gcPtr->valueHashPtr); Tcl_DeleteHashEntry(idHashPtr); ckfree(gcPtr); } }
static void EmbWinLostSlaveProc( ClientData clientData, /* Pointer to record describing window item. */ Tk_Window tkwin) /* Window that was claimed away by another * geometry manager. */ { TkTextEmbWindowClient *client = clientData; TkTextSegment *ewPtr = client->parent; TkTextIndex index; Tcl_HashEntry *hPtr; TkTextEmbWindowClient *loop; Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask, EmbWinStructureProc, client); Tcl_CancelIdleCall(EmbWinDelayedUnmap, client); if (client->textPtr->tkwin != Tk_Parent(tkwin)) { Tk_UnmaintainGeometry(tkwin, client->textPtr->tkwin); } else { Tk_UnmapWindow(tkwin); } hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable, Tk_PathName(client->tkwin)); Tcl_DeleteHashEntry(hPtr); client->tkwin = NULL; ewPtr->body.ew.tkwin = NULL; /* * Free up the memory allocation for this client. */ loop = ewPtr->body.ew.clients; if (loop == client) { ewPtr->body.ew.clients = client->next; } else { while (loop->next != client) { loop = loop->next; } loop->next = client->next; } ckfree((char *) client); index.tree = ewPtr->body.ew.sharedTextPtr->tree; index.linePtr = ewPtr->body.ew.linePtr; index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr); TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index); TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL, index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); }
static duk_context * parse_id(ClientData cdata, Tcl_Interp *interp, Tcl_Obj *const idobj, int del) { duk_context *ctx; Tcl_HashEntry *hashPtr; hashPtr = Tcl_FindHashEntry(&DUKTCL_CDATA->table, Tcl_GetString(idobj)); if (hashPtr == NULL) { Tcl_SetObjResult(interp, Tcl_NewStringObj(ERROR_TOKEN, -1)); return NULL; } ctx = (duk_context *) Tcl_GetHashValue(hashPtr); if (del) { Tcl_DeleteHashEntry(hashPtr); } return ctx; }
int DBus_MethodCleanup(Tcl_Interp *interp, Tcl_HashTable *members) { Tcl_HashEntry *memberPtr; Tcl_HashSearch search; Tcl_DBusMethodData *method; for (memberPtr = Tcl_FirstHashEntry(members, &search); memberPtr != NULL; memberPtr = Tcl_NextHashEntry(&search)) { method = Tcl_GetHashValue(memberPtr); if (method->interp == interp) { Tcl_DecrRefCount(method->script); ckfree((char *) method); Tcl_DeleteHashEntry(memberPtr); } } return Tcl_CheckHashEmpty(members); }
static void SlaveStructureProc( ClientData clientData, /* Pointer to Slave structure for window * referred to by eventPtr. */ XEvent *eventPtr) /* Describes what just happened. */ { register Slave *slavePtr = clientData; TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr; if (eventPtr->type == DestroyNotify) { if (slavePtr->masterPtr != NULL) { UnlinkSlave(slavePtr); } Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable, (char *) slavePtr->tkwin)); FreeSlave(slavePtr); } }
/* Delete any receiver_reports this member has reported from the hash tables for every sender. */ void Clear_Member_RRs(_RTP_CONTEXT *the_context, member *the_member) { struct link *cur_link; Tcl_HashTable *the_table; Tcl_HashEntry *the_entry; cur_link = the_context->RTP_SenderList.actual_list.first_link; while (cur_link != NULL) { the_table = &cur_link->my_member->RR_Hash; the_entry = Tcl_FindHashEntry(the_table, (char *) the_member->unique_id); if (the_entry != NULL) { free(Tcl_GetHashValue(the_entry)); Tcl_DeleteHashEntry(the_entry); } cur_link = cur_link->next_link; } }
int TnmAttrSet(Tcl_HashTable *tablePtr, Tcl_Interp *interp, char *name, char *value) { Tcl_HashEntry *entryPtr; int isNew; char *p; entryPtr = Tcl_FindHashEntry(tablePtr, name); if (value) { /* * Check the character set of the name to make sure that * we do not run into quoting hell problems just because * people put funny characters into the names. */ for (p = name; *p; p++) { if (!isalnum(*p) && *p != ':') { Tcl_SetResult(interp, "illegal character in attribute name", TCL_STATIC); return TCL_ERROR; } } if (! entryPtr) { entryPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew); } else { ckfree((char *) Tcl_GetHashValue(entryPtr)); } if (*value) { Tcl_SetHashValue(entryPtr, ckstrdup(value)); } else { Tcl_DeleteHashEntry(entryPtr); entryPtr = NULL; } } if (entryPtr) { Tcl_SetResult(interp, (char *) Tcl_GetHashValue(entryPtr), TCL_STATIC); } return TCL_OK; }
/* ARGSUSED */ static void PlaceLostSlaveProc( ClientData clientData, /* Slave structure for slave window that was * stolen away. */ Tk_Window tkwin) /* Tk's handle for the slave window. */ { register Slave *slavePtr = clientData; TkDisplay *dispPtr = ((TkWindow *) slavePtr->tkwin)->dispPtr; if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) { Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin); } Tk_UnmapWindow(tkwin); UnlinkSlave(slavePtr); Tcl_DeleteHashEntry(Tcl_FindHashEntry(&dispPtr->slaveTable, (char *) tkwin)); Tk_DeleteEventHandler(tkwin, StructureNotifyMask, SlaveStructureProc, slavePtr); FreeSlave(slavePtr); }
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); } }
int HTAssocList_delete_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { if (argc == 2) { char *keyname = argv[1]; if (keyname) { Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&HTableAssoc, keyname); if (entryPtr) { HTAssocList *list = Tcl_GetHashValue(entryPtr); HTAssocList_delete(list); Tcl_DeleteHashEntry(entryPtr); return TCL_OK; } } Tcl_AppendResult(interp, bad_vars, NULL); return TCL_ERROR; } else { Tcl_AppendResult(interp, err_string, argv[0], " associated-list", NULL); return TCL_ERROR; } }