Tk Source Code

2012-04-20  Jan Nijtmans  <[email protected]>

	* generic/tk.tcl: Use vroot size in stead of screen size for
	clipping window coordinates in ::tk::PlaceWindow.
	* generic/dialog.tcl: Use ::tk::PlaceWindow in dialog.tcl, in
	stead of dumplicating the code there.
	(harmless part of [Bug 533519])

2012-04-13  Jan Nijtmans  <[email protected]>

	* win/rules.vc: [Bug 3517448] TclKit build fails (unresolved
	__strtoi64)

2012-04-07  Jan Nijtmans  <[email protected]>

    int flags;			/* If the TK_ARGV_NO_DEFAULTS bit is set
				 * in this word, then don't generate
				 * information for default options. */
{
    register Tk_ArgvInfo *infoPtr;
    int width, i, numSpaces;
#define NUM_SPACES 20
    static CONST char spaces[] = "                    ";
    char tmp[TCL_DOUBLE_SPACE];

    /*
     * First, compute the width of the widest option key, so that we
     * can make everything line up.
     */

#include "tkInt.h"

/*
 * The following are a list of the predefined atom strings.
 * They should match those found in xatom.h
 */

static CONST char *atomNameArray[] = {
    "PRIMARY",		"SECONDARY",		"ARC",
    "ATOM",		"BITMAP",		"CARDINAL",
    "COLORMAP",		"CURSOR",		"CUT_BUFFER0",
    "CUT_BUFFER1",	"CUT_BUFFER2",		"CUT_BUFFER3",
    "CUT_BUFFER4",	"CUT_BUFFER5",		"CUT_BUFFER6",
    "CUT_BUFFER7",	"DRAWABLE",		"FONT",
    "INTEGER",		"PIXMAP",		"POINT",

    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++) {
	hPtr = Tcl_FindHashEntry(&dispPtr->atomTable, (char *) atom);
	if (hPtr == NULL) {
	    CONST char *name;
	    int new;

	    name = atomNameArray[atom - 1];
	    hPtr = Tcl_CreateHashEntry(&dispPtr->nameTable, (char *) name,
		&new);
	    Tcl_SetHashValue(hPtr, atom);
	    name = Tcl_GetHashKey(&dispPtr->nameTable, hPtr);
	    hPtr = Tcl_CreateHashEntry(&dispPtr->atomTable, (char *) atom,
		&new);
	    Tcl_SetHashValue(hPtr, name);
	}
    }
}

		    string = "??";
		}
		goto doString;
	    }
	    case 'X':
		if (flags & KEY_BUTTON_MOTION_CROSSING) {
		    Tk_Window tkwin;



		    number = eventPtr->xkey.x_root;
		    tkwin = Tk_IdToWindow(eventPtr->xany.display,
			    eventPtr->xany.window);




		    goto doNumber;
		}
		goto doString;
	    case 'Y':
		if (flags & KEY_BUTTON_MOTION_CROSSING) {
		    Tk_Window tkwin;



		    number = eventPtr->xkey.y_root;
		    tkwin = Tk_IdToWindow(eventPtr->xany.display,
			    eventPtr->xany.window);




		    goto doNumber;
		}
		goto doString;
	    default:
		numStorage[0] = before[1];
		numStorage[1] = '\0';
		string = numStorage;

static Tcl_ThreadDataKey dataKey;

/*
 * Class names for buttons, indexed by one of the type values defined
 * in tkButton.h.
 */

static CONST char *classNames[] = {"Label", "Button", "Checkbutton", "Radiobutton"};

/*
 * The following table defines the legal values for the -default option.
 * It is used together with the "enum defaultValue" declaration in tkButton.h.
 */

static CONST char *defaultStrings[] = {
    "active", "disabled", "normal", (char *) NULL
};

/*
 * The following table defines the legal values for the -state option.
 * It is used together with the "enum state" declaration in tkButton.h.
 */

static CONST char *stateStrings[] = {
    "active", "disabled", "normal", (char *) NULL
};

