/*

* tkConfig.c --

*

* This file contains functions that manage configuration options for

* widgets and other things.

*

* Copyright © 1997-1998 Sun Microsystems, Inc.

*

* See the file "license.terms" for information on usage and redistribution of

* this file, and for a DISCLAIMER OF ALL WARRANTIES.

*/

/*

* Temporary flag for working on new config package.

*/

#if 0

/*

* used only for removing the old config code

*/

#define __NO_OLD_CONFIG

#endif

#include "tkInt.h"

#include "tkFont.h"

#ifdef _WIN32

#include "tkWinInt.h"

#endif

/*

* The following encoding is used in TK_OPTION_VAR:

*

* if sizeof(type) == sizeof(int) => TK_OPTION_VAR(type) = 0

* if sizeof(type) == 1 => TK_OPTION_VAR(type) = 64

* if sizeof(type) == 2 => TK_OPTION_VAR(type) = 128

* if sizeof(type) == sizeof(long long) => TK_OPTION_VAR(type) = 192

*/

#define TYPE_MASK (((((int)sizeof(int)-1))|3)<<6)

/*

* The following definition keeps track of all of

* the option tables that have been created for a thread.

*/

typedef struct {

bool initialized; /* false means table below needs initializing. */

Tcl_HashTable hashTable;

} ThreadSpecificData;

static Tcl_ThreadDataKey dataKey;

/*

* The following two structures are used along with Tk_OptionSpec structures

* to manage configuration options. Tk_OptionSpec is static templates that are

* compiled into the code of a widget or other object manager. However, to

* look up options efficiently we need to supplement the static information

* with additional dynamic information, and this dynamic information may be

* different for each application. Thus we create structures of the following

* two types to hold all of the dynamic information; this is done by

* Tk_CreateOptionTable.

*

* One of the following structures corresponds to each Tk_OptionSpec. These

* structures exist as arrays inside TkOptionTable structures.

*/

typedef struct TkOption {

const Tk_OptionSpec *specPtr;

/* The original spec from the template passed

* to Tk_CreateOptionTable.*/

Tk_Uid dbNameUID; /* The Uid form of the option database

* name. */

Tk_Uid dbClassUID; /* The Uid form of the option database class

* name. */

Tcl_Obj *defaultPtr; /* Default value for this option. */

union {

Tcl_Obj *monoColorPtr; /* For color and border options, this is an

* alternate default value to use on

* monochrome displays. */

struct TkOption *synonymPtr;

/* For synonym options, this points to the

* original entry. */

const struct Tk_ObjCustomOption *custom;

/* For TK_OPTION_CUSTOM. */

} extra;

int flags; /* Miscellaneous flag values; see below for

* definitions. */

} Option;

/*

* Flag bits defined for Option structures:

*

* OPTION_NEEDS_FREEING - 1 means that FreeResources must be invoked to

* free resources associated with the option when

* it is no longer needed.

*/

#define OPTION_NEEDS_FREEING 1

/*

* One of the following exists for each Tk_OptionSpec array that has been

* passed to Tk_CreateOptionTable.

*/

typedef struct OptionTable {

size_t refCount; /* Counts the number of uses of this table

* (the number of times Tk_CreateOptionTable

* has returned it). This can be greater than

* 1 if it is shared along several option

* table chains, or if the same table is used

* for multiple purposes. */

Tcl_HashEntry *hashEntryPtr;/* Hash table entry that refers to this table;

* used to delete the entry. */

struct OptionTable *nextPtr;/* If templatePtr was part of a chain of

* templates, this points to the table

* corresponding to the next template in the

* chain. */

size_t numOptions; /* The number of items in the options array

* below. */

Option options[1]; /* Information about the individual options in

* the table. This must be the last field in

* the structure: the actual size of the array

* will be numOptions, not 1. */

} OptionTable;

/*

* Forward declarations for functions defined later in this file:

*/

