static void
GenerateEditEvent(
int flag)
{
XVirtualEvent event;
Point where;
Tk_Window tkwin;
Window window;
TkDisplay *dispPtr;
if (TkMacHaveAppearance() >= 0x110) {
window = TkMacGetXWindow(FrontNonFloatingWindow());
} else {
window = TkMacGetXWindow(FrontWindow());
}
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, window);
tkwin = (Tk_Window) ((TkWindow *) tkwin)->dispPtr->focusPtr;
if (tkwin == NULL) {
return;
}
event.type = VirtualEvent;
event.serial = Tk_Display(tkwin)->request;
event.send_event = false;
event.display = Tk_Display(tkwin);
event.event = Tk_WindowId(tkwin);
event.root = XRootWindow(Tk_Display(tkwin), 0);
event.subwindow = None;
event.time = TkpGetMS();
GetMouse(&where);
tkwin = Tk_TopCoordsToWindow(tkwin, where.h, where.v,
&event.x, &event.y);
LocalToGlobal(&where);
event.x_root = where.h;
event.y_root = where.v;
event.state = TkMacButtonKeyState();
event.same_screen = true;
switch (flag) {
case EDIT_CUT:
event.name = Tk_GetUid("Cut");
break;
case EDIT_COPY:
event.name = Tk_GetUid("Copy");
break;
case EDIT_PASTE:
event.name = Tk_GetUid("Paste");
break;
case EDIT_CLEAR:
event.name = Tk_GetUid("Clear");
break;
}
Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
}
static void
GenerateEditEvent(
int flag)
{
XVirtualEvent event;
int x, y;
Tk_Window tkwin;
Window window;
TkDisplay *dispPtr;
window = TkMacOSXGetXWindow(ActiveNonFloatingWindow());
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, window);
tkwin = (Tk_Window) ((TkWindow *) tkwin)->dispPtr->focusPtr;
if (tkwin == NULL) {
return;
}
bzero(&event, sizeof(XVirtualEvent));
event.type = VirtualEvent;
event.serial = Tk_Display(tkwin)->request;
event.send_event = false;
event.display = Tk_Display(tkwin);
event.event = Tk_WindowId(tkwin);
event.root = XRootWindow(Tk_Display(tkwin), 0);
event.subwindow = None;
event.time = TkpGetMS();
XQueryPointer(NULL, None, NULL, NULL,
&event.x_root, &event.y_root, &x, &y, &event.state);
Tk_TopCoordsToWindow(tkwin, x, y, &event.x, &event.y);
event.same_screen = true;
switch (flag) {
case EDIT_CUT:
event.name = Tk_GetUid("Cut");
break;
case EDIT_COPY:
event.name = Tk_GetUid("Copy");
break;
case EDIT_PASTE:
event.name = Tk_GetUid("Paste");
break;
case EDIT_CLEAR:
event.name = Tk_GetUid("Clear");
break;
}
Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
}
void
TkpDefineNativeBitmaps(void)
{
Tcl_HashTable *tablePtr = TkGetBitmapPredefTable();
BuiltInIcon *builtInPtr;
for (builtInPtr = builtInIcons; builtInPtr->name != NULL; builtInPtr++) {
Tcl_HashEntry *predefHashPtr;
const char * name;
int isNew;
name = Tk_GetUid(builtInPtr->name);
predefHashPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew);
if (isNew) {
TkPredefBitmap *predefPtr = (TkPredefBitmap *)
ckalloc(sizeof(TkPredefBitmap));
NativeIcon *nativeIconPtr = (NativeIcon *)
ckalloc(sizeof(NativeIcon));
nativeIconPtr->id = builtInPtr->id;
nativeIconPtr->type = builtInPtr->type;
predefPtr->source = (char *) nativeIconPtr;
predefPtr->width = builtInPtr->size;
predefPtr->height = builtInPtr->size;
predefPtr->native = 1;
Tcl_SetHashValue(predefHashPtr, predefPtr);
}
}
}
TkScrollbar *
TkpCreateScrollbar(
Tk_Window tkwin) /* New Tk Window. */
{
MacScrollbar * macScrollPtr;
TkWindow *winPtr = (TkWindow *)tkwin;
if (scrollActionProc == NULL) {
scrollActionProc = NewControlActionProc(ScrollbarActionProc);
thumbActionProc = NewThumbActionProc(ThumbActionProc);
}
macScrollPtr = (MacScrollbar *) ckalloc(sizeof(MacScrollbar));
macScrollPtr->sbHandle = NULL;
macScrollPtr->macFlags = 0;
Tk_CreateEventHandler(tkwin, ActivateMask|ExposureMask|
StructureNotifyMask|FocusChangeMask,
ScrollbarEventProc, (ClientData) macScrollPtr);
if (!Tcl_GetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL)) {
Tcl_SetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL,
(ClientData)1);
TkCreateBindingProcedure(winPtr->mainPtr->interp,
winPtr->mainPtr->bindingTable,
(ClientData)Tk_GetUid("Scrollbar"), "<ButtonPress>",
ScrollbarBindProc, NULL, NULL);
}
return (TkScrollbar *) macScrollPtr;
}
void
Boot_Tix (pTHX)
{
install_vtab("TixVtab",TixVGet(),sizeof(TixVtab));
install_vtab("TixintVtab",TixintVGet(),sizeof(TixintVtab));
install_vtab("TiximgxpmVtab",TiximgxpmVGet(),sizeof(TiximgxpmVtab));
tixNormalUid = Tk_GetUid("normal");
tixDisabledUid = Tk_GetUid("disabled");
tixCellUid = Tk_GetUid("cell");
tixRowUid = Tk_GetUid("row");
tixColumnUid = Tk_GetUid("column");
Tix_AddDItemType(&tix_TextItemType);
Tix_AddDItemType(&tix_ImageItemType);
Tix_AddDItemType(&tix_ImageTextItemType);
Tix_AddDItemType(&tix_WindowItemType);
}
/* TtkSendVirtualEvent --
* Send a virtual event notification to the specified target window.
* Equivalent to "event generate $tgtWindow <<$eventName>>"
*
* Note that we use Tk_QueueWindowEvent, not Tk_HandleEvent,
* so this routine does not reenter the interpreter.
*/
void TtkSendVirtualEvent(Tk_Window tgtWin, const char *eventName)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.xany.type = VirtualEvent;
event.xany.serial = NextRequest(Tk_Display(tgtWin));
event.xany.send_event = False;
event.xany.window = Tk_WindowId(tgtWin);
event.xany.display = Tk_Display(tgtWin);
((XVirtualEvent *) &event)->name = Tk_GetUid(eventName);
Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
}
static void
GetTkFontAttributes(
XftFont *ftFont,
TkFontAttributes *faPtr)
{
const char *family = "Unknown";
const char *const *familyPtr = &family;
int weight, slant, size, pxsize;
double ptsize;
(void) XftPatternGetString(ftFont->pattern, XFT_FAMILY, 0, familyPtr);
if (XftPatternGetDouble(ftFont->pattern, XFT_SIZE, 0,
&ptsize) == XftResultMatch) {
size = (int) ptsize;
} else if (XftPatternGetInteger(ftFont->pattern, XFT_PIXEL_SIZE, 0,
&pxsize) == XftResultMatch) {
size = -pxsize;
} else {
size = 12;
}
if (XftPatternGetInteger(ftFont->pattern, XFT_WEIGHT, 0,
&weight) != XftResultMatch) {
weight = XFT_WEIGHT_MEDIUM;
}
if (XftPatternGetInteger(ftFont->pattern, XFT_SLANT, 0,
&slant) != XftResultMatch) {
slant = XFT_SLANT_ROMAN;
}
#if DEBUG_FONTSEL
printf("family %s size %d weight %d slant %d\n",
family, size, weight, slant);
#endif /* DEBUG_FONTSEL */
faPtr->family = Tk_GetUid(family);
faPtr->size = size;
faPtr->weight = (weight > XFT_WEIGHT_MEDIUM) ? TK_FW_BOLD : TK_FW_NORMAL;
faPtr->slant = (slant > XFT_SLANT_ROMAN) ? TK_FS_ITALIC : TK_FS_ROMAN;
faPtr->underline = 0;
faPtr->overstrike = 0;
}
static int
GenerateToolbarButtonEvent(
MouseEventData *medPtr)
{
Tk_Window rootwin, tkwin = NULL;
TkDisplay *dispPtr;
TkWindow *winPtr;
XVirtualEvent event;
dispPtr = TkGetDisplayList();
rootwin = Tk_IdToWindow(dispPtr->display, medPtr->window);
if (rootwin) {
tkwin = Tk_TopCoordsToWindow(rootwin,
medPtr->local.h, medPtr->local.v, &event.x, &event.y);
}
if (!tkwin) {
return true;
}
winPtr = (TkWindow *) tkwin;
bzero(&event, sizeof(XVirtualEvent));
event.type = VirtualEvent;
event.serial = LastKnownRequestProcessed(winPtr->display);
event.send_event = false;
event.display = winPtr->display;
event.event = winPtr->window;
event.root = XRootWindow(winPtr->display, 0);
event.subwindow = None;
event.time = TkpGetMS();
event.x_root = medPtr->global.h;
event.y_root = medPtr->global.v;
event.state = medPtr->state;
event.same_screen = true;
event.name = Tk_GetUid("ToolbarButton");
Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
return true;
}
int
Tk_ParseArgv(
Tcl_Interp *interp, /* Place to store error message. */
Tk_Window tkwin, /* Window to use for setting Tk options. NULL
* means ignore Tk option specs. */
int *argcPtr, /* Number of arguments in argv. Modified to
* hold # args left in argv at end. */
CONST char **argv, /* Array of arguments. Modified to hold those
* that couldn't be processed here. */
Tk_ArgvInfo *argTable, /* Array of option descriptions */
int flags) /* Or'ed combination of various flag bits,
* such as TK_ARGV_NO_DEFAULTS. */
{
register Tk_ArgvInfo *infoPtr;
/* Pointer to the current entry in the table
* of argument descriptions. */
Tk_ArgvInfo *matchPtr; /* Descriptor that matches current argument. */
CONST char *curArg; /* Current argument */
register char c; /* Second character of current arg (used for
* quick check for matching; use 2nd char.
* because first char. will almost always be
* '-'). */
int srcIndex; /* Location from which to read next argument
* from argv. */
int dstIndex; /* Index into argv to which next unused
* argument should be copied (never greater
* than srcIndex). */
int argc; /* # arguments in argv still to process. */
size_t length; /* Number of characters in current argument. */
int i;
if (flags & TK_ARGV_DONT_SKIP_FIRST_ARG) {
srcIndex = dstIndex = 0;
argc = *argcPtr;
} else {
srcIndex = dstIndex = 1;
argc = *argcPtr-1;
}
while (argc > 0) {
curArg = argv[srcIndex];
srcIndex++;
argc--;
length = strlen(curArg);
if (length > 0) {
c = curArg[1];
} else {
c = 0;
}
/*
* Loop throught the argument descriptors searching for one with the
* matching key string. If found, leave a pointer to it in matchPtr.
*/
matchPtr = NULL;
for (i = 0; i < 2; i++) {
if (i == 0) {
infoPtr = argTable;
} else {
infoPtr = defaultTable;
}
for (; (infoPtr != NULL) && (infoPtr->type != TK_ARGV_END);
infoPtr++) {
if (infoPtr->key == NULL) {
continue;
}
if ((infoPtr->key[1] != c)
|| (strncmp(infoPtr->key, curArg, length) != 0)) {
continue;
}
if ((tkwin == NULL)
&& ((infoPtr->type == TK_ARGV_CONST_OPTION)
|| (infoPtr->type == TK_ARGV_OPTION_VALUE)
|| (infoPtr->type == TK_ARGV_OPTION_NAME_VALUE))) {
continue;
}
if (infoPtr->key[length] == 0) {
matchPtr = infoPtr;
goto gotMatch;
}
if (flags & TK_ARGV_NO_ABBREV) {
continue;
}
if (matchPtr != NULL) {
Tcl_AppendResult(interp, "ambiguous option \"", curArg,
"\"", NULL);
return TCL_ERROR;
}
matchPtr = infoPtr;
}
}
if (matchPtr == NULL) {
/*
* Unrecognized argument. Just copy it down, unless the caller
* prefers an error to be registered.
*/
if (flags & TK_ARGV_NO_LEFTOVERS) {
Tcl_AppendResult(interp, "unrecognized argument \"",
curArg, "\"", NULL);
return TCL_ERROR;
}
argv[dstIndex] = curArg;
dstIndex++;
continue;
}
/*
* Take the appropriate action based on the option type
*/
gotMatch:
infoPtr = matchPtr;
switch (infoPtr->type) {
case TK_ARGV_CONSTANT:
*((int *) infoPtr->dst) = PTR2INT(infoPtr->src);
break;
case TK_ARGV_INT:
if (argc == 0) {
goto missingArg;
} else {
char *endPtr;
*((int *) infoPtr->dst) = strtol(argv[srcIndex], &endPtr, 0);
if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
Tcl_AppendResult(interp,"expected integer argument for \"",
infoPtr->key, "\" but got \"", argv[srcIndex],
"\"", NULL);
return TCL_ERROR;
}
srcIndex++;
argc--;
}
break;
case TK_ARGV_STRING:
if (argc == 0) {
goto missingArg;
}
*((CONST char **)infoPtr->dst) = argv[srcIndex];
srcIndex++;
argc--;
break;
case TK_ARGV_UID:
if (argc == 0) {
goto missingArg;
}
*((Tk_Uid *)infoPtr->dst) = Tk_GetUid(argv[srcIndex]);
srcIndex++;
argc--;
break;
case TK_ARGV_REST:
*((int *) infoPtr->dst) = dstIndex;
goto argsDone;
case TK_ARGV_FLOAT:
if (argc == 0) {
goto missingArg;
} else {
char *endPtr;
*((double *) infoPtr->dst) = strtod(argv[srcIndex], &endPtr);
if ((endPtr == argv[srcIndex]) || (*endPtr != 0)) {
Tcl_AppendResult(interp, "expected floating-point ",
"argument for \"", infoPtr->key, "\" but got \"",
argv[srcIndex], "\"", NULL);
return TCL_ERROR;
}
srcIndex++;
argc--;
}
break;
case TK_ARGV_FUNC: {
typedef int (ArgvFunc)(char *, char *, CONST char *);
ArgvFunc *handlerProc = (ArgvFunc *) infoPtr->src;
if ((*handlerProc)(infoPtr->dst, infoPtr->key, argv[srcIndex])) {
srcIndex++;
argc--;
}
break;
}
case TK_ARGV_GENFUNC: {
typedef int (ArgvGenFunc)(char *, Tcl_Interp *, char *, int,
CONST char **);
ArgvGenFunc *handlerProc = (ArgvGenFunc *) infoPtr->src;
argc = (*handlerProc)(infoPtr->dst, interp, infoPtr->key,
argc, argv+srcIndex);
if (argc < 0) {
return TCL_ERROR;
}
break;
}
case TK_ARGV_HELP:
PrintUsage(interp, argTable, flags);
return TCL_ERROR;
case TK_ARGV_CONST_OPTION:
Tk_AddOption(tkwin, infoPtr->dst, infoPtr->src,
TK_INTERACTIVE_PRIO);
break;
case TK_ARGV_OPTION_VALUE:
if (argc < 1) {
goto missingArg;
}
Tk_AddOption(tkwin, infoPtr->dst, argv[srcIndex],
TK_INTERACTIVE_PRIO);
srcIndex++;
argc--;
break;
case TK_ARGV_OPTION_NAME_VALUE:
if (argc < 2) {
Tcl_AppendResult(interp, "\"", curArg,
"\" option requires two following arguments", NULL);
return TCL_ERROR;
}
Tk_AddOption(tkwin, argv[srcIndex], argv[srcIndex+1],
TK_INTERACTIVE_PRIO);
srcIndex += 2;
argc -= 2;
break;
default: {
char buf[64 + TCL_INTEGER_SPACE];
sprintf(buf, "bad argument type %d in Tk_ArgvInfo", infoPtr->type);
Tcl_SetResult(interp, buf, TCL_VOLATILE);
return TCL_ERROR;
}
}
}
/*
* If we broke out of the loop because of an OPT_REST argument, copy the
* remaining arguments down.
*/
argsDone:
while (argc) {
argv[dstIndex] = argv[srcIndex];
srcIndex++;
dstIndex++;
argc--;
}
argv[dstIndex] = NULL;
*argcPtr = dstIndex;
return TCL_OK;
missingArg:
Tcl_AppendResult(interp, "\"", curArg,
"\" option requires an additional argument", NULL);
return TCL_ERROR;
}
void defineTclutilBitmaps(Tcl_Interp *interp) {
#include "ar6_6_4.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar6_6_4"), (char*)ar6_6_4_bits, ar6_6_4_width, ar6_6_4_height);
#include "arrowboth.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("arrowboth"), (char*)arrowboth_bits, arrowboth_width, arrowboth_height);
#include "files.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("files"), (char*)files_bits, files_width, files_height);
#include "width1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("width1"), (char*)width1_bits, width1_width, width1_height);
#include "width2.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("width2"), (char*)width2_bits, width2_width, width2_height);
#include "width3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("width3"), (char*)width3_bits, width3_width, width3_height);
#include "width4.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("width4"), (char*)width4_bits, width4_width, width4_height);
#include "arrownone.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("arrownone"), (char*)arrownone_bits, arrownone_width, arrownone_height);
#include "circle.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("circle"), (char*)circle_bits, circle_width, circle_height);
#include "dir.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("dir"), (char*)dir_bits, dir_width, dir_height);
#include "shiftb1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("shiftb1"), (char*)shiftb1_bits, shiftb1_width, shiftb1_height);
#include "down.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("down"), (char*)down_bits, down_width, down_height);
#include "label.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("label"), (char*)label_bits, label_width, label_height);
#include "polygon.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("polygon"), (char*)polygon_bits, polygon_width, polygon_height);
#include "ar10_13_3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar10_13_3"), (char*)ar10_13_3_bits, ar10_13_3_width, ar10_13_3_height);
#include "right.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("right"), (char*)right_bits, right_width, right_height);
#include "ar8_10_3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar8_10_3"), (char*)ar8_10_3_bits, ar8_10_3_width, ar8_10_3_height);
#include "left.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("left"), (char*)left_bits, left_width, left_height);
#include "pat0.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat0"), (char*)pat0_bits, pat0_width, pat0_height);
#include "pat1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat1"), (char*)pat1_bits, pat1_width, pat1_height);
#include "pat2.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat2"), (char*)pat2_bits, pat2_width, pat2_height);
#include "pat3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat3"), (char*)pat3_bits, pat3_width, pat3_height);
#include "pat4.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat4"), (char*)pat4_bits, pat4_width, pat4_height);
#include "pat5.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat5"), (char*)pat5_bits, pat5_width, pat5_height);
#include "pat6.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat6"), (char*)pat6_bits, pat6_width, pat6_height);
#include "pat7.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat7"), (char*)pat7_bits, pat7_width, pat7_height);
#include "pat8.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat8"), (char*)pat8_bits, pat8_width, pat8_height);
#include "pat9.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat9"), (char*)pat9_bits, pat9_width, pat9_height);
#include "rotate.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("rotate"), (char*)rotate_bits, rotate_width, rotate_height);
#include "anyselect.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("anyselect"), (char*)anyselect_bits, anyselect_width, anyselect_height);
#include "freehand.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("freehand"), (char*)freehand_bits, freehand_width, freehand_height);
#include "magnify.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("magnify"), (char*)magnify_bits, magnify_width, magnify_height);
#include "file.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("file"), (char*)file_bits, file_width, file_height);
#include "b1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("b1"), (char*)b1_bits, b1_width, b1_height);
#include "b2.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("b2"), (char*)b2_bits, b2_width, b2_height);
#include "b3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("b3"), (char*)b3_bits, b3_width, b3_height);
#include "square.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("square"), (char*)square_bits, square_width, square_height);
#include "smooth.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("smooth"), (char*)smooth_bits, smooth_width, smooth_height);
#include "text.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("text"), (char*)text_bits, text_width, text_height);
#include "ar8_8_6.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar8_8_6"), (char*)ar8_8_6_bits, ar8_8_6_width, ar8_8_6_height);
#include "pat10.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat10"), (char*)pat10_bits, pat10_width, pat10_height);
#include "pat11.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat11"), (char*)pat11_bits, pat11_width, pat11_height);
#include "pat12.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat12"), (char*)pat12_bits, pat12_width, pat12_height);
#include "pat13.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat13"), (char*)pat13_bits, pat13_width, pat13_height);
#include "pat14.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat14"), (char*)pat14_bits, pat14_width, pat14_height);
#include "pat15.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pat15"), (char*)pat15_bits, pat15_width, pat15_height);
#include "abc.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("abc"), (char*)abc_bits, abc_width, abc_height);
#include "decr.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("decr"), (char*)decr_bits, decr_width, decr_height);
#include "ar12_11_3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar12_11_3"), (char*)ar12_11_3_bits, ar12_11_3_width, ar12_11_3_height);
#include "shrink.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("shrink"), (char*)shrink_bits, shrink_width, shrink_height);
#include "oval.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("oval"), (char*)oval_bits, oval_width, oval_height);
#include "objselect.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("objselect"), (char*)objselect_bits, objselect_width, objselect_height);
#include "flipx.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("flipx"), (char*)flipx_bits, flipx_width, flipx_height);
#include "flipy.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("flipy"), (char*)flipy_bits, flipy_width, flipy_height);
#include "ar8_12_9.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar8_12_9"), (char*)ar8_12_9_bits, ar8_12_9_width, ar8_12_9_height);
#include "polyline.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("polyline"), (char*)polyline_bits, polyline_width, polyline_height);
#include "ar12_12_3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ar12_12_3"), (char*)ar12_12_3_bits, ar12_12_3_width, ar12_12_3_height);
#include "down_arrow.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("down_arrow"), (char*)down_arrow_bits, down_arrow_width, down_arrow_height);
#include "shiftdragb1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("shiftdragb1"), (char*)shiftdragb1_bits, shiftdragb1_width, shiftdragb1_height);
#include "up.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("up"), (char*)up_bits, up_width, up_height);
#include "dragb1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("dragb1"), (char*)dragb1_bits, dragb1_width, dragb1_height);
#include "dragb2.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("dragb2"), (char*)dragb2_bits, dragb2_width, dragb2_height);
#include "dragb3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("dragb3"), (char*)dragb3_bits, dragb3_width, dragb3_height);
#include "arrowfirst.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("arrowfirst"), (char*)arrowfirst_bits, arrowfirst_width, arrowfirst_height);
#include "up_arrow.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("up_arrow"), (char*)up_arrow_bits, up_arrow_width, up_arrow_height);
#include "arc.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("arc"), (char*)arc_bits, arc_width, arc_height);
#include "incr.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("incr"), (char*)incr_bits, incr_width, incr_height);
#include "region.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("region"), (char*)region_bits, region_width, region_height);
#include "rectangle.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("rectangle"), (char*)rectangle_bits, rectangle_width, rectangle_height);
#include "arrowlast.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("arrowlast"), (char*)arrowlast_bits, arrowlast_width, arrowlast_height);
#include "left_arrow.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("left_arrow"), (char*)left_arrow_bits, left_arrow_width, left_arrow_height);
#include "line.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("line"), (char*)line_bits, line_width, line_height);
#include "right_arrow.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("right_arrow"), (char*)right_arrow_bits, right_arrow_width, right_arrow_height);
#include "link.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("link"), (char*)link_bits, link_width, link_height);
#include "information.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("information"), (char*)information_bits, information_width, information_height);
}
void defineGaiaBitmaps(Tcl_Interp *interp) {
#include "cross.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("cross"), (char*)cross_bits, cross_width, cross_height);
#include "diamond.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("diamond"), (char*)diamond_bits, diamond_width, diamond_height);
#include "rectangle.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("rectangle"), (char*)rectangle_bits, rectangle_width, rectangle_height);
#include "gaiaplus.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("gaiaplus"), (char*)gaiaplus_bits, gaiaplus_width, gaiaplus_height);
#include "row.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("row"), (char*)row_bits, row_width, row_height);
#include "finger.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("finger"), (char*)finger_bits, finger_width, finger_height);
#include "symb_rotbox.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("symb_rotbox"), (char*)symb_rotbox_bits, symb_rotbox_width, symb_rotbox_height);
#include "style0.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("style0"), (char*)style0_bits, style0_width, style0_height);
#include "pointpoly.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pointpoly"), (char*)pointpoly_bits, pointpoly_width, pointpoly_height);
#include "yrange.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("yrange"), (char*)yrange_bits, yrange_width, yrange_height);
#include "column.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("column"), (char*)column_bits, column_width, column_height);
#include "annular_circle.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("annular_circle"), (char*)annular_circle_bits, annular_circle_width, annular_circle_height);
#include "stcshape.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("stcshape"), (char*)stcshape_bits, stcshape_width, stcshape_height);
#include "line.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("line"), (char*)line_bits, line_width, line_height);
#include "pixel.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("pixel"), (char*)pixel_bits, pixel_width, pixel_height);
#include "annular_ellipse.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("annular_ellipse"), (char*)annular_ellipse_bits, annular_ellipse_width, annular_ellipse_height);
#include "ellipse.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("ellipse"), (char*)ellipse_bits, ellipse_width, ellipse_height);
#include "triangle.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("triangle"), (char*)triangle_bits, triangle_width, triangle_height);
#include "rotbox.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("rotbox"), (char*)rotbox_bits, rotbox_width, rotbox_height);
#include "poly.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("poly"), (char*)poly_bits, poly_width, poly_height);
#include "dot.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("dot"), (char*)dot_bits, dot_width, dot_height);
#include "xrange.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("xrange"), (char*)xrange_bits, xrange_width, xrange_height);
#include "style2.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("style2"), (char*)style2_bits, style2_width, style2_height);
#include "style3.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("style3"), (char*)style3_bits, style3_width, style3_height);
#include "style1.xbm"
Tk_DefineBitmap(interp, Tk_GetUid("style1"), (char*)style1_bits, style1_width, style1_height);
}
int
Tk_ConfigureWidget(
Tcl_Interp *interp, /* Interpreter for error reporting. */
Tk_Window tkwin, /* Window containing widget (needed to set up
* X resources). */
Tk_ConfigSpec *specs, /* Describes legal options. */
int argc, /* Number of elements in argv. */
CONST char **argv, /* Command-line options. */
char *widgRec, /* Record whose fields are to be modified.
* Values must be properly initialized. */
int flags) /* Used to specify additional flags that must
* be present in config specs for them to be
* considered. Also, may have
* TK_CONFIG_ARGV_ONLY set. */
{
register Tk_ConfigSpec *specPtr;
Tk_Uid value; /* Value of option from database. */
int needFlags; /* Specs must contain this set of flags or
* else they are not considered. */
int hateFlags; /* If a spec contains any bits here, it's not
* considered. */
if (tkwin == NULL) {
/*
* Either we're not really in Tk, or the main window was destroyed and
* we're on our way out of the application
*/
Tcl_AppendResult(interp, "NULL main window", NULL);
return TCL_ERROR;
}
needFlags = flags & ~(TK_CONFIG_USER_BIT - 1);
if (Tk_Depth(tkwin) <= 1) {
hateFlags = TK_CONFIG_COLOR_ONLY;
} else {
hateFlags = TK_CONFIG_MONO_ONLY;
}
/*
* Get the build of the config for this interpreter.
*/
specs = GetCachedSpecs(interp, specs);
/*
* Pass one: scan through all of the arguments, processing those that
* match entries in the specs.
*/
for ( ; argc > 0; argc -= 2, argv += 2) {
CONST char *arg;
if (flags & TK_CONFIG_OBJS) {
arg = Tcl_GetStringFromObj((Tcl_Obj *) *argv, NULL);
} else {
arg = *argv;
}
specPtr = FindConfigSpec(interp, specs, arg, needFlags, hateFlags);
if (specPtr == NULL) {
return TCL_ERROR;
}
/*
* Process the entry.
*/
if (argc < 2) {
Tcl_AppendResult(interp, "value for \"", arg, "\" missing", NULL);
return TCL_ERROR;
}
if (flags & TK_CONFIG_OBJS) {
arg = Tcl_GetString((Tcl_Obj *) argv[1]);
} else {
arg = argv[1];
}
if (DoConfig(interp, tkwin, specPtr, arg, 0, widgRec) != TCL_OK) {
char msg[100];
sprintf(msg, "\n (processing \"%.40s\" option)",
specPtr->argvName);
Tcl_AddErrorInfo(interp, msg);
return TCL_ERROR;
}
if (!(flags & TK_CONFIG_ARGV_ONLY)) {
specPtr->specFlags |= TK_CONFIG_OPTION_SPECIFIED;
}
}
/*
* Pass two: scan through all of the specs again; if no command-line
* argument matched a spec, then check for info in the option database.
* If there was nothing in the database, then use the default.
*/
if (!(flags & TK_CONFIG_ARGV_ONLY)) {
for (specPtr=specs; specPtr->type!=TK_CONFIG_END; specPtr++) {
if ((specPtr->specFlags & TK_CONFIG_OPTION_SPECIFIED)
|| (specPtr->argvName == NULL)
|| (specPtr->type == TK_CONFIG_SYNONYM)) {
specPtr->specFlags &= ~TK_CONFIG_OPTION_SPECIFIED;
continue;
}
if (((specPtr->specFlags & needFlags) != needFlags)
|| (specPtr->specFlags & hateFlags)) {
continue;
}
value = NULL;
if (specPtr->dbName != NULL) {
value = Tk_GetOption(tkwin, specPtr->dbName, specPtr->dbClass);
}
if (value != NULL) {
if (DoConfig(interp, tkwin, specPtr, value, 1, widgRec) !=
TCL_OK) {
char msg[200];
sprintf(msg, "\n (%s \"%.50s\" in widget \"%.50s\")",
"database entry for",
specPtr->dbName, Tk_PathName(tkwin));
Tcl_AddErrorInfo(interp, msg);
return TCL_ERROR;
}
} else {
if (specPtr->defValue != NULL) {
value = Tk_GetUid(specPtr->defValue);
} else {
value = NULL;
}
if ((value != NULL) && !(specPtr->specFlags
& TK_CONFIG_DONT_SET_DEFAULT)) {
if (DoConfig(interp, tkwin, specPtr, value, 1, widgRec) !=
TCL_OK) {
char msg[200];
sprintf(msg,
"\n (%s \"%.50s\" in widget \"%.50s\")",
"default value for",
specPtr->dbName, Tk_PathName(tkwin));
Tcl_AddErrorInfo(interp, msg);
return TCL_ERROR;
}
}
}
}
}
return TCL_OK;
}
static int
DoConfig(
Tcl_Interp *interp, /* Interpreter for error reporting. */
Tk_Window tkwin, /* Window containing widget (needed to set up
* X resources). */
Tk_ConfigSpec *specPtr, /* Specifier to apply. */
Tk_Uid value, /* Value to use to fill in widgRec. */
int valueIsUid, /* Non-zero means value is a Tk_Uid; zero
* means it's an ordinary string. */
char *widgRec) /* Record whose fields are to be modified.
* Values must be properly initialized. */
{
char *ptr;
Tk_Uid uid;
int nullValue;
nullValue = 0;
if ((*value == 0) && (specPtr->specFlags & TK_CONFIG_NULL_OK)) {
nullValue = 1;
}
do {
ptr = widgRec + specPtr->offset;
switch (specPtr->type) {
case TK_CONFIG_BOOLEAN:
if (Tcl_GetBoolean(interp, value, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_INT:
if (Tcl_GetInt(interp, value, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_DOUBLE:
if (Tcl_GetDouble(interp, value, (double *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_STRING: {
char *oldStr, *newStr;
if (nullValue) {
newStr = NULL;
} else {
newStr = (char *) ckalloc((unsigned) (strlen(value) + 1));
strcpy(newStr, value);
}
oldStr = *((char **) ptr);
if (oldStr != NULL) {
ckfree(oldStr);
}
*((char **) ptr) = newStr;
break;
}
case TK_CONFIG_UID:
if (nullValue) {
*((Tk_Uid *) ptr) = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
*((Tk_Uid *) ptr) = uid;
}
break;
case TK_CONFIG_COLOR: {
XColor *newPtr, *oldPtr;
if (nullValue) {
newPtr = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newPtr = Tk_GetColor(interp, tkwin, uid);
if (newPtr == NULL) {
return TCL_ERROR;
}
}
oldPtr = *((XColor **) ptr);
if (oldPtr != NULL) {
Tk_FreeColor(oldPtr);
}
*((XColor **) ptr) = newPtr;
break;
}
case TK_CONFIG_FONT: {
Tk_Font newFont;
if (nullValue) {
newFont = NULL;
} else {
newFont = Tk_GetFont(interp, tkwin, value);
if (newFont == NULL) {
return TCL_ERROR;
}
}
Tk_FreeFont(*((Tk_Font *) ptr));
*((Tk_Font *) ptr) = newFont;
break;
}
case TK_CONFIG_BITMAP: {
Pixmap newBmp, oldBmp;
if (nullValue) {
newBmp = None;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newBmp = Tk_GetBitmap(interp, tkwin, uid);
if (newBmp == None) {
return TCL_ERROR;
}
}
oldBmp = *((Pixmap *) ptr);
if (oldBmp != None) {
Tk_FreeBitmap(Tk_Display(tkwin), oldBmp);
}
*((Pixmap *) ptr) = newBmp;
break;
}
case TK_CONFIG_BORDER: {
Tk_3DBorder newBorder, oldBorder;
if (nullValue) {
newBorder = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newBorder = Tk_Get3DBorder(interp, tkwin, uid);
if (newBorder == NULL) {
return TCL_ERROR;
}
}
oldBorder = *((Tk_3DBorder *) ptr);
if (oldBorder != NULL) {
Tk_Free3DBorder(oldBorder);
}
*((Tk_3DBorder *) ptr) = newBorder;
break;
}
case TK_CONFIG_RELIEF:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetRelief(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_CURSOR:
case TK_CONFIG_ACTIVE_CURSOR: {
Tk_Cursor newCursor, oldCursor;
if (nullValue) {
newCursor = None;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newCursor = Tk_GetCursor(interp, tkwin, uid);
if (newCursor == None) {
return TCL_ERROR;
}
}
oldCursor = *((Tk_Cursor *) ptr);
if (oldCursor != None) {
Tk_FreeCursor(Tk_Display(tkwin), oldCursor);
}
*((Tk_Cursor *) ptr) = newCursor;
if (specPtr->type == TK_CONFIG_ACTIVE_CURSOR) {
Tk_DefineCursor(tkwin, newCursor);
}
break;
}
case TK_CONFIG_JUSTIFY:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetJustify(interp, uid, (Tk_Justify *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_ANCHOR:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetAnchor(interp, uid, (Tk_Anchor *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_CAP_STYLE:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetCapStyle(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_JOIN_STYLE:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetJoinStyle(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_PIXELS:
if (Tk_GetPixels(interp, tkwin, value, (int *) ptr)
!= TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_MM:
if (Tk_GetScreenMM(interp, tkwin, value, (double*)ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_WINDOW: {
Tk_Window tkwin2;
if (nullValue) {
tkwin2 = NULL;
} else {
tkwin2 = Tk_NameToWindow(interp, value, tkwin);
if (tkwin2 == NULL) {
return TCL_ERROR;
}
}
*((Tk_Window *) ptr) = tkwin2;
break;
}
case TK_CONFIG_CUSTOM:
if ((*specPtr->customPtr->parseProc)(
specPtr->customPtr->clientData, interp, tkwin, value,
widgRec, specPtr->offset) != TCL_OK) {
return TCL_ERROR;
}
break;
default: {
char buf[64 + TCL_INTEGER_SPACE];
sprintf(buf, "bad config table: unknown type %d", specPtr->type);
Tcl_SetResult(interp, buf, TCL_VOLATILE);
return TCL_ERROR;
}
}
specPtr++;
} while ((specPtr->argvName == NULL) && (specPtr->type != TK_CONFIG_END));
return TCL_OK;
}
void
plD_esc_ntk(PLStream *pls, PLINT op, void *ptr)
{
PLINT i,j;
short *xa, *ya;
Pixmap bitmap;
static unsigned char bit_pat[] = {
0x24, 0x01, 0x92, 0x00, 0x49, 0x00, 0x24, 0x00, 0x12, 0x00, 0x09, 0x00,
0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff};
switch (op) {
case PLESC_DASH:
xa = (short *) malloc(sizeof(short) * pls->dev_npts);
ya = (short *) malloc(sizeof(short) * pls->dev_npts);
for (i = 0; i < pls->dev_npts; i++) {
xa[i] = pls->dev_x[i];
ya[i] = pls->dev_y[i];
}
j = sprintf(dash, "-dash {");
for (i = 0; i < pls->nms; i++)
j += sprintf(&dash[j]," %d %d",
(int) ceil(pls->mark[i]/1e3 * ppm),
(int) ceil(pls->space[i]/1e3 * ppm));
sprintf(&dash[j], "}");
plD_polyline_ntk(pls, xa, ya, pls->dev_npts);
free(xa); free(ya);
dash[0] = 0;
break;
case PLESC_FLUSH:
tk_cmd("update");
break;
case PLESC_GETC:
getcursor(pls, (PLGraphicsIn *) ptr);
break;
case PLESC_FILL:
if (pls->patt != 0) {
/* this is a hack! The real solution is in the if(0) bellow */
pls->xpmm *= scale;
pls->ypmm *= scale;
plfill_soft( pls->dev_x, pls->dev_y, pls->dev_npts);
pls->xpmm /= scale;
pls->ypmm /= scale;
} else {
j = sprintf(cmd, "$plf.f2.c%d create polygon ", ccanv);
for (i = 0; i < pls->dev_npts; i++)
j += sprintf(&cmd[j], "%.1f %.1f ", pls->dev_x[i]/scale,
ymax-pls->dev_y[i]/scale);
j += sprintf(&cmd[j]," -fill %s", curcolor);
tk_cmd(cmd);
}
if (0) {
if (pls->patt != 0) {
Tk_DefineBitmap(interp, Tk_GetUid("foo"), bit_pat, 16, 16);
bitmap = Tk_GetBitmap(interp, mainw, Tk_GetUid("patt"));
}
j = sprintf(cmd, "$plf.f2.c%d create polygon ", ccanv);
for (i = 0; i < pls->dev_npts; i++)
j += sprintf(&cmd[j], "%.1f %.1f ", pls->dev_x[i]/scale,
ymax-pls->dev_y[i]/scale);
j += sprintf(&cmd[j]," -fill %s", curcolor);
if (pls->patt != 0)
sprintf(&cmd[j], " -stipple patt -outline black");
tk_cmd(cmd);
/*Tk_FreeBitmap(display, bitmap)*/
}
break;
}
}
Tk_Uid
Tk_GetOption(
Tk_Window tkwin, /* Token for window that option is associated
* with. */
CONST char *name, /* Name of option. */
CONST char *className) /* Class of option. NULL means there is no
* class for this option: just check for
* name. */
{
Tk_Uid nameId, classId = NULL;
char *masqName;
register Element *elPtr, *bestPtr;
register int count;
StackLevel *levelPtr;
int stackDepth[NUM_STACKS];
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
/*
* Note: no need to call OptionInit here: it will be done by the
* SetupStacks call below (squeeze out those nanoseconds).
*/
if (tkwin != (Tk_Window) tsdPtr->cachedWindow) {
SetupStacks((TkWindow *) tkwin, 1);
}
/*
* Get a default "best" match.
*/
bestPtr = &tsdPtr->defaultMatch;
/*
* For megawidget support, we want to have some widget options masquerade
* as options for other widgets. For example, a combobox has a button in
* it; this button ought to pick up the *Button.background, etc., options.
* But because the class of the widget is Combobox, our normal search
* won't get that option.
*
* To work around this, the option name field syntax was extended to allow
* for a "." in the name; if this character occurs in the name, then it
* indicates that this name contains a new window class and an option
* name, ie, "Button.foreground". If we see this form in the name field,
* we query the option database directly (since the option stacks will not
* have the information we need).
*/
masqName = strchr(name, (int)'.');
if (masqName != NULL) {
/*
* This option is masquerading with a different window class. Search
* the stack to the depth it was before the current window's
* information was pushed (the value for which is stored in the bases
* field).
*/
levelPtr = &tsdPtr->levels[tsdPtr->curLevel];
nameId = Tk_GetUid(masqName+1);
for (count = 0; count < NUM_STACKS; count++) {
stackDepth[count] = levelPtr->bases[count];
}
} else {
/*
* No option masquerading here. Just use the current level to get the
* stack depths.
*/
nameId = Tk_GetUid(name);
for (count = 0; count < NUM_STACKS; count++) {
stackDepth[count] = tsdPtr->stacks[count]->numUsed;
}
}
/*
* Probe the stacks for matches.
*/
for (elPtr = tsdPtr->stacks[EXACT_LEAF_NAME]->els,
count = stackDepth[EXACT_LEAF_NAME]; count > 0;
elPtr++, count--) {
if ((elPtr->nameUid == nameId)
&& (elPtr->priority > bestPtr->priority)) {
bestPtr = elPtr;
}
}
for (elPtr = tsdPtr->stacks[WILDCARD_LEAF_NAME]->els,
count = stackDepth[WILDCARD_LEAF_NAME]; count > 0;
elPtr++, count--) {
if ((elPtr->nameUid == nameId)
&& (elPtr->priority > bestPtr->priority)) {
bestPtr = elPtr;
}
}
if (className != NULL) {
classId = Tk_GetUid(className);
for (elPtr = tsdPtr->stacks[EXACT_LEAF_CLASS]->els,
count = stackDepth[EXACT_LEAF_CLASS]; count > 0;
elPtr++, count--) {
if ((elPtr->nameUid == classId)
&& (elPtr->priority > bestPtr->priority)) {
bestPtr = elPtr;
}
}
for (elPtr = tsdPtr->stacks[WILDCARD_LEAF_CLASS]->els,
count = stackDepth[WILDCARD_LEAF_CLASS]; count > 0;
elPtr++, count--) {
if ((elPtr->nameUid == classId)
&& (elPtr->priority > bestPtr->priority)) {
bestPtr = elPtr;
}
}
}
/*
* If this option was masquerading with a different window class, probe
* the option database now. Note that this will be inefficient if the
* option database is densely populated, or if the widget has many
* masquerading options.
*/
if (masqName != NULL) {
char *masqClass;
Tk_Uid nodeId, winClassId, winNameId;
unsigned int classNameLength;
register Element *nodePtr, *leafPtr;
static int searchOrder[] = {
EXACT_NODE_NAME, WILDCARD_NODE_NAME, EXACT_NODE_CLASS,
WILDCARD_NODE_CLASS, -1
};
int *currentPtr, currentStack, leafCount;
/*
* Extract the masquerade class name from the name field.
*/
classNameLength = (unsigned int)(masqName - name);
masqClass = (char *) ckalloc(classNameLength + 1);
strncpy(masqClass, name, classNameLength);
masqClass[classNameLength] = '\0';
winClassId = Tk_GetUid(masqClass);
ckfree(masqClass);
winNameId = ((TkWindow *)tkwin)->nameUid;
levelPtr = &tsdPtr->levels[tsdPtr->curLevel];
for (currentPtr = searchOrder; *currentPtr != -1; currentPtr++) {
currentStack = *currentPtr;
nodePtr = tsdPtr->stacks[currentStack]->els;
count = levelPtr->bases[currentStack];
/*
* For wildcard stacks, check all entries; for non-wildcard
* stacks, only check things that matched in the parent.
*/
if (!(currentStack & WILDCARD)) {
nodePtr += levelPtr[-1].bases[currentStack];
count -= levelPtr[-1].bases[currentStack];
}
if (currentStack && CLASS) {
nodeId = winClassId;
} else {
nodeId = winNameId;
}
for ( ; count > 0; nodePtr++, count--) {
if (nodePtr->nameUid == nodeId) {
leafPtr = nodePtr->child.arrayPtr->els;
leafCount = nodePtr->child.arrayPtr->numUsed;
for ( ; leafCount > 0; leafPtr++, leafCount--) {
if (leafPtr->flags & CLASS && className != NULL) {
if (leafPtr->nameUid == classId &&
leafPtr->priority > bestPtr->priority) {
bestPtr = leafPtr;
}
} else {
if (leafPtr->nameUid == nameId &&
leafPtr->priority > bestPtr->priority) {
bestPtr = leafPtr;
}
}
}
}
}
}
}
return bestPtr->child.valueUid;
}
void
Tk_AddOption(
Tk_Window tkwin, /* Window token; option will be associated
* with main window for this window. */
CONST char *name, /* Multi-element name of option. */
CONST char *value, /* String value for option. */
int priority) /* Overall priority level to use for this
* option, such as TK_USER_DEFAULT_PRIO or
* TK_INTERACTIVE_PRIO. Must be between 0 and
* TK_MAX_PRIO. */
{
TkWindow *winPtr = ((TkWindow *) tkwin)->mainPtr->winPtr;
register ElArray **arrayPtrPtr;
register Element *elPtr;
Element newEl;
register CONST char *p;
CONST char *field;
int count, firstField;
ptrdiff_t length;
#define TMP_SIZE 100
char tmp[TMP_SIZE+1];
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
if (winPtr->mainPtr->optionRootPtr == NULL) {
OptionInit(winPtr->mainPtr);
}
tsdPtr->cachedWindow = NULL;/* Invalidate the cache. */
/*
* Compute the priority for the new element, including both the overall
* level and the serial number (to disambiguate with the level).
*/
if (priority < 0) {
priority = 0;
} else if (priority > TK_MAX_PRIO) {
priority = TK_MAX_PRIO;
}
newEl.priority = (priority << 24) + tsdPtr->serial;
tsdPtr->serial++;
/*
* Parse the option one field at a time.
*/
arrayPtrPtr = &(((TkWindow *) tkwin)->mainPtr->optionRootPtr);
p = name;
for (firstField = 1; ; firstField = 0) {
/*
* Scan the next field from the name and convert it to a Tk_Uid. Must
* copy the field before calling Tk_Uid, so that a terminating NULL
* may be added without modifying the source string.
*/
if (*p == '*') {
newEl.flags = WILDCARD;
p++;
} else {
newEl.flags = 0;
}
field = p;
while ((*p != 0) && (*p != '.') && (*p != '*')) {
p++;
}
length = p - field;
if (length > TMP_SIZE) {
length = TMP_SIZE;
}
strncpy(tmp, field, (size_t) length);
tmp[length] = 0;
newEl.nameUid = Tk_GetUid(tmp);
if (isupper(UCHAR(*field))) {
newEl.flags |= CLASS;
}
if (*p != 0) {
/*
* New element will be a node. If this option can't possibly apply
* to this main window, then just skip it. Otherwise, add it to
* the parent, if it isn't already there, and descend into it.
*/
newEl.flags |= NODE;
if (firstField && !(newEl.flags & WILDCARD)
&& (newEl.nameUid != winPtr->nameUid)
&& (newEl.nameUid != winPtr->classUid)) {
return;
}
for (elPtr = (*arrayPtrPtr)->els, count = (*arrayPtrPtr)->numUsed;
; elPtr++, count--) {
if (count == 0) {
newEl.child.arrayPtr = NewArray(5);
*arrayPtrPtr = ExtendArray(*arrayPtrPtr, &newEl);
arrayPtrPtr = &((*arrayPtrPtr)
->nextToUse[-1].child.arrayPtr);
break;
}
if ((elPtr->nameUid == newEl.nameUid)
&& (elPtr->flags == newEl.flags)) {
arrayPtrPtr = &(elPtr->child.arrayPtr);
break;
}
}
if (*p == '.') {
p++;
}
} else {
/*
* New element is a leaf. Add it to the parent, if it isn't
* already there. If it exists already, keep whichever value has
* highest priority.
*/
newEl.child.valueUid = Tk_GetUid(value);
for (elPtr = (*arrayPtrPtr)->els, count = (*arrayPtrPtr)->numUsed;
; elPtr++, count--) {
if (count == 0) {
*arrayPtrPtr = ExtendArray(*arrayPtrPtr, &newEl);
return;
}
if ((elPtr->nameUid == newEl.nameUid)
&& (elPtr->flags == newEl.flags)) {
if (elPtr->priority < newEl.priority) {
elPtr->priority = newEl.priority;
elPtr->child.valueUid = newEl.child.valueUid;
}
return;
}
}
}
}
}
callGraphConsts::callGraphConsts(Tcl_Interp *interp, Tk_Window theTkWindow) {
display = Tk_Display(theTkWindow); // needed in destructor
textColor = Tk_GetColor(interp, theTkWindow, Tk_GetUid("black"));
assert(textColor);
// Root Item FontStruct's:
Tk_Uid rootItemFontName = Tk_GetOption( theTkWindow,
"listRootItemFont",
"Font" );
assert( rootItemFontName != NULL );
rootItemFontStruct = Tk_GetFont( interp, theTkWindow, rootItemFontName );
Tk_Uid rootItemItalicFontName = Tk_GetOption( theTkWindow,
"listRootItemEmphFont",
"Font" );
assert( rootItemItalicFontName != NULL );
rootItemItalicFontStruct = Tk_GetFont( interp, theTkWindow,
rootItemItalicFontName );
// Root Item Text GCs:
XGCValues values;
values.foreground = textColor->pixel;
values.font = Tk_FontId(rootItemFontStruct);
rootItemTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont, &values);
assert(rootItemTextGC);
values.font = Tk_FontId(rootItemItalicFontStruct);
values.foreground = textColor->pixel;
rootItemShadowTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont,
&values);
assert(rootItemShadowTextGC);
// Listbox FontStruct's:
Tk_Uid listboxItemFontName = Tk_GetOption( theTkWindow,
"listItemFont",
"Font" );
assert( listboxItemFontName );
listboxItemFontStruct = Tk_GetFont(interp,
theTkWindow,
listboxItemFontName );
Tk_Uid listboxItemItalicFontName = Tk_GetOption( theTkWindow,
"listItemEmphFont",
"Font" );
assert( listboxItemItalicFontName );
listboxItemItalicFontStruct = Tk_GetFont(interp,
theTkWindow,
listboxItemItalicFontName );
// Listbox Item Text GCs:
values.foreground = textColor->pixel;
values.font = Tk_FontId(listboxItemFontStruct);
listboxItemGC = Tk_GetGC(theTkWindow, GCForeground | GCFont, &values);
assert(listboxItemGC);
values.font = Tk_FontId(listboxItemItalicFontStruct);
values.foreground = textColor->pixel;
listboxItemShadowTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont,
&values);
assert(listboxItemShadowTextGC);
rootItemTk3DBordersByStyle.resize(2);
//Color for non-recursive nodes
rootItemTk3DBordersByStyle[0] = Tk_Get3DBorder(interp, theTkWindow,
Tk_GetUid("gray"));
assert(rootItemTk3DBordersByStyle[0]);
//Color for recursive nodes
rootItemTk3DBordersByStyle[1] = Tk_Get3DBorder(interp, theTkWindow,
Tk_GetUid("#60c0a0"));
//green
assert(rootItemTk3DBordersByStyle[1]);
listboxItemTk3DBordersByStyle = rootItemTk3DBordersByStyle;
// 3D borders for listbox:
// It seems reasonable to use the exact same colors for shg listbox items:
//listboxScrollbarBorder = rootItemBorder;
}
static Tk_ConfigSpec *
GetCachedSpecs(
Tcl_Interp *interp, /* Interpreter in which to store the cache. */
const Tk_ConfigSpec *staticSpecs)
/* Value to cache a copy of; it is also used
* as a key into the cache. */
{
Tk_ConfigSpec *cachedSpecs;
Tcl_HashTable *specCacheTablePtr;
Tcl_HashEntry *entryPtr;
int isNew;
/*
* Get (or allocate if it doesn't exist) the hash table that the writable
* copies of the widget specs are stored in. In effect, this is
* self-initializing code.
*/
specCacheTablePtr = (Tcl_HashTable *)
Tcl_GetAssocData(interp, "tkConfigSpec.threadTable", NULL);
if (specCacheTablePtr == NULL) {
specCacheTablePtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(specCacheTablePtr, TCL_ONE_WORD_KEYS);
Tcl_SetAssocData(interp, "tkConfigSpec.threadTable",
DeleteSpecCacheTable, (ClientData) specCacheTablePtr);
}
/*
* Look up or create the hash entry that the constant specs are mapped to,
* which will have the writable specs as its associated value.
*/
entryPtr = Tcl_CreateHashEntry(specCacheTablePtr, (char *) staticSpecs,
&isNew);
if (isNew) {
unsigned int entrySpace = sizeof(Tk_ConfigSpec);
const Tk_ConfigSpec *staticSpecPtr;
Tk_ConfigSpec *specPtr;
/*
* OK, no working copy in this interpreter so copy. Need to work out
* how much space to allocate first.
*/
for (staticSpecPtr=staticSpecs; staticSpecPtr->type!=TK_CONFIG_END;
staticSpecPtr++) {
entrySpace += sizeof(Tk_ConfigSpec);
}
/*
* Now allocate our working copy's space and copy over the contents
* from the master copy.
*/
cachedSpecs = (Tk_ConfigSpec *) ckalloc(entrySpace);
memcpy(cachedSpecs, staticSpecs, entrySpace);
Tcl_SetHashValue(entryPtr, (ClientData) cachedSpecs);
/*
* Finally, go through and replace database names, database classes
* and default values with Tk_Uids. This is the bit that has to be
* per-thread.
*/
for (specPtr=cachedSpecs; specPtr->type!=TK_CONFIG_END; specPtr++) {
if (specPtr->argvName != NULL) {
if (specPtr->dbName != NULL) {
specPtr->dbName = Tk_GetUid(specPtr->dbName);
}
if (specPtr->dbClass != NULL) {
specPtr->dbClass = Tk_GetUid(specPtr->dbClass);
}
if (specPtr->defValue != NULL) {
specPtr->defValue = Tk_GetUid(specPtr->defValue);
}
}
specPtr->specFlags &= ~TK_CONFIG_OPTION_SPECIFIED;
}
} else {
cachedSpecs = (Tk_ConfigSpec *) Tcl_GetHashValue(entryPtr);
}
return cachedSpecs;
}
static void
imfsample_display(ClientData cldata)
{
char *str;
int row, col, namex, namey, n, sx, sy, update = FALSE, done;
Imfsample *imfsample = (Imfsample *) cldata;
Display *dpy = imfsample->display;
Tk_Window tkwin = imfsample->tkwin;
GC gc;
Pixmap pm = None;
Drawable d;
Tk_Font tkfont;
int winwidth = Tk_Width(Tk_Parent(tkwin));
int winheight = Tk_Height(Tk_Parent(tkwin));
char tclbuf[100];
int rslt;
imfsample->update_pending = 0;
if (!Tk_IsMapped(tkwin)) {
return;
}
/* Check if we need to redraw the entire imfsample. */
if (imfsample->imfapp) {
if (imfsample->oldfirst != imfsample->firstvisrow
|| imfsample->redraw) {
imfsample->oldfirst = imfsample->firstvisrow;
update = TRUE;
}
}
/* Create a pixmap for double-buffering if necessary. */
if (imfsample->double_buffer) {
update = TRUE;
pm = Tk_GetPixmap(imfsample->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin),
DefaultDepthOfScreen(Tk_Screen(tkwin)));
d = pm;
} else {
d = Tk_WindowId(tkwin);
}
if (black_color == NULL) {
black_color = Tk_GetColor(interp, tkwin, Tk_GetUid("black"));
}
if (white_color == NULL) {
white_color = Tk_GetColor(interp, tkwin, Tk_GetUid("white"));
}
if (black_border == NULL) {
black_border = Tk_Get3DBorder(interp, tkwin, "black");
}
if (white_border == NULL) {
white_border = Tk_Get3DBorder(interp, tkwin, "white");
}
/* Collect GC and font for subsequent work. */
gc = imfsample->gc;
XSetClipMask(dpy, gc, None);
if (imfsample->show_names) {
#ifdef WIN32
tkfont = Tk_GetFont(interp, tkwin, "-family arial -size 8");
#elif defined (MAC)
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 11");
#else
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 12");
#endif
XSetFont(imfsample->display, gc, Tk_FontId(tkfont));
}
/* Redraw the entire widget background/border, but not if we
are just updating the selected image. */
if (imfsample->selected == imfsample->previous
/* Always redraw if we have only one image (e.g. closeups). */
|| (imfsample->numimages == 1 && imfsample->selected == -1)
|| update) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
XFillRectangle(dpy, d, gc, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin));
done = TRUE;
}
}
}
if (!done) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin),
imfsample->border_width, imfsample->relief);
}
}
#if 0
for (i = 0; i < imfsample->numimages; i++) {
if (imf_interp_hook)
imfsample->imf_list[i] =
(*imf_interp_hook)(imfsample->imf_list[i], NULL, TRUE);
}
#endif
/* Tweak the default item width/height to something better. */
if (imfsample->iheight == 0) {
imfsample->iheight = 32;
if (imfsample->numimages == 1)
imfsample->iheight = imfsample->height;
}
if (imfsample->iwidth == 0) {
imfsample->iwidth = 32;
if (imfsample->numimages == 1)
imfsample->iwidth = imfsample->width;
}
imfsample->eltw = imfsample->iwidth;
if (imfsample->show_grid)
imfsample->eltw += 2;
else
imfsample->eltw += 2 * imfsample->pad;
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw += 80;
imfsample->elth = imfsample->iheight;
if (imfsample->show_grid)
imfsample->elth += 2;
else
imfsample->elth += 2 * imfsample->pad;
/* Fix a lower bound on the vertical spacing. */
/* (should be determined by choice of app font) */
if (imfsample->elth < 10 && !imfsample->show_grid)
imfsample->elth = 10;
/* Compute and save the number of columns to use. */
imfsample->cols = winwidth / imfsample->eltw;
if (imfsample->cols <= 0)
imfsample->cols = 1;
/* We can get a little wider spacing by recalculating the element
width. */
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw = (winwidth - 10) / imfsample->cols;
imfsample->rows = imfsample->numimages / imfsample->cols;
/* Account for a last partial row. */
if (imfsample->rows * imfsample->cols < imfsample->numimages)
++(imfsample->rows);
/* Compute the number of visible rows. It would be time-consuming
to render all the images, so try to do only the visible ones. */
imfsample->numvisrows = winheight / imfsample->elth;
if (imfsample->numvisrows > imfsample->rows)
imfsample->numvisrows = imfsample->rows;
if (imfsample->numvisrows < 1)
imfsample->numvisrows = min(1, imfsample->rows);
if (imfsample->firstvisrow + imfsample->numvisrows > imfsample->rows)
imfsample->firstvisrow = imfsample->rows - imfsample->numvisrows;
/* Imfapp-specific code that adjusts the canvas content to fit a resized
window and also sets the canvas scrollregion correctly. */
if (imfsample->imfapp
&& imfsample->redraw) {
imfsample->width = Tk_Width(Tk_Parent(tkwin));
imfsample->height = imfsample->rows * imfsample->elth + 7;
Tk_GeometryRequest(tkwin, imfsample->width, imfsample->height);
/* There must be a better way to do this ... */
sprintf(tclbuf,
".images.canvas configure -scrollregion [ list 0 0 0 %d ]",
imfsample->height);
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
/* Force a redraw of the scrollbar if the window was resized. */
if (imfsample->numimages) {
sprintf(tclbuf, ".images.canvas.content yview scroll 0 units");
} else {
sprintf(tclbuf, ".images.scroll set 0 1");
}
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
}
/* Now iterate through all the images we want to draw. */
for (row = imfsample->firstvisrow;
row <= (imfsample->firstvisrow + imfsample->numvisrows);
++row) {
if (row < 0)
continue;
for (col = 0; col < imfsample->cols; ++col) {
n = row * imfsample->cols + col;
if (n >= imfsample->numimages)
break;
sx = col * imfsample->eltw;
sy = (row - imfsample->firstvisrow) * imfsample->elth;
/* Erase the old selected imf if we picked a new one. */
if (n == imfsample->previous && n != imfsample->selected) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
if (imfsample->show_grid) {
XFillRectangle(dpy, d, gc, sx, sy + 2,
imfsample->eltw,
imfsample->elth);
} else {
XFillRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw,
imfsample->elth);
}
done = TRUE;
}
}
}
if (!done) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 2,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
} else {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 7,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
}
}
}
/* Just draw the old erased image if we selected a new one, else
draw every image. */
if (imfsample->selected == imfsample->previous
|| n == imfsample->previous
|| update) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->cu_border,
sx + 2, sy + 2,
imfsample->iwidth, imfsample->iheight,
imfsample->border_width, imfsample->relief);
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + 2, sy + 2,
imfsample->iwidth,
imfsample->iheight);
} else {
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + imfsample->pad,
sy + imfsample->pad,
imfsample->iwidth,
imfsample->iheight);
}
if (imfsample->show_names && !imfsample->show_grid) {
namex = sx + 5;
namey = sy + imfsample->elth + 3;
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc,
Tk_3DBorderColor(
imfsample->fg_border)->pixel);
str = imfsample->imf_list[n]->name;
Tk_DrawChars(dpy, d, gc, tkfont, str, strlen(str),
namex, namey);
}
}
/* Box the selected imf. */
if (n == imfsample->selected) {
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc, Tk_3DBorderColor(imfsample->fg_border)->pixel);
if (imfsample->show_grid) {
/* A rectangle on the Mac is 1 pixel smaller in both directions. */
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 2, imfsample->elth - 2);
#else
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 3, imfsample->elth - 3);
#endif
} else {
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw, imfsample->elth);
#else
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw - 1, imfsample->elth - 1);
#endif
}
}
}
}
/* Reset the old selected image to the new one if it exists. */
if (imfsample->selected != -1) {
imfsample->previous = imfsample->selected;
}
/* Reset the redraw flag. */
imfsample->redraw = FALSE;
/* If double-buffered, copy to the screen and release the pixmap. */
if (imfsample->double_buffer) {
XCopyArea(imfsample->display, pm, Tk_WindowId(tkwin),
imfsample->copygc,
0, 0, (unsigned) winwidth, (unsigned) winheight, 0, 0);
Tk_FreePixmap(imfsample->display, pm);
}
if (imfsample->show_names) {
Tk_FreeFont(tkfont);
}
/* In theory this shouldn't be necessary, but in practice the
interface widgets (esp. the progress bar fill color) are
affected by the last value of the foreground left over from
drawing, so set to a consistent value. */
/* (Note that as of 2000-09-16, some color errors persist, so
this might not really be necessary -sts) */
XSetForeground(imfsample->display, imfsample->gc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->gc, white_color->pixel);
XSetForeground(imfsample->display, imfsample->copygc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->copygc, white_color->pixel);
}