/*
 * The following table defines the legal values for the -compound option.
 * It is used with the "enum compound" declaration in tkButton.h
 */

static CONST char *compoundStrings[] = {
    "bottom", "center", "left", "none", "right", "top", (char *) NULL
};

char tkDefButtonBorderWidth[TCL_INTEGER_SPACE] = DEF_BUTTON_BORDER_WIDTH;

/*
 * Information used for parsing configuration options.  There is a

/*
 * A comparison function for double values.  For Spinboxes.
 */
#define MIN_DBL_VAL		1E-9
#define DOUBLES_EQ(d1, d2)	(fabs((d1) - (d2)) < MIN_DBL_VAL)


static CONST char *stateStrings[] = {
    "disabled", "normal", "readonly", (char *) NULL
};

/*
 * Definitions for -validate option values:
 */

static CONST char *validateStrings[] = {
    "all", "key", "focus", "focusin", "focusout", "none", (char *) NULL
};
enum validateType {
    VALIDATE_ALL, VALIDATE_KEY, VALIDATE_FOCUS,
    VALIDATE_FOCUSIN, VALIDATE_FOCUSOUT, VALIDATE_NONE,
    /*
     * These extra enums are for use with EntryValidateChange

    TkWindow *winPtr;		/* Window that selects an application
				 * and a display. */
    XEvent *eventPtr;		/* X event to redirect (should be KeyPress
				 * or KeyRelease). */
{
    DisplayFocusInfo *displayFocusPtr;
    TkWindow *focusWinPtr;
    int focusX, focusY;

    displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
    focusWinPtr = displayFocusPtr->focusWinPtr;

    /*
     * The code below is a debugging aid to make sure that dispPtr->focusPtr
     * is kept properly in sync with the "truth", which is the value in

	 */

	if ((focusWinPtr->display != winPtr->display)
		|| (focusWinPtr->screenNum != winPtr->screenNum)) {
	    eventPtr->xkey.x = -1;
	    eventPtr->xkey.y = -1;
	} else {


	    Tk_GetRootCoords((Tk_Window) focusWinPtr, &focusX, &focusY);
	    eventPtr->xkey.x = eventPtr->xkey.x_root - focusX;
	    eventPtr->xkey.y = eventPtr->xkey.y_root - focusY;
	}
	eventPtr->xkey.window = focusWinPtr->window;
	return focusWinPtr;
    }

    /*
     * The event doesn't belong to us.  Perhaps, due to embedding, it

enum labelanchor {
    LABELANCHOR_E, LABELANCHOR_EN, LABELANCHOR_ES,
    LABELANCHOR_N, LABELANCHOR_NE, LABELANCHOR_NW,
    LABELANCHOR_S, LABELANCHOR_SE, LABELANCHOR_SW,
    LABELANCHOR_W, LABELANCHOR_WN, LABELANCHOR_WS
};

static CONST char *labelAnchorStrings[] = {
    "e", "en", "es", "n", "ne", "nw", "s", "se", "sw", "w", "wn", "ws",
    (char *) NULL
};

/*
 * Information used for parsing configuration options.  There are
 * one common table used by all and one table for each widget class.

	(char *) NULL, 0, 0, 0, (ClientData) commonOptSpec, 0}
};

/*
 * Class names for widgets, indexed by FrameType.
 */

static CONST char *classNames[] = {"Frame", "Toplevel", "Labelframe"};

/*
 * The following table maps from FrameType to the option template for
 * that class of widgets.
 */

static Tk_OptionSpec *optionSpecs[] = {
    frameOptSpec,
    toplevelOptSpec,
    labelframeOptSpec
};

/*
 * Forward declarations for procedures defined later in this file:
 */

static void		ComputeFrameGeometry _ANSI_ARGS_((Frame *framePtr));