static int DoObjConfig(Tcl_Interp *interp, void *recordPtr,

Option *optionPtr, Tcl_Obj *valuePtr,

Tk_Window tkwin, Tk_SavedOption *savePtr);

static void FreeResources(Option *optionPtr, Tcl_Obj *objPtr,

void *internalPtr, Tk_Window tkwin);

static Tcl_Obj * GetConfigList(void *recordPtr,

Option *optionPtr, Tk_Window tkwin);

static Tcl_Obj * GetObjectForOption(void *recordPtr,

Option *optionPtr, Tk_Window tkwin);

static Option * GetOption(const char *name, OptionTable *tablePtr);

static Option * GetOptionFromObj(Tcl_Interp *interp,

Tcl_Obj *objPtr, OptionTable *tablePtr);

static void FreeOptionInternalRep(Tcl_Obj *objPtr);

static void DupOptionInternalRep(Tcl_Obj *, Tcl_Obj *);

/*

* The structure below defines an object type that is used to cache the result

* of looking up an option name. If an object has this type, then its

* internalPtr1 field points to the OptionTable in which it was looked up, and

* the internalPtr2 field points to the entry that matched.

*/

static const Tcl_ObjType optionObjType = {

"option", /* name */

FreeOptionInternalRep, /* freeIntRepProc */

DupOptionInternalRep, /* dupIntRepProc */

NULL, /* updateStringProc */

NULL, /* setFromAnyProc */

TCL_OBJTYPE_V0

};



/*

*--------------------------------------------------------------

*

* Tk_CreateOptionTable --

*

* Given a template for configuration options, this function creates a

* table that may be used to look up options efficiently.

*

* Results:

* Returns a token to a structure that can be passed to functions such as

* Tk_InitOptions, Tk_SetOptions, and Tk_FreeConfigOptions.

*

* Side effects:

* Storage is allocated.

*

*--------------------------------------------------------------

*/

Tk_OptionTable

Tk_CreateOptionTable(

Tcl_Interp *interp, /* Interpreter associated with the application

* in which this table will be used. */

const Tk_OptionSpec *templatePtr)

/* Static information about the configuration

* options. */

