/*
* ------------------------------------------------------------------------
* ItclCheckSetItclHull()
*
*
* ------------------------------------------------------------------------
*/
static int
ItclCheckSetItclHull(
ClientData clientData, /* infoPtr */
Tcl_Interp *interp, /* current interpreter */
int objc, /* number of arguments */
Tcl_Obj *const objv[]) /* argument objects */
{
Tcl_HashEntry *hPtr;
Tcl_Obj *objPtr;
ItclObject *ioPtr;
ItclVariable *ivPtr;
ItclObjectInfo *infoPtr;
const char *valueStr;
if (objc < 3) {
Tcl_AppendResult(interp, "ItclCheckSetItclHull wrong # args should be ",
"<objectName> <value>", NULL);
return TCL_ERROR;
}
infoPtr = (ItclObjectInfo *)clientData;
if (strlen(Tcl_GetString(objv[1])) > 0) {
hPtr = Tcl_FindHashEntry(&infoPtr->objectNames, (char *)objv[1]);
if (hPtr == NULL) {
Tcl_AppendResult(interp, "ItclCheckSetItclHull cannot find object\"",
Tcl_GetString(objv[1]), "\"", NULL);
return TCL_ERROR;
}
ioPtr = Tcl_GetHashValue(hPtr);
} else {
ioPtr = infoPtr->currIoPtr;
if (ioPtr == NULL) {
Tcl_AppendResult(interp, "ItclCheckSetItclHull cannot find object",
NULL);
return TCL_ERROR;
}
}
objPtr = Tcl_NewStringObj("itcl_hull", -1);
hPtr = Tcl_FindHashEntry(&ioPtr->iclsPtr->variables, (char *)objPtr);
Tcl_DecrRefCount(objPtr);
if (hPtr == NULL) {
Tcl_AppendResult(interp, "ItclCheckSetItclHull cannot find itcl_hull",
" variable for object \"", Tcl_GetString(objv[1]), "\"", NULL);
return TCL_ERROR;
}
ivPtr = Tcl_GetHashValue(hPtr);
valueStr = Tcl_GetString(objv[2]);
if (strcmp(valueStr, "2") == 0) {
ivPtr->initted = 2;
} else {
if (strcmp(valueStr, "0") == 0) {
ivPtr->initted = 0;
} else {
Tcl_AppendResult(interp, "ItclCheckSetItclHull bad value \"",
valueStr, "\"", NULL);
return TCL_ERROR;
}
}
return TCL_OK;
}
KeySym
XKeycodeToKeysym(
Display* display,
KeyCode keycode,
int index)
{
register Tcl_HashEntry *hPtr;
register char c;
char virtualKey;
int newKeycode;
unsigned long dummy, newChar;
if (!initialized) {
InitKeyMaps();
}
c = keycode & charCodeMask;
virtualKey = (keycode & keyCodeMask) >> 8;
/*
* When determining what keysym to produce we firt check to see if
* the key is a function key. We then check to see if the character
* is another non-printing key. Finally, we return the key syms
* for all ASCI chars.
*/
if (c == 0x10) {
hPtr = Tcl_FindHashEntry(&vkeyTable, (char *) virtualKey);
if (hPtr != NULL) {
return (KeySym) Tcl_GetHashValue(hPtr);
}
}
hPtr = Tcl_FindHashEntry(&keycodeTable, (char *) virtualKey);
if (hPtr != NULL) {
return (KeySym) Tcl_GetHashValue(hPtr);
}
/*
* Recompute the character based on the Shift key only.
* TODO: The index may also specify the NUM_LOCK.
*/
newKeycode = virtualKey;
if (index & 0x01) {
newKeycode += 0x0200;
}
dummy = 0;
newChar = KeyTranslate(KCHRPtr, (short) newKeycode, &dummy);
c = newChar & charCodeMask;
if (c >= XK_space && c < XK_asciitilde) {
return c;
}
return NoSymbol;
}
Tcl_DBusBus *DBus_GetConnection(Tcl_Interp *interp, Tcl_Obj *const name)
{
Tcl_HashEntry *entry;
Tcl_DBusBus *dbus;
entry = Tcl_FindHashEntry(&bus, (char *) name);
if (entry == NULL) return NULL;
dbus = (Tcl_DBusBus *) Tcl_GetHashValue(entry);
entry = Tcl_FindHashEntry(dbus->snoop, (char *) interp);
if (entry != NULL)
return dbus;
else
return NULL;
}
/* ARGSUSED */
int
Itcl_ParseVarResolver2(
Tcl_Interp *interp, /* current interpreter */
const char* name, /* name of the variable being accessed */
Tcl_Namespace *contextNs, /* namespace context */
int flags, /* TCL_GLOBAL_ONLY => global variable
* TCL_NAMESPACE_ONLY => namespace variable */
Tcl_Var* rPtr) /* returns: Tcl_Var for desired variable */
{
ItclObjectInfo *infoPtr = (ItclObjectInfo*)contextNs->clientData;
ItclClass *iclsPtr = (ItclClass*)Itcl_PeekStack(&infoPtr->clsStack);
Tcl_HashEntry *hPtr;
ItclVarLookup *vlookup;
/*
* See if the requested variable is a recognized "common" member.
* If it is, make sure that access is allowed.
*/
hPtr = Tcl_FindHashEntry(&iclsPtr->resolveVars, name);
if (hPtr) {
vlookup = (ItclVarLookup*)Tcl_GetHashValue(hPtr);
if ((vlookup->ivPtr->flags & ITCL_COMMON) != 0) {
if (!vlookup->accessible) {
Tcl_AppendResult(interp,
"can't access \"", name, "\": ",
Itcl_ProtectionStr(vlookup->ivPtr->protection),
" variable",
(char*)NULL);
return TCL_ERROR;
}
hPtr = Tcl_FindHashEntry(&vlookup->ivPtr->iclsPtr->classCommons,
(char *)vlookup->ivPtr);
if (hPtr != NULL) {
*rPtr = Tcl_GetHashValue(hPtr);
return TCL_OK;
}
}
}
/*
* If the variable is not recognized, return TCL_CONTINUE and
* let lookup continue via the normal name resolution rules.
* This is important for variables like "errorInfo"
* that might get set while the parser namespace is active.
*/
return TCL_CONTINUE;
}
ClientData
Tk_GetImageMasterData(
Tcl_Interp *interp, /* Interpreter in which the image was
* created. */
const char *name, /* Name of image. */
const Tk_ImageType **typePtrPtr)
/* Points to location to fill in with pointer
* to type information for image. */
{
TkWindow *winPtr = (TkWindow *) Tk_MainWindow(interp);
Tcl_HashEntry *hPtr;
ImageMaster *masterPtr;
hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->imageTable, name);
if (hPtr == NULL) {
*typePtrPtr = NULL;
return NULL;
}
masterPtr = Tcl_GetHashValue(hPtr);
if (masterPtr->deleted) {
*typePtrPtr = NULL;
return NULL;
}
*typePtrPtr = masterPtr->typePtr;
return masterPtr->masterData;
}
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 TkTextTag *
FindTag(
Tcl_Interp *interp, /* Interpreter to use for error message; if
* NULL, then don't record an error
* message. */
TkText *textPtr, /* Widget in which tag is being used. */
Tcl_Obj *tagName) /* Name of desired tag. */
{
Tcl_HashEntry *hPtr;
int len;
const char *str;
str = Tcl_GetStringFromObj(tagName, &len);
if (len == 3 && !strcmp(str, "sel")) {
return textPtr->selTagPtr;
}
hPtr = Tcl_FindHashEntry(&textPtr->sharedTextPtr->tagTable,
Tcl_GetString(tagName));
if (hPtr != NULL) {
return Tcl_GetHashValue(hPtr);
}
if (interp != NULL) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"tag \"%s\" isn't defined in text widget",
Tcl_GetString(tagName)));
Tcl_SetErrorCode(interp, "TK", "LOOKUP", "TEXT_TAG",
Tcl_GetString(tagName), NULL);
}
return NULL;
}
static void
AtomInit(
TkDisplay *dispPtr)/* Display to initialize. */
{
Tcl_HashEntry *hPtr;
Atom atom;
dispPtr->atomInit = 1;
Tcl_InitHashTable(&dispPtr->nameTable, TCL_STRING_KEYS);
Tcl_InitHashTable(&dispPtr->atomTable, TCL_ONE_WORD_KEYS);
for (atom = 1; atom <= XA_LAST_PREDEFINED; atom++) {
const char *name;
int isNew;
hPtr = Tcl_FindHashEntry(&dispPtr->atomTable, (char *) atom);
if (hPtr != NULL) {
continue;
}
name = atomNameArray[atom - 1];
hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, name, &isNew);
Tcl_SetHashValue(hPtr, atom);
name = Tcl_GetHashKey(&dispPtr->nameTable, hPtr);
hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom, &isNew);
Tcl_SetHashValue(hPtr, name);
}
}
static int
IvySendDirectCmd(ClientData clientData,
Tcl_Interp *interp,
int argc,
const char **argv)
{
Tcl_HashEntry *entry;
unsigned long id;
char *end;
if (argc != 4) {
Tcl_AppendResult(interp, "wrong # of args: \"",
argv[0], " appName id msg\"", (char *) NULL);
return TCL_ERROR;
}
entry = Tcl_FindHashEntry(&app_table, argv[1]);
if (!entry) {
Tcl_AppendResult(interp, "Application \"",
argv[1], "\" not connected", (char *) NULL);
return TCL_ERROR;
}
id = strtol(argv[2], &end, 10);
if (*end) {
Tcl_AppendResult(interp, argv[0], " wrong id: \"", argv[2],
(char *) NULL);
return TCL_ERROR;
}
IvySendDirectMsg((IvyClientPtr) Tcl_GetHashValue(entry), id, (char*)argv[3]);
return TCL_OK;
}
CONST char *
Tk_NameOfCursor(
Display *display, /* Display for which cursor was allocated. */
Tk_Cursor cursor) /* Identifier for cursor whose name is
* wanted. */
{
Tcl_HashEntry *idHashPtr;
TkCursor *cursorPtr;
TkDisplay *dispPtr;
dispPtr = TkGetDisplay(display);
if (!dispPtr->cursorInit) {
printid:
sprintf(dispPtr->cursorString, "cursor id %p", cursor);
return dispPtr->cursorString;
}
idHashPtr = Tcl_FindHashEntry(&dispPtr->cursorIdTable, (char *) cursor);
if (idHashPtr == NULL) {
goto printid;
}
cursorPtr = (TkCursor *) Tcl_GetHashValue(idHashPtr);
if (cursorPtr->otherTable != &dispPtr->cursorNameTable) {
goto printid;
}
return cursorPtr->hashPtr->key.string;
}
static int
IvyApplicationHostCmd(ClientData clientData,
Tcl_Interp *interp,
int argc,
const char **argv)
{
Tcl_HashEntry *entry;
if (argc != 2) {
Tcl_AppendResult(interp, "wrong # of args: \"",
argv[0], " appName\"", (char *) NULL);
return TCL_ERROR;
}
entry = Tcl_FindHashEntry(&app_table, argv[1]);
if (!entry) {
Tcl_AppendResult(interp, "Application \"",
argv[1], "\" not connected", (char *) NULL);
return TCL_ERROR;
}
Tcl_SetResult(interp, (char *) IvyGetApplicationHost((IvyClientPtr) Tcl_GetHashValue(entry)),
TCL_STATIC);
return TCL_OK;
}
char *
Ns_GetMimeType(char *file)
{
char *start, *ext;
Ns_DString ds;
Tcl_HashEntry *hePtr;
start = strrchr(file, '/');
if (start == NULL) {
start = file;
}
ext = strrchr(start, '.');
if (ext == NULL) {
return noextType;
}
Ns_DStringInit(&ds);
ext = LowerDString(&ds, ext);
hePtr = Tcl_FindHashEntry(&types, ext);
if (hePtr == NULL) {
return defaultType;
}
return Tcl_GetHashValue(hePtr);
}
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;
}
SignalMapEntry *
FindSigMapEntry (
SignalMap *sigmapPtr,
int signum)
{
return Tcl_FindHashEntry(sigmapPtr, WORDKEY(signum));
}
/* + style element create name type ? ...args ?
*/
static int StyleElementCreateCmd(
ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
StylePackageData *pkgPtr = clientData;
Ttk_Theme theme = pkgPtr->currentTheme;
const char *elementName, *factoryName;
Tcl_HashEntry *entryPtr;
FactoryRec *recPtr;
if (objc < 5) {
Tcl_WrongNumArgs(interp, 3, objv, "name type ?-option value ...?");
return TCL_ERROR;
}
elementName = Tcl_GetString(objv[3]);
factoryName = Tcl_GetString(objv[4]);
entryPtr = Tcl_FindHashEntry(&pkgPtr->factoryTable, factoryName);
if (!entryPtr) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"No such element type %s", factoryName));
Tcl_SetErrorCode(interp, "TTK", "LOOKUP", "ELEMENT_TYPE", factoryName,
NULL);
return TCL_ERROR;
}
recPtr = Tcl_GetHashValue(entryPtr);
return recPtr->factory(interp, recPtr->clientData,
theme, elementName, objc - 5, objv + 5);
}
SWIG_Tcl_Thisown(void *ptr) {
if (!swigobjectTableinit) return 0;
if (Tcl_FindHashEntry(&swigobjectTable, (char *) ptr)) {
return 1;
}
return 0;
}
static int
IvyApplicationMsgsCmd(ClientData clientData,
Tcl_Interp *interp,
int argc,
const char **argv)
{
Tcl_HashEntry *entry;
char **msgs, **scan;
if (argc != 2) {
Tcl_AppendResult(interp, "wrong # of args: \"",
argv[0], " appName\"", (char *) NULL);
return TCL_ERROR;
}
entry = Tcl_FindHashEntry(&app_table, argv[1]);
if (!entry) {
Tcl_AppendResult(interp, "Application \"",
argv[1], "\" not connected", (char *) NULL);
return TCL_ERROR;
}
msgs = IvyGetApplicationMessages((IvyClientPtr) Tcl_GetHashValue(entry));
for (scan = msgs; *scan; scan++) {
Tcl_AppendElement(interp, *scan);
}
return TCL_OK;
}
int
TkTextMarkNameToIndex(
TkText *textPtr, /* Text widget containing mark. */
const char *name, /* Name of mark. */
TkTextIndex *indexPtr) /* Index information gets stored here. */
{
TkTextSegment *segPtr;
if (textPtr == NULL) {
return TCL_ERROR;
}
if (!strcmp(name, "insert")) {
segPtr = textPtr->insertMarkPtr;
} else if (!strcmp(name, "current")) {
segPtr = textPtr->currentMarkPtr;
} else {
Tcl_HashEntry *hPtr;
hPtr = Tcl_FindHashEntry(&textPtr->sharedTextPtr->markTable, name);
if (hPtr == NULL) {
return TCL_ERROR;
}
segPtr = (TkTextSegment *) Tcl_GetHashValue(hPtr);
}
TkTextMarkSegToIndex(textPtr, segPtr, indexPtr);
return TCL_OK;
}
ClientData DBus_FindListeners(Tcl_DBusBus *dbus,
const char *path, const char *name, int method)
{
Tcl_DBusHandlerData *dataPtr;
Tcl_HashTable *tablePtr;
Tcl_HashEntry *hPtr;
/* Get the currently registered handler for signal/method and path */
if (*path == '\0')
dataPtr = dbus->fallback;
else
if (!dbus_connection_get_object_path_data(dbus->conn, path,
(void **)&dataPtr)) return NULL;
/* Check if any handler is registered for this path */
if (dataPtr == NULL) return NULL;
if (method)
tablePtr = dataPtr->method;
else
tablePtr = dataPtr->signal;
/* Check if any handlers are registered for this path */
if (tablePtr == NULL) return NULL;
/* Check if a handler with the specified name was registered */
hPtr = Tcl_FindHashEntry(tablePtr, name);
if (hPtr == NULL) return NULL;
return Tcl_GetHashValue(hPtr);
}
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);
}
Tcl_Obj *
TkDebugColor(
Tk_Window tkwin, /* The window in which the color will be used
* (not currently used). */
char *name) /* Name of the desired color. */
{
Tcl_HashEntry *hashPtr;
Tcl_Obj *resultPtr;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
resultPtr = Tcl_NewObj();
hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable, name);
if (hashPtr != NULL) {
TkColor *tkColPtr = Tcl_GetHashValue(hashPtr);
if (tkColPtr == NULL) {
Tcl_Panic("TkDebugColor found empty hash table entry");
}
for ( ; (tkColPtr != NULL); tkColPtr = tkColPtr->nextPtr) {
Tcl_Obj *objPtr = Tcl_NewObj();
Tcl_ListObjAppendElement(NULL, objPtr,
Tcl_NewIntObj(tkColPtr->resourceRefCount));
Tcl_ListObjAppendElement(NULL, objPtr,
Tcl_NewIntObj(tkColPtr->objRefCount));
Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
}
}
return resultPtr;
}
/* ARGSUSED */
static int
EmbWinDeleteProc(
TkTextSegment *ewPtr, /* Segment being deleted. */
TkTextLine *linePtr, /* Line containing segment. */
int treeGone) /* Non-zero means the entire tree is being
* deleted, so everything must get cleaned
* up. */
{
TkTextEmbWindowClient *client;
client = ewPtr->body.ew.clients;
while (client != NULL) {
TkTextEmbWindowClient *next = client->next;
Tcl_HashEntry *hPtr = NULL;
if (client->tkwin != NULL) {
hPtr = Tcl_FindHashEntry(
&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
}
TkTextWinFreeClient(hPtr, client);
client = next;
}
ewPtr->body.ew.clients = NULL;
Tk_FreeConfigOptions((char *) &ewPtr->body.ew, ewPtr->body.ew.optionTable,
NULL);
/*
* Free up all memory allocated.
*/
ckfree((char *) ewPtr);
return 0;
}
void
XOTclProfileFillTable(Tcl_HashTable* table, Tcl_DString* key,
double totalMicroSec) {
Tcl_HashEntry* hPtr;
char* keyStr = Tcl_DStringValue(key);
long int* value;
hPtr = Tcl_FindHashEntry(table, keyStr);
if (!hPtr) {
int nw;
hPtr = Tcl_CreateHashEntry(table, keyStr, &nw);
if (!nw)
return;
value = (long int*) ckalloc (sizeof(long int));
*value = 0;
Tcl_SetHashValue(hPtr, (ClientData) value);
} else
value = (long int*) Tcl_GetHashValue (hPtr);
*value += totalMicroSec;
/* {
long int* d = (long int*) Tcl_GetHashValue (hPtr);
fprintf(stderr, "Entered %s ... %ld\n", Tcl_GetHashKey(table, hPtr), *d);
}*/
}
/*++
GetHandleTableEntry
Looks up a handle's hash table entry.
Arguments:
interp - Interpreter to use for error reporting.
objPtr - The string value of this object is used to search through tablePtr.
tablePtr - Address of a hash table structure.
type - Null-terminated string describing the handle type.
Return Value:
If the handle is valid, the address of the handle's hash table entry is
returned. If the handle is invalid, NULL is returned and an error message
is left in the interpreter's result.
--*/
Tcl_HashEntry *
GetHandleTableEntry(
Tcl_Interp *interp,
Tcl_Obj *objPtr,
Tcl_HashTable *tablePtr,
const char *type
)
{
char *handle;
Tcl_HashEntry *hashEntryPtr;
assert(interp != NULL);
assert(objPtr != NULL);
assert(tablePtr != NULL);
assert(type != NULL);
handle = Tcl_GetString(objPtr);
hashEntryPtr = Tcl_FindHashEntry(tablePtr, handle);
if (hashEntryPtr == NULL) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "invalid ", type, " handle \"", handle, "\"", NULL);
}
return hashEntryPtr;
}
Tk_Style
Tk_GetStyle(
Tcl_Interp *interp, /* Interp for error return. */
const char *name) /* Name of the style to retrieve. NULL or empty
* means the default system style. */
{
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
Tcl_HashEntry *entryPtr;
Style *stylePtr;
/*
* Search for a corresponding entry in the style table.
*/
entryPtr = Tcl_FindHashEntry(&tsdPtr->styleTable, (name!=NULL?name:""));
if (entryPtr == NULL) {
if (interp != NULL) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"style \"%s\" doesn't exist", name));
Tcl_SetErrorCode(interp, "TK", "LOOKUP", "STYLE", name, NULL);
}
return (Tk_Style) NULL;
}
stylePtr = Tcl_GetHashValue(entryPtr);
return (Tk_Style) stylePtr;
}
Box* BoxVec::boxPtr(char* nm){
/****
given the name of the box 'nm',
return the pointer to the box object
****/
Tcl_HashEntry *entryPtr=Tcl_FindHashEntry(&bvhash, nm);
if( entryPtr == NULL ) return NULL;
else return (Box*)(entryPtr->clientData);
}
void
ObjToRepMap::erase (Tcl_Obj *pObj)
{
Tcl_HashEntry *pEntry = Tcl_FindHashEntry(
&m_objMap, reinterpret_cast<char *>(pObj));
if (pEntry != 0) {
Tcl_DeleteHashEntry(pEntry);
}
}
/*
* CheckNamedColor(objPtr) --
* If objPtr is a registered color name, return a Tcl_Obj *
* containing the registered color value specification.
* Otherwise, return the input argument.
*/
static Tcl_Obj *CheckNamedColor(Ttk_ResourceCache cache, Tcl_Obj *objPtr)
{
Tcl_HashEntry *entryPtr =
Tcl_FindHashEntry(&cache->namedColors, Tcl_GetString(objPtr));
if (entryPtr) { /* Use named color instead */
objPtr = Tcl_GetHashValue(entryPtr);
}
return objPtr;
}
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);
}
}
}
extern int
XOTclGetObjectData(XOTclObject* obj, XOTclClass* cl, ClientData* data) {
Tcl_HashEntry *hPtr;
if (!cl->opt || !cl->opt->objectdata)
return 0;
hPtr = Tcl_FindHashEntry(cl->opt->objectdata, (char*)obj);
if (data) *data = hPtr ? Tcl_GetHashValue(hPtr) : 0;
return hPtr != 0;
}