    /* 
     * The bit order of bitmaps in Tk is the opposite of the bit order that
     * postscript uses.  (In Tk, the least significant bit is on the right
     * side of the bitmap and in postscript the least significant bit is shown
     * on the left.)  The following array is used to reverse the order of bits
     * within a byte so that the bits will be in the order postscript expects.
     */
    static CONST unsigned char bit_reverse[] = {
       0, 128, 64, 192, 32, 160,  96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
       8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
       4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
      12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
       2, 130, 66, 194, 34, 162,  98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
      10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
       6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,

 * string table below.
 */

enum state {
    STATE_DISABLED, STATE_NORMAL
};

static CONST char *stateStrings[] = {
    "disabled", "normal", (char *) NULL
};

enum activeStyle {
    ACTIVE_STYLE_DOTBOX, ACTIVE_STYLE_NONE, ACTIVE_STYLE_UNDERLINE
};

static CONST char *activeStyleStrings[] = {
    "dotbox", "none", "underline", (char *) NULL
};

/*
 * The optionSpecs table defines the valid configuration options for the
 * listbox widget
 */

     *    (if any) to the real root.  Can't get the virtual root
     *    from the menu itself (it will never be seen by the wm)
     *    so use its parent instead (it would be better to have an
     *    an option that names a window to use for this...).
     * 2. The menu may not have been mapped yet, so its current size
     *    might be the default 1x1.  To compute how much space it
     *    needs, use its requested size, not its actual size.





     */

    Tk_GetVRootGeometry(Tk_Parent(menuPtr->tkwin), &vRootX, &vRootY,
	&vRootWidth, &vRootHeight);




    if (x > vRootX + vRootWidth) {
	x = vRootX + vRootWidth;
    }
    if (x < vRootX) {
	x = vRootX;
    }


    if (y > vRootY + vRootHeight) {
	y = vRootY + vRootHeight;
    }
    if (y < vRootY) {
	y = vRootY;
    }
    Tk_MoveToplevelWindow(menuPtr->tkwin, x, y);
    if (!Tk_IsMapped(menuPtr->tkwin)) {
	Tk_MapWindow(menuPtr->tkwin);
    }
    TkWmRestackToplevel((TkWindow *) menuPtr->tkwin, Above, NULL);
    return TCL_OK;

/*
 * The following table defines the legal values for the -direction 
 * option.  It is used together with the "enum direction" declaration 
 * in tkMenubutton.h.
 */

static CONST char *directionStrings[] = {
    "above", "below", "flush", "left", "right", (char *) NULL
};

/*
 * The following table defines the legal values for the -state option.
 * It is used together with the "enum state" declaration in tkMenubutton.h.
 */

static CONST char *stateStrings[] = {
    "active", "disabled", "normal", (char *) NULL
};

/*
 * The following table defines the legal values for the -compound option.
 * It is used with the "enum compound" declaration in tkMenuButton.h
 */

static CONST char *compoundStrings[] = {
    "bottom", "center", "left", "none", "right", "top", (char *) NULL
};

/*
 * Information used for parsing configuration specs:
 */

#define STICK_EAST		2
#define STICK_SOUTH		4
#define STICK_WEST		8
/*
 * The following table defines the legal values for the -orient option.
 */

static CONST char *orientStrings[] = {
    "horizontal", "vertical", (char *) NULL
};

enum orient { ORIENT_HORIZONTAL, ORIENT_VERTICAL };

typedef struct {
    Tk_OptionTable pwOptions;	/* Token for paned window option table. */

 *			all borders of master window.
 * BM_OUTSIDE:		relative distances computed using outside area
 *			that includes all borders of master.
 * BM_IGNORE:		border issues are ignored:  place relative to
 *			master's actual window size.
 */

static CONST char *borderModeStrings[] = {
    "inside", "outside", "ignore", (char *) NULL
};

typedef enum {BM_INSIDE, BM_OUTSIDE, BM_IGNORE} BorderMode;

/*
 * For each window whose geometry is managed by the placer there is

#include "tkScale.h"

/*
 * The following table defines the legal values for the -orient option.
 * It is used together with the "enum orient" declaration in tkScale.h.
 */

static CONST char *orientStrings[] = {
    "horizontal", "vertical", (char *) NULL
};

/*
 * The following table defines the legal values for the -state option.
 * It is used together with the "enum state" declaration in tkScale.h.
 */

static CONST char *stateStrings[] = {
    "active", "disabled", "normal", (char *) NULL
};

static Tk_OptionSpec optionSpecs[] = {
    {TK_OPTION_BORDER, "-activebackground", "activeBackground", "Foreground",
	DEF_SCALE_ACTIVE_BG_COLOR, -1, Tk_Offset(TkScale, activeBorder),
	0, (ClientData) DEF_SCALE_ACTIVE_BG_MONO, 0},

		Tcl_Obj *justifyPtr;
		Tcl_Obj *anchorPtr;
		Tcl_Obj *pixelPtr;
		Tcl_Obj *mmPtr;
		Tcl_Obj *customPtr;
	    } TypesRecord;
	    TypesRecord *recordPtr;
	    static CONST char *stringTable[] = {"one", "two", "three", "four", 
		    (char *) NULL};
	    static Tk_OptionSpec typesSpecs[] = {
		{TK_OPTION_BOOLEAN,
			"-boolean", "boolean", "Boolean",
			"1", Tk_Offset(TypesRecord, booleanPtr), -1, 0, 0, 0x1},
		{TK_OPTION_INT,
			"-integer", "integer", "Integer",

		Tk_Anchor anchor;
		int pixels;
		double mm;
		Tk_Window tkwin;
		char *custom;
	    } InternalRecord;
	    InternalRecord *recordPtr;
	    static CONST char *internalStringTable[] = {
		    "one", "two", "three", "four", (char *) NULL
	    };
	    static Tk_OptionSpec internalSpecs[] = {
		{TK_OPTION_BOOLEAN,
			"-boolean", "boolean", "Boolean",
			"1", -1, Tk_Offset(InternalRecord, boolean), 0, 0, 0x1},
		{TK_OPTION_INT,

/*
 * Default values for "changes" and "atts" fields of TkWindows.  Note
 * that Tk always requests all events for all windows, except StructureNotify
 * events on internal windows:  these events are generated internally.
 */

static CONST XWindowChanges defChanges = {
    0, 0, 1, 1, 0, 0, Above
};
#define ALL_EVENTS_MASK \
    KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask| \
    EnterWindowMask|LeaveWindowMask|PointerMotionMask|ExposureMask| \
    VisibilityChangeMask|PropertyChangeMask|ColormapChangeMask
static CONST XSetWindowAttributes defAtts= {
    None,			/* background_pixmap */
    0,				/* background_pixel */
    CopyFromParent,		/* border_pixmap */
    0,				/* border_pixel */
    NorthWestGravity,		/* bit_gravity */
    NorthWestGravity,		/* win_gravity */
    NotUseful,			/* backing_store */

};

/*
 * The following structure defines all of the commands supported by
 * Tk, and the C procedures that execute them.
 */

#define ISSAFE 1
#define PASSMAINWINDOW 2

typedef struct {
    CONST char *name;			/* Name of command. */
    Tcl_CmdProc *cmdProc;	/* Command's string-based procedure. */
    Tcl_ObjCmdProc *objProc;	/* Command's object-based procedure. */


    int flags;




} TkCmd;

static CONST TkCmd commands[] = {
    /*
     * Commands that are part of the intrinsics:
     */

    {"bell",		NULL,			Tk_BellObjCmd,		PASSMAINWINDOW},
    {"bind",		NULL,			Tk_BindObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"bindtags",	NULL,			Tk_BindtagsObjCmd,	PASSMAINWINDOW|ISSAFE},
    {"clipboard",	NULL,			Tk_ClipboardObjCmd,	PASSMAINWINDOW},
    {"destroy",		NULL,			Tk_DestroyObjCmd,	PASSMAINWINDOW|ISSAFE},
    {"event",		NULL,			Tk_EventObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"focus",		NULL,			Tk_FocusObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"font",		NULL,			Tk_FontObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"grab",		NULL,			Tk_GrabObjCmd,		PASSMAINWINDOW},
    {"grid",		NULL,			Tk_GridObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"image",		NULL,			Tk_ImageObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"lower",		NULL,			Tk_LowerObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"option",		NULL,			Tk_OptionObjCmd,	PASSMAINWINDOW|ISSAFE},
    {"pack",		NULL,			Tk_PackObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"place",		NULL,			Tk_PlaceObjCmd,		ISSAFE},
    {"raise",		NULL,			Tk_RaiseObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"selection",	NULL,			Tk_SelectionObjCmd,	PASSMAINWINDOW},
    {"tk",		NULL,			Tk_TkObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"tkwait",		NULL,			Tk_TkwaitObjCmd,	PASSMAINWINDOW|ISSAFE},
#if defined(__WIN32__) || defined(MAC_TCL) || defined(MAC_OSX_TK)
    {"tk_chooseColor",  NULL,			Tk_ChooseColorObjCmd,	PASSMAINWINDOW},
    {"tk_chooseDirectory", NULL,		Tk_ChooseDirectoryObjCmd, PASSMAINWINDOW},
    {"tk_getOpenFile",  NULL,			Tk_GetOpenFileObjCmd,	PASSMAINWINDOW},
    {"tk_getSaveFile",  NULL,			Tk_GetSaveFileObjCmd,	PASSMAINWINDOW},
#endif
#if defined(__WIN32__) || defined(MAC_OSX_TK)
    {"tk_messageBox",   NULL,			Tk_MessageBoxObjCmd,	PASSMAINWINDOW},
#endif
    {"update",		NULL,			Tk_UpdateObjCmd,	PASSMAINWINDOW|ISSAFE},
    {"winfo",		NULL,			Tk_WinfoObjCmd,		PASSMAINWINDOW|ISSAFE},
    {"wm",		NULL,			Tk_WmObjCmd,		PASSMAINWINDOW},

    /*
     * Widget class commands.
     */

    {"button",		NULL,			Tk_ButtonObjCmd,	ISSAFE},
    {"canvas",		NULL,			Tk_CanvasObjCmd,	PASSMAINWINDOW|ISSAFE},
    {"checkbutton",	NULL,			Tk_CheckbuttonObjCmd,	ISSAFE},
    {"entry",		NULL,                   Tk_EntryObjCmd,		ISSAFE},
    {"frame",		NULL,			Tk_FrameObjCmd,		ISSAFE},
    {"label",		NULL,			Tk_LabelObjCmd,		ISSAFE},
    {"labelframe",	NULL,			Tk_LabelframeObjCmd,	ISSAFE},
    {"listbox",		NULL,			Tk_ListboxObjCmd,	ISSAFE},
    {"menubutton",	NULL,                   Tk_MenubuttonObjCmd,	ISSAFE},
    {"message",		NULL,			Tk_MessageObjCmd,	ISSAFE},
    {"panedwindow",	NULL,			Tk_PanedWindowObjCmd,	ISSAFE},
    {"radiobutton",	NULL,			Tk_RadiobuttonObjCmd,	ISSAFE},
    {"scale",		NULL,	                Tk_ScaleObjCmd,		ISSAFE},
    {"scrollbar",	Tk_ScrollbarCmd,	NULL,			PASSMAINWINDOW|ISSAFE},
    {"spinbox",		NULL,                   Tk_SpinboxObjCmd,	ISSAFE},
    {"text",		Tk_TextCmd,		NULL,			PASSMAINWINDOW|ISSAFE},
    {"toplevel",	NULL,			Tk_ToplevelObjCmd,	0},

    /*
     * Misc.
     */

#if defined(MAC_TCL) || defined(MAC_OSX_TK)
    {"::tk::unsupported::MacWindowStyle",
	    		NULL,	TkUnsupported1ObjCmd,			PASSMAINWINDOW|ISSAFE},
#endif
    {(char *) NULL,	(int (*) _ANSI_ARGS_((ClientData, Tcl_Interp *, int, CONST char **))) NULL, NULL, 0}
};

/*
 * The variables and table below are used to parse arguments from
 * the "argv" variable in Tk_Init.

{
    Tk_Window tkwin;
    int dummy;
    int isSafe;
    Tcl_HashEntry *hPtr;
    register TkMainInfo *mainPtr;
    register TkWindow *winPtr;
    register CONST TkCmd *cmdPtr;
    ClientData clientData;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
    
    /*
     * Panic if someone updated the TkWindow structure without
     * also updating the Tk_FakeWin structure (or vice versa).

    /*
     * Bind in Tk's commands.
     */

    isSafe = Tcl_IsSafe(interp);
    for (cmdPtr = commands; cmdPtr->name != NULL; cmdPtr++) {
	if ((cmdPtr->cmdProc == NULL) && (cmdPtr->objProc == NULL)) {
	    Tcl_Panic("TkCreateMainWindow: builtin command with NULL string and object procs");
	}
	if (cmdPtr->flags & PASSMAINWINDOW) {
	    clientData = (ClientData) tkwin;
	} else {
	    clientData = (ClientData) NULL;
	}
	if (cmdPtr->cmdProc != NULL) {
	    Tcl_CreateCommand(interp, cmdPtr->name, cmdPtr->cmdProc,
		    clientData, (void (*) _ANSI_ARGS_((ClientData))) NULL);
	} else {
	    Tcl_CreateObjCommand(interp, cmdPtr->name, cmdPtr->objProc,
		    clientData, NULL);
	}
	if (isSafe) {
	    if (!(cmdPtr->flags & ISSAFE)) {
		Tcl_HideCommand(interp, cmdPtr->name, cmdPtr->name);
	    }
	}
    }

    TkCreateMenuCmd(interp);

    /*
     * Set variables for the intepreter.
     */

	     * Invalidate all objects referring to windows
	     * with the same main window
	     */
	    winPtr->mainPtr->deletionEpoch++;
	}
	winPtr->mainPtr->refCount--;
	if (winPtr->mainPtr->refCount == 0) {
	    register CONST TkCmd *cmdPtr;

	    /*
	     * We just deleted the last window in the application.  Delete
	     * the TkMainInfo structure too and replace all of Tk's commands
	     * with dummy commands that return errors.	Also delete the
	     * "send" command to unregister the interpreter.
	     *

	    fi
	@if test "x$(TK_SHARED_BUILD)" = "x1"; then \
	    echo "Creating package index $(PKG_INDEX)"; \
	    rm -f $(PKG_INDEX); \
	    (\
	    relative=`echo | awk '{ORS=" "; split("$(TK_PKG_DIR)",a,"/"); for (f in a) {print ".."}}'`;\
	    echo "if {[package vcompare [package provide Tcl] $(TCLVERSION)] != 0} { return }";\
	    echo "if {[string match CYGWIN* \$$::tcl_platform(os)]} {";\
	    echo "    if {([info exists ::env(DISPLAY)] || [lsearch -exact \$$::argv -display] > -1)} {";\
	    echo "	package ifneeded Tk $(MAJOR_VERSION).$(MINOR_VERSION) [list load [file join \$$dir $${relative}.. bin $(TK_LIB_FILE)] Tk]";\
	    echo "    } else {";\
	    echo "	package ifneeded Tk $(MAJOR_VERSION).$(MINOR_VERSION) [list load [file join \$$dir $${relative}.. bin tk${MAJOR_VERSION}${MINOR_VERSION}.dll] Tk]";\
	    echo "    }";\
	    echo "} else {";\
	    echo "    package ifneeded Tk $(MAJOR_VERSION).$(MINOR_VERSION) [list load [file join \$$dir $${relative}$(TK_LIB_FILE)] Tk]";\
	    echo "}";\
	    ) > $(PKG_INDEX); \
	    fi
	@echo "Installing $(LIB_FILE) to $(LIB_INSTALL_DIR)/"
	@@INSTALL_LIB@
	@chmod 555 $(LIB_INSTALL_DIR)/$(LIB_FILE)
	@if test "$(TK_BUILD_EXP_FILE)" != ""; then \
	    echo "Installing $(TK_EXP_FILE) to $(LIB_INSTALL_DIR)/"; \