{

Tcl_HashEntry *hashEntryPtr;

int newEntry;

OptionTable *tablePtr;

const Tk_OptionSpec *specPtr, *specPtr2;

Option *optionPtr;

size_t numOptions, i;

ThreadSpecificData *tsdPtr = (ThreadSpecificData *)

Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

/*

* We use an TSD in the thread to keep a hash table of

* all the option tables we've created for this application. This is

* used for allowing us to share the tables (e.g. in several chains).

* The code below finds the hash table or creates a new one if it

* doesn't already exist.

*/

if (!tsdPtr->initialized) {

Tcl_InitHashTable(&tsdPtr->hashTable, TCL_ONE_WORD_KEYS);

tsdPtr->initialized = true;

}

/*

* See if a table has already been created for this template. If so, just

* reuse the existing table.

*/

hashEntryPtr = Tcl_CreateHashEntry(&tsdPtr->hashTable, (char *)templatePtr,

&newEntry);

if (!newEntry) {

tablePtr = (OptionTable *)Tcl_GetHashValue(hashEntryPtr);

tablePtr->refCount++;

return (Tk_OptionTable)tablePtr;

}

/*

* Count the number of options in the template, then create the table

* structure.

*/

numOptions = 0;

for (specPtr = templatePtr; specPtr->type != TK_OPTION_END; specPtr++) {

numOptions++;

}

tablePtr = (OptionTable *)ckalloc(sizeof(OptionTable) + (numOptions * sizeof(Option)));

tablePtr->refCount = 1;

tablePtr->hashEntryPtr = hashEntryPtr;

tablePtr->nextPtr = NULL;

tablePtr->numOptions = numOptions;

/*

* Initialize all of the Option structures in the table.

*/

for (specPtr = templatePtr, optionPtr = tablePtr->options;

specPtr->type != TK_OPTION_END; specPtr++, optionPtr++) {

optionPtr->specPtr = specPtr;

optionPtr->dbNameUID = NULL;

optionPtr->dbClassUID = NULL;

optionPtr->defaultPtr = NULL;

optionPtr->extra.monoColorPtr = NULL;

optionPtr->flags = 0;

if (specPtr->type == TK_OPTION_SYNONYM) {

/*

* This is a synonym option; find the original option that it refers

* to and create a pointer from the synonym to the origin.

*/

for (specPtr2 = templatePtr, i = 0; ; specPtr2++, i++) {

if (specPtr2->type == TK_OPTION_END) {

Tcl_Panic("Tk_CreateOptionTable couldn't find synonym");

}

if (strcmp(specPtr2->optionName,

(char *)specPtr->clientData) == 0) {

optionPtr->extra.synonymPtr = tablePtr->options + i;

break;

}

}

} else {

if (specPtr->dbName != NULL) {

optionPtr->dbNameUID = Tk_GetUid(specPtr->dbName);

}

if (specPtr->dbClass != NULL) {

optionPtr->dbClassUID = Tk_GetUid(specPtr->dbClass);

}

if (specPtr->defValue != NULL) {

optionPtr->defaultPtr = Tcl_NewStringObj(specPtr->defValue, TCL_INDEX_NONE);

Tcl_IncrRefCount(optionPtr->defaultPtr);

}

if (((specPtr->type == TK_OPTION_COLOR)

|| (specPtr->type == TK_OPTION_BORDER))

&& (specPtr->clientData != NULL)) {

optionPtr->extra.monoColorPtr =

Tcl_NewStringObj((const char *)specPtr->clientData, TCL_INDEX_NONE);

Tcl_IncrRefCount(optionPtr->extra.monoColorPtr);

}

if (specPtr->type == TK_OPTION_CUSTOM) {

/*

* Get the custom parsing, etc., functions.

*/

optionPtr->extra.custom = (const Tk_ObjCustomOption *)specPtr->clientData;

}

}

if (((specPtr->type == TK_OPTION_STRING)

&& (specPtr->internalOffset != TCL_INDEX_NONE))

|| (specPtr->type == TK_OPTION_COLOR)

|| (specPtr->type == TK_OPTION_FONT)

|| (specPtr->type == TK_OPTION_BITMAP)

|| (specPtr->type == TK_OPTION_BORDER)

|| (specPtr->type == TK_OPTION_CURSOR)

|| (specPtr->type == TK_OPTION_CUSTOM)) {

optionPtr->flags |= OPTION_NEEDS_FREEING;

}

}

tablePtr->hashEntryPtr = hashEntryPtr;

Tcl_SetHashValue(hashEntryPtr, tablePtr);

/*

* Finally, check to see if this template chains to another template with

* additional options. If so, call ourselves recursively to create the

* next table(s).

*/

if (specPtr->clientData != NULL) {

tablePtr->nextPtr = (OptionTable *)

Tk_CreateOptionTable(interp, (Tk_OptionSpec *)specPtr->clientData);

}

return (Tk_OptionTable)tablePtr;

}



/*

*----------------------------------------------------------------------

*

* Tk_DeleteOptionTable --

*

* Called to release resources used by an option table when the table is

* no longer needed.

*

* Results:

* None.

*

* Side effects:

* The option table and associated resources (such as additional option

* tables chained off it) are destroyed.

*

*----------------------------------------------------------------------

*/

void

Tk_DeleteOptionTable(

Tk_OptionTable optionTable) /* The option table to delete. */

{

OptionTable *tablePtr = (OptionTable *)optionTable;

Option *optionPtr;

size_t count;

if (tablePtr->refCount-- > 1) {

return;

}

if (tablePtr->nextPtr != NULL) {

Tk_DeleteOptionTable((Tk_OptionTable)tablePtr->nextPtr);

}

for (count = tablePtr->numOptions, optionPtr = tablePtr->options;

count > 0; count--, optionPtr++) {

if (optionPtr->defaultPtr != NULL) {

Tcl_DecrRefCount(optionPtr->defaultPtr);

}

if (((optionPtr->specPtr->type == TK_OPTION_COLOR)

|| (optionPtr->specPtr->type == TK_OPTION_BORDER))

&& (optionPtr->extra.monoColorPtr != NULL)) {

Tcl_DecrRefCount(optionPtr->extra.monoColorPtr);

}

}

Tcl_DeleteHashEntry(tablePtr->hashEntryPtr);

ckfree(tablePtr);

}



/*

*--------------------------------------------------------------

*

* Tk_InitOptions --

*

* This function is invoked when an object such as a widget is created.

* It supplies an initial value for each configuration option (the value

* may come from the option database, a system default, or the default in

* the option table).

*

* Results:

* The return value is TCL_OK if the function completed successfully, and

* TCL_ERROR if one of the initial values was bogus. If an error occurs

* and interp isn't NULL, then an error message will be left in its

* result.

*

* Side effects:

* Fields of recordPtr are filled in with initial values.

*

*--------------------------------------------------------------

*/

int

Tk_InitOptions(

Tcl_Interp *interp, /* Interpreter for error reporting. NULL means

* don't leave an error message. */

void *recordPtr, /* Pointer to the record to configure. Note:

* the caller should have properly initialized

* the record with NULL pointers for each

* option value. */

Tk_OptionTable optionTable, /* The token which matches the config specs

* for the widget in question. */

Tk_Window tkwin) /* Certain options types (such as

* TK_OPTION_COLOR) need fields out of the

* window they are used in to be able to

* calculate their values. Not needed unless

* one of these options is in the configSpecs

* record. */

{

OptionTable *tablePtr = (OptionTable *)optionTable;

Option *optionPtr;

size_t count;

Tk_Uid value;

Tcl_Obj *valuePtr;

enum {

OPTION_DATABASE, SYSTEM_DEFAULT, TABLE_DEFAULT

} source;

/*

* If this table chains to other tables, handle their initialization

* first. That way, if both tables refer to the same field of the record,

* the value in the first table will win.

*/

if (tablePtr->nextPtr != NULL) {

if (Tk_InitOptions(interp, recordPtr,

(Tk_OptionTable)tablePtr->nextPtr, tkwin) != TCL_OK) {

return TCL_ERROR;

}

}

/*

* Iterate over all of the options in the table, initializing each in

* turn.

*/

for (optionPtr = tablePtr->options, count = tablePtr->numOptions;

count > 0; optionPtr++, count--) {

/*

* If we specify TK_OPTION_DONT_SET_DEFAULT, then the user has

* processed and set a default for this already.

*/

if ((optionPtr->specPtr->type == TK_OPTION_SYNONYM) ||

(optionPtr->specPtr->flags & TK_OPTION_DONT_SET_DEFAULT)) {

continue;

}

source = TABLE_DEFAULT;

/*

* We look in three places for the initial value, using the first

* non-NULL value that we find. First, check the option database.

*/

valuePtr = NULL;

if (optionPtr->dbNameUID != NULL) {

value = Tk_GetOption(tkwin, optionPtr->dbNameUID,

optionPtr->dbClassUID);

if (value != NULL) {

valuePtr = Tcl_NewStringObj(value, TCL_INDEX_NONE);

source = OPTION_DATABASE;

}

}

/*

* Second, check for a system-specific default value.

*/

if ((valuePtr == NULL)

&& (optionPtr->dbNameUID != NULL)) {

valuePtr = Tk_GetSystemDefault(tkwin, optionPtr->dbNameUID,

optionPtr->dbClassUID);

if (valuePtr != NULL) {

source = SYSTEM_DEFAULT;

}

}

/*

* Third and last, use the default value supplied by the option table.

* In the case of color objects, we pick one of two values depending

* on whether the screen is mono or color.

*/

if (valuePtr == NULL) {

if ((tkwin != NULL)

&& ((optionPtr->specPtr->type == TK_OPTION_COLOR)

|| (optionPtr->specPtr->type == TK_OPTION_BORDER))

&& (Tk_Depth(tkwin) <= 1)

&& (optionPtr->extra.monoColorPtr != NULL)) {

valuePtr = optionPtr->extra.monoColorPtr;

} else {

valuePtr = optionPtr->defaultPtr;

}

}

if (valuePtr == NULL) {

continue;

}

/*

* Bump the reference count on valuePtr, so that it is strongly

* referenced here, and will be properly free'd when finished,

* regardless of what DoObjConfig does.

*/

Tcl_IncrRefCount(valuePtr);

if (DoObjConfig(interp, recordPtr, optionPtr, valuePtr, tkwin,

NULL) != TCL_OK) {

if (interp != NULL) {

char msg[200];

switch (source) {

case OPTION_DATABASE:

snprintf(msg, 200, "\n (database entry for \"%.50s\")",

optionPtr->specPtr->optionName);

break;

case SYSTEM_DEFAULT:

snprintf(msg, 200, "\n (system default for \"%.50s\")",

optionPtr->specPtr->optionName);

break;

case TABLE_DEFAULT:

snprintf(msg, 200, "\n (default value for \"%.50s\")",

optionPtr->specPtr->optionName);

}

if (tkwin != NULL) {

snprintf(msg + strlen(msg) - 1, 200 - (strlen(msg) - 1), " in widget \"%.50s\")",

Tk_PathName(tkwin));

}

Tcl_AddErrorInfo(interp, msg);

}

Tcl_DecrRefCount(valuePtr);

return TCL_ERROR;

}

Tcl_DecrRefCount(valuePtr);

}

return TCL_OK;

}



/*

*--------------------------------------------------------------

*

* DoObjConfig --

*

* This function applies a new value for a configuration option to the

* record being configured.

*

* Results:

* The return value is TCL_OK if the function completed successfully. If

* an error occurred then TCL_ERROR is returned and an error message is

* left in interp's result, if interp isn't NULL. In addition, if

* oldValuePtrPtr isn't NULL then it *oldValuePtrPtr is filled in with a

* pointer to the option's old value.

*

* Side effects:

* RecordPtr gets modified to hold the new value in the form of a

* Tcl_Obj, an internal representation, or both. The old value is freed

* if oldValuePtrPtr is NULL.

*

*--------------------------------------------------------------

*/

static int

DoObjConfig(

Tcl_Interp *interp, /* Interpreter for error reporting. If NULL,

* then no message is left if an error

* occurs. */

void *recordPtr, /* The record to modify to hold the new option

* value. */

Option *optionPtr, /* Pointer to information about the option. */

Tcl_Obj *valuePtr, /* New value for option. */

Tk_Window tkwin, /* Window in which option will be used (needed

* to allocate resources for some options).

* May be NULL if the option doesn't require

* window-related resources. */

Tk_SavedOption *savedOptionPtr)

/* If NULL, the old value for the option will

* be freed. If non-NULL, the old value will

* be stored here, and it becomes the property

* of the caller (the caller must eventually

* free the old value). */

{

Tcl_Obj **slotPtrPtr, *oldPtr;

void *internalPtr; /* Points to location in record where internal

* representation of value should be stored,

* or NULL. */

void *oldInternalPtr; /* Points to location in which to save old

* internal representation of value. */

Tk_SavedOption internal; /* Used to save the old internal

* representation of the value if

* savedOptionPtr is NULL. */

const Tk_OptionSpec *specPtr;

/*

* Save the old object form for the value, if there is one.

*/

specPtr = optionPtr->specPtr;

if (specPtr->objOffset != TCL_INDEX_NONE) {

slotPtrPtr = (Tcl_Obj **)((char *)recordPtr + specPtr->objOffset);

oldPtr = *slotPtrPtr;

} else {

slotPtrPtr = NULL;

oldPtr = NULL;

}

/*

* Apply the new value in a type-specific way. Also remember the old

* object and internal forms, if they exist.

*/

if (specPtr->internalOffset != TCL_INDEX_NONE) {

internalPtr = (char *)recordPtr + specPtr->internalOffset;

} else {

internalPtr = NULL;

}

if (savedOptionPtr != NULL) {

savedOptionPtr->optionPtr = optionPtr;

savedOptionPtr->valuePtr = oldPtr;

oldInternalPtr = (char *)&savedOptionPtr->internalForm;

} else {

oldInternalPtr = (char *)&internal.internalForm;

}

bool nullOK = (optionPtr->specPtr->flags & TCL_NULL_OK) != 0;

switch (optionPtr->specPtr->type) {

case TK_OPTION_BOOLEAN: {

int newBool;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newBool = -1;

} else if (Tcl_GetBooleanFromObj(nullOK ? NULL : interp, valuePtr, &newBool) != TCL_OK) {

if (nullOK && interp) {

Tcl_AppendResult(interp, "expected boolean value or \"\" but got \"",

Tcl_GetString(valuePtr), "\"", (char *)NULL);

}

return TCL_ERROR;

}

if (internalPtr != NULL) {

if (optionPtr->specPtr->flags & TYPE_MASK) {

if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(char)) {

*((char *)oldInternalPtr) = *((char *)internalPtr);

*((char *)internalPtr) = (char)newBool;

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(short)) {

*((short *)oldInternalPtr) = *((short *)internalPtr);

*((short *)internalPtr) = (short)newBool;

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_BOOLEAN");

}

} else {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = newBool;

}

}

break;

}

case TK_OPTION_INT: {

int newInt;

if ((optionPtr->specPtr->flags & TYPE_MASK) == 0) {

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newInt = INT_MIN;

} else if (Tcl_GetIntFromObj(nullOK ? NULL : interp, valuePtr, &newInt) != TCL_OK) {

invalidIntValue:

if (nullOK && interp) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"expected integer or \"\" but got \"%.50s\"", Tcl_GetString(valuePtr)));

Tcl_SetErrorCode(interp, "TCL", "VALUE", "NUMBER", (char *)NULL);

}

return TCL_ERROR;

}

if (internalPtr != NULL) {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = newInt;

}

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TYPE_MASK) {

Tcl_WideInt newWideInt;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newWideInt = (sizeof(long) > sizeof(int)) ? LONG_MIN : LLONG_MIN;

} else if (Tcl_GetWideIntFromObj(nullOK ? NULL : interp, valuePtr, &newWideInt) != TCL_OK) {

goto invalidIntValue;

}

if (internalPtr != NULL) {

if (sizeof(long) > sizeof(int)) {

*((long *)oldInternalPtr) = *((long *)internalPtr);

*((long *)internalPtr) = (long)newWideInt;

} else {

*((long long *)oldInternalPtr) = *((long long *)internalPtr);

*((long long *)internalPtr) = (long long)newWideInt;

}

}

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_INT");

}

break;

}

case TK_OPTION_INDEX: {

Tcl_Size newIndex;

if (TkGetIntForIndex(valuePtr, TCL_INDEX_NONE, 0, &newIndex) != TCL_OK) {

if (interp) {

Tcl_AppendResult(interp, "bad index \"", Tcl_GetString(valuePtr),

"\": must be integer?[+-]integer?, end?[+-]integer?, or \"\"", (char *)NULL);

}

return TCL_ERROR;

}

if (newIndex < INT_MIN) {

newIndex = INT_MIN;

} else if (newIndex > INT_MAX) {

newIndex = INT_MAX;

}

if (internalPtr != NULL) {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = (int)newIndex;

}

break;

}

case TK_OPTION_DOUBLE: {

double newDbl;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

#if defined(NAN)

newDbl = NAN;

#else

newDbl = 0.0;

#endif

} else {

if (Tcl_GetDoubleFromObj(nullOK ? NULL : interp, valuePtr, &newDbl) != TCL_OK) {

if (nullOK && interp) {

Tcl_Obj *msg = Tcl_NewStringObj("expected floating-point number or \"\" but got \"", TCL_INDEX_NONE);

Tcl_AppendLimitedToObj(msg, Tcl_GetString(valuePtr), TCL_INDEX_NONE, 50, "");

Tcl_AppendToObj(msg, "\"", TCL_INDEX_NONE);

Tcl_SetObjResult(interp, msg);

Tcl_SetErrorCode(interp, "TCL", "VALUE", "NUMBER", (char *)NULL);

}

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((double *)oldInternalPtr) = *((double *)internalPtr);

*((double *)internalPtr) = newDbl;

}

break;

}

case TK_OPTION_STRING: {

char *newStr;

const char *value;

Tcl_Size length;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

}

if (internalPtr != NULL) {

if (valuePtr != NULL) {

value = Tcl_GetStringFromObj(valuePtr, &length);

newStr = (char *)ckalloc(length + 1);

strcpy(newStr, value);

} else {

newStr = NULL;

}

*((char **)oldInternalPtr) = *((char **)internalPtr);

*((char **)internalPtr) = newStr;

}

break;

}

case TK_OPTION_STRING_TABLE: {

int newValue;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newValue = -1;

} else {

if (Tcl_GetIndexFromObjStruct(interp, valuePtr,

optionPtr->specPtr->clientData, sizeof(char *),

optionPtr->specPtr->optionName+1, (nullOK ? TCL_NULL_OK : 0), &newValue) != TCL_OK) {

return TCL_ERROR;

}

if (slotPtrPtr != NULL && valuePtr != NULL) {

valuePtr = Tcl_DuplicateObj(valuePtr);

Tcl_InvalidateStringRep(valuePtr);

}

}

if (internalPtr != NULL) {

if (optionPtr->specPtr->flags & TYPE_MASK) {

if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(char)) {

*((char *)oldInternalPtr) = *((char *)internalPtr);

*((char *)internalPtr) = (char)newValue;

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(short)) {

*((short *)oldInternalPtr) = *((short *)internalPtr);

*((short *)internalPtr) = (short)newValue;

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_STRING_TABLE");

}

} else {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = newValue;

}

}

break;

}

case TK_OPTION_COLOR: {

XColor *newPtr;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newPtr = NULL;

} else {

newPtr = Tk_AllocColorFromObj(interp, tkwin, valuePtr);

if (newPtr == NULL) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((XColor **)oldInternalPtr) = *((XColor **)internalPtr);

*((XColor **)internalPtr) = newPtr;

}

break;

}

case TK_OPTION_FONT: {

Tk_Font newFont;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newFont = NULL;

} else {

newFont = Tk_AllocFontFromObj(interp, tkwin, valuePtr);

if (newFont == NULL) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((Tk_Font *)oldInternalPtr) = *((Tk_Font *)internalPtr);

*((Tk_Font *)internalPtr) = newFont;

}

break;

}

case TK_OPTION_STYLE: {

Tk_Style newStyle;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newStyle = NULL;

} else {

newStyle = Tk_AllocStyleFromObj(interp, valuePtr);

if (newStyle == NULL) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((Tk_Style *)oldInternalPtr) = *((Tk_Style *)internalPtr);

*((Tk_Style *)internalPtr) = newStyle;

}

break;

}

case TK_OPTION_BITMAP: {

Pixmap newBitmap;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newBitmap = None;

} else {

newBitmap = Tk_AllocBitmapFromObj(interp, tkwin, valuePtr);

if (newBitmap == None) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((Pixmap *)oldInternalPtr) = *((Pixmap *)internalPtr);

*((Pixmap *)internalPtr) = newBitmap;

}

break;

}

case TK_OPTION_BORDER: {

Tk_3DBorder newBorder;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newBorder = NULL;

} else {

newBorder = Tk_Alloc3DBorderFromObj(interp, tkwin, valuePtr);

if (newBorder == NULL) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((Tk_3DBorder *)oldInternalPtr) = *((Tk_3DBorder *)internalPtr);

*((Tk_3DBorder *)internalPtr) = newBorder;

}

break;

}

case TK_OPTION_RELIEF: {

int newRelief;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newRelief = TK_RELIEF_NULL;

} else if (Tcl_GetIndexFromObj(interp, valuePtr, tkReliefStrings,

"relief", (nullOK ? TCL_NULL_OK : 0), &newRelief) != TCL_OK) {

return TCL_ERROR;

}

if (internalPtr != NULL) {

if (optionPtr->specPtr->flags & TYPE_MASK) {

if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(char)) {

*((char *)oldInternalPtr) = *((char *)internalPtr);

*((char *)internalPtr) = (char)newRelief;

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(short)) {

*((short *)oldInternalPtr) = *((short *)internalPtr);

*((short *)internalPtr) = (short)newRelief;

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_RELIEF");

}

} else {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = newRelief;

}

}

if (slotPtrPtr != NULL && valuePtr != NULL) {

valuePtr = Tcl_DuplicateObj(valuePtr);

Tcl_InvalidateStringRep(valuePtr);

}

break;

}

case TK_OPTION_CURSOR: {

Tk_Cursor newCursor;

if (nullOK && TkObjIsEmpty(valuePtr)) {

newCursor = NULL;

valuePtr = NULL;

} else {

newCursor = Tk_AllocCursorFromObj(interp, tkwin, valuePtr);

if (newCursor == NULL) {

return TCL_ERROR;

}

}

if (internalPtr != NULL) {

*((Tk_Cursor *)oldInternalPtr) = *((Tk_Cursor *)internalPtr);

*((Tk_Cursor *)internalPtr) = newCursor;

}

Tk_DefineCursor(tkwin, newCursor);

break;

}

case TK_OPTION_JUSTIFY: {

int newJustify;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newJustify = -1;

} else if (Tcl_GetIndexFromObj(interp, valuePtr, tkJustifyStrings,

"justification", (nullOK ? TCL_NULL_OK : 0), &newJustify) != TCL_OK) {

return TCL_ERROR;

}

if (internalPtr != NULL) {

if (optionPtr->specPtr->flags & TYPE_MASK) {

if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(char)) {

*((char *)oldInternalPtr) = *((char *)internalPtr);

*((char *)internalPtr) = (char)newJustify;

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(short)) {

*((short *)oldInternalPtr) = *((short *)internalPtr);

*((short *)internalPtr) = (short)newJustify;

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_JUSTIFY");

}

} else {

*((int *)oldInternalPtr) = *((int *)internalPtr);

*((int *)internalPtr) = newJustify;

}

}

if (slotPtrPtr != NULL && valuePtr != NULL) {

valuePtr = Tcl_DuplicateObj(valuePtr);

Tcl_InvalidateStringRep(valuePtr);

}

break;

}

case TK_OPTION_ANCHOR: {

int newAnchor;

if (nullOK && TkObjIsEmpty(valuePtr)) {

valuePtr = NULL;

newAnchor = -1;

} else if (Tcl_GetIndexFromObj(interp, valuePtr, tkAnchorStrings,

"anchor", (nullOK ? TCL_NULL_OK : 0), &newAnchor) != TCL_OK) {

return TCL_ERROR;

}

if (internalPtr != NULL) {

if (optionPtr->specPtr->flags & TYPE_MASK) {

if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(char)) {

*((char *)oldInternalPtr) = *((char *)internalPtr);

*((char *)internalPtr) = (char)newAnchor;

} else if ((optionPtr->specPtr->flags & TYPE_MASK) == TK_OPTION_VAR(short)) {

*((short *)oldInternalPtr) = *((short *)internalPtr);

*((short *)internalPtr) = (short)newAnchor;

} else {

Tcl_Panic("Invalid flags for %s", "TK_OPTION_JUSTIFY");

}