* Merged 8.1 branch into the main trunk

1 files changed, 887 insertions, 643 deletions

diff --git a/generic/tkEntry.c b/generic/tkEntry.c
index 9dc65ee..855d22d 100644
--- a/generic/tkEntry.c
+++ b/generic/tkEntry.c
@@ -6,12 +6,12 @@
  *	the string to be edited.
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
- * Copyright (c) 1994-1996 Sun Microsystems, Inc.
+ * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  *
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkEntry.c,v 1.2 1998/09/14 18:23:09 stanton Exp $
+ * RCS: @(#) $Id: tkEntry.c,v 1.3 1999/04/16 01:51:13 stanton Exp $
  */
 
 #include "tkInt.h"
@@ -32,6 +32,9 @@ typedef struct {
 				 * freed even after tkwin has gone away. */
     Tcl_Interp *interp;		/* Interpreter associated with entry. */
     Tcl_Command widgetCmd;	/* Token for entry's widget command. */
+    Tk_OptionTable optionTable;	/* Table that defines configuration options
+				 * available for this widget. */
+
 
     /*
      * Fields that are set by widget commands other than "configure".
@@ -39,17 +42,17 @@ typedef struct {
      
     char *string;		/* Pointer to storage for string;
 				 * NULL-terminated;  malloc-ed. */
-    int insertPos;		/* Index of character before which next
-				 * typed character will be inserted. */
+    int insertPos;		/* Character index before which next typed
+				 * character will be inserted. */
 
     /*
      * Information about what's selected, if any.
      */
 
-    int selectFirst;		/* Index of first selected character (-1 means
-				 * nothing selected. */
-    int selectLast;		/* Index of last selected character (-1 means
-				 * nothing selected. */
+    int selectFirst;		/* Character index of first selected
+				 * character (-1 means nothing selected. */
+    int selectLast;		/* Character index just after last selected
+				 * character (-1 means nothing selected. */
     int selectAnchor;		/* Fixed end of selection (i.e. "select to"
 				 * operation will use this as one end of the
 				 * selection). */
@@ -60,8 +63,8 @@ typedef struct {
 
     int scanMarkX;		/* X-position at which scan started (e.g.
 				 * button was pressed here). */
-    int scanMarkIndex;		/* Index of character that was at left of
-				 * window when scan started. */
+    int scanMarkIndex;		/* Character index of character that was at
+				 * left of window when scan started. */
 
     /*
      * Configuration settings that are updated by Tk_ConfigureWidget.
@@ -99,7 +102,7 @@ typedef struct {
     char *showChar;		/* Value of -show option.  If non-NULL, first
 				 * character is used for displaying all
 				 * characters in entry.  Malloc'ed. */
-    Tk_Uid state;		/* Normal or disabled.  Entry is read-only
+    int state;		        /* Normal or disabled.  Entry is read-only
 				 * when disabled. */
     char *textVarName;		/* Name of variable (malloc'ed) or NULL.
 				 * If non-NULL, entry's string tracks the
@@ -118,20 +121,27 @@ typedef struct {
      * configuration settings above.
      */
 
-    int numChars;		/* Number of non-NULL characters in
-				 * string (may be 0). */
-    char *displayString;	/* If non-NULL, points to string with same
+    int numBytes;		/* Length of string in bytes. */
+    int numChars;		/* Length of string in characters.  Both
+				 * string and displayString have the same
+				 * character length, but may have different
+				 * byte lengths due to being made from
+				 * different UTF-8 characters. */
+    char *displayString;	/* String to use when displaying.  This may
+				 * be a pointer to string, or a pointer to
+				 * malloced memory with the same character
 				 * length as string but whose characters
-				 * are all equal to showChar.  Malloc'ed. */
+				 * are all equal to showChar. */
+    int numDisplayBytes;	/* Length of displayString in bytes. */
     int inset;			/* Number of pixels on the left and right
 				 * sides that are taken up by XPAD, borderWidth
 				 * (if any), and highlightWidth (if any). */
     Tk_TextLayout textLayout;	/* Cached text layout information. */
     int layoutX, layoutY;	/* Origin for layout. */
-    int leftIndex;		/* Index of left-most character visible in
-				 * window. */
     int leftX;			/* X position at which character at leftIndex
 				 * is drawn (varies depending on justify). */
+    int leftIndex;		/* Character index of left-most character
+				 * visible in window. */
     Tcl_TimerToken insertBlinkHandler;
 				/* Timer handler used to blink cursor on and
 				 * off. */
@@ -167,6 +177,7 @@ typedef struct {
 #define GOT_FOCUS		8
 #define UPDATE_SCROLLBAR	0x10
 #define GOT_SELECTION		0x20
+#define ENTRY_DELETED           0x40
 
 /*
  * The following macro defines how many extra pixels to leave on each
@@ -177,93 +188,108 @@ typedef struct {
 #define YPAD 1
 
 /*
+ * The following enum is used to define a type for the -state option
+ * of the Entry widget.  These values are used as indices into the 
+ * string table below.
+ */
+
+enum state {
+    STATE_DISABLED, STATE_NORMAL
+};
+
+static char *stateStrings[] = {
+    "disabled", "normal", (char *) NULL
+};
+
+/*
  * Information used for argv parsing.
  */
 
-static Tk_ConfigSpec configSpecs[] = {
-    {TK_CONFIG_BORDER, "-background", "background", "Background",
-	DEF_ENTRY_BG_COLOR, Tk_Offset(Entry, normalBorder),
-	TK_CONFIG_COLOR_ONLY},
-    {TK_CONFIG_BORDER, "-background", "background", "Background",
-	DEF_ENTRY_BG_MONO, Tk_Offset(Entry, normalBorder),
-	TK_CONFIG_MONO_ONLY},
-    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
-	(char *) NULL, 0, 0},
-    {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
-	(char *) NULL, 0, 0},
-    {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
-	DEF_ENTRY_BORDER_WIDTH, Tk_Offset(Entry, borderWidth), 0},
-    {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
-	DEF_ENTRY_CURSOR, Tk_Offset(Entry, cursor), TK_CONFIG_NULL_OK},
-    {TK_CONFIG_BOOLEAN, "-exportselection", "exportSelection",
-	"ExportSelection", DEF_ENTRY_EXPORT_SELECTION,
-	Tk_Offset(Entry, exportSelection), 0},
-    {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
-	(char *) NULL, 0, 0},
-    {TK_CONFIG_FONT, "-font", "font", "Font",
-	DEF_ENTRY_FONT, Tk_Offset(Entry, tkfont), 0},
-    {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
-	DEF_ENTRY_FG, Tk_Offset(Entry, fgColorPtr), 0},
-    {TK_CONFIG_COLOR, "-highlightbackground", "highlightBackground",
+static Tk_OptionSpec optionSpecs[] = {
+    {TK_OPTION_BORDER, "-background", "background", "Background",
+	DEF_ENTRY_BG_COLOR, -1, Tk_Offset(Entry, normalBorder),
+	0, (ClientData) DEF_ENTRY_BG_MONO, 0},
+    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
+	(char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
+    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
+	(char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
+    {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
+	DEF_ENTRY_BORDER_WIDTH, -1, Tk_Offset(Entry, borderWidth), 
+        0, 0, 0},
+    {TK_OPTION_CURSOR, "-cursor", "cursor", "Cursor",
+	DEF_ENTRY_CURSOR, -1, Tk_Offset(Entry, cursor),
+	TK_OPTION_NULL_OK, 0, 0},
+    {TK_OPTION_BOOLEAN, "-exportselection", "exportSelection",
+        "ExportSelection", DEF_ENTRY_EXPORT_SELECTION, -1, 
+        Tk_Offset(Entry, exportSelection), 0, 0, 0},
+    {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
+	(char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
+    {TK_OPTION_FONT, "-font", "font", "Font",
+	DEF_ENTRY_FONT, -1, Tk_Offset(Entry, tkfont), 0, 0, 0},
+    {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
+	DEF_ENTRY_FG, -1, Tk_Offset(Entry, fgColorPtr), 0, 
+        0, 0},
+    {TK_OPTION_COLOR, "-highlightbackground", "highlightBackground",
 	"HighlightBackground", DEF_ENTRY_HIGHLIGHT_BG,
-	Tk_Offset(Entry, highlightBgColorPtr), 0},
-    {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
-	DEF_ENTRY_HIGHLIGHT, Tk_Offset(Entry, highlightColorPtr), 0},
-    {TK_CONFIG_PIXELS, "-highlightthickness", "highlightThickness",
-	"HighlightThickness",
-	DEF_ENTRY_HIGHLIGHT_WIDTH, Tk_Offset(Entry, highlightWidth), 0},
-    {TK_CONFIG_BORDER, "-insertbackground", "insertBackground", "Foreground",
-	DEF_ENTRY_INSERT_BG, Tk_Offset(Entry, insertBorder), 0},
-    {TK_CONFIG_PIXELS, "-insertborderwidth", "insertBorderWidth", "BorderWidth",
-	DEF_ENTRY_INSERT_BD_COLOR, Tk_Offset(Entry, insertBorderWidth),
-	TK_CONFIG_COLOR_ONLY},
-    {TK_CONFIG_PIXELS, "-insertborderwidth", "insertBorderWidth", "BorderWidth",
-	DEF_ENTRY_INSERT_BD_MONO, Tk_Offset(Entry, insertBorderWidth),
-	TK_CONFIG_MONO_ONLY},
-    {TK_CONFIG_INT, "-insertofftime", "insertOffTime", "OffTime",
-	DEF_ENTRY_INSERT_OFF_TIME, Tk_Offset(Entry, insertOffTime), 0},
-    {TK_CONFIG_INT, "-insertontime", "insertOnTime", "OnTime",
-	DEF_ENTRY_INSERT_ON_TIME, Tk_Offset(Entry, insertOnTime), 0},
-    {TK_CONFIG_PIXELS, "-insertwidth", "insertWidth", "InsertWidth",
-	DEF_ENTRY_INSERT_WIDTH, Tk_Offset(Entry, insertWidth), 0},
-    {TK_CONFIG_JUSTIFY, "-justify", "justify", "Justify",
-	DEF_ENTRY_JUSTIFY, Tk_Offset(Entry, justify), 0},
-    {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
-	DEF_ENTRY_RELIEF, Tk_Offset(Entry, relief), 0},
-    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
-	DEF_ENTRY_SELECT_COLOR, Tk_Offset(Entry, selBorder),
-	TK_CONFIG_COLOR_ONLY},
-    {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground",
-	DEF_ENTRY_SELECT_MONO, Tk_Offset(Entry, selBorder),
-	TK_CONFIG_MONO_ONLY},
-    {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth", "BorderWidth",
-	DEF_ENTRY_SELECT_BD_COLOR, Tk_Offset(Entry, selBorderWidth),
-	TK_CONFIG_COLOR_ONLY},
-    {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth", "BorderWidth",
-	DEF_ENTRY_SELECT_BD_MONO, Tk_Offset(Entry, selBorderWidth),
-	TK_CONFIG_MONO_ONLY},
-    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
-	DEF_ENTRY_SELECT_FG_COLOR, Tk_Offset(Entry, selFgColorPtr),
-	TK_CONFIG_COLOR_ONLY},
-    {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background",
-	DEF_ENTRY_SELECT_FG_MONO, Tk_Offset(Entry, selFgColorPtr),
-	TK_CONFIG_MONO_ONLY},
+	-1, Tk_Offset(Entry, highlightBgColorPtr), 
+        0, 0, 0},
+    {TK_OPTION_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
+	DEF_ENTRY_HIGHLIGHT, -1, Tk_Offset(Entry, highlightColorPtr),
+	0, 0, 0},
+    {TK_OPTION_PIXELS, "-highlightthickness", "highlightThickness",
+	"HighlightThickness", DEF_ENTRY_HIGHLIGHT_WIDTH, -1, 
+	Tk_Offset(Entry, highlightWidth), 0, 0, 0},
+    {TK_OPTION_BORDER, "-insertbackground", "insertBackground", "Foreground",
+	DEF_ENTRY_INSERT_BG,
+	-1, Tk_Offset(Entry, insertBorder), 
+        0, 0, 0},
+    {TK_OPTION_PIXELS, "-insertborderwidth", "insertBorderWidth", 
+        "BorderWidth", DEF_ENTRY_INSERT_BD_COLOR, -1, 
+        Tk_Offset(Entry, insertBorderWidth), 0, 
+        (ClientData) DEF_ENTRY_INSERT_BD_MONO, 0},
+    {TK_OPTION_INT, "-insertofftime", "insertOffTime", "OffTime",
+        DEF_ENTRY_INSERT_OFF_TIME, -1, Tk_Offset(Entry, insertOffTime), 
+        0, 0, 0},
+    {TK_OPTION_INT, "-insertontime", "insertOnTime", "OnTime",
+        DEF_ENTRY_INSERT_ON_TIME, -1, Tk_Offset(Entry, insertOnTime), 
+        0, 0, 0},
+    {TK_OPTION_PIXELS, "-insertwidth", "insertWidth", "InsertWidth",
+	DEF_ENTRY_INSERT_WIDTH, -1, Tk_Offset(Entry, insertWidth), 
+        0, 0, 0},
+    {TK_OPTION_JUSTIFY, "-justify", "justify", "Justify",
+	DEF_ENTRY_JUSTIFY, -1, Tk_Offset(Entry, justify), 0, 0, 0},
+    {TK_OPTION_RELIEF, "-relief", "relief", "Relief",
+	DEF_ENTRY_RELIEF, -1, Tk_Offset(Entry, relief), 
+        0, 0, 0},
+    {TK_OPTION_BORDER, "-selectbackground", "selectBackground", "Foreground",
+        DEF_ENTRY_SELECT_COLOR, -1, Tk_Offset(Entry, selBorder),
+        0, (ClientData) DEF_ENTRY_SELECT_MONO, 0},
+    {TK_OPTION_PIXELS, "-selectborderwidth", "selectBorderWidth", 
+        "BorderWidth", DEF_ENTRY_SELECT_BD_COLOR, -1, 
+        Tk_Offset(Entry, selBorderWidth), 
+        0, (ClientData) DEF_ENTRY_SELECT_BD_MONO, 0},
+    {TK_OPTION_COLOR, "-selectforeground", "selectForeground", "Background",
+	DEF_ENTRY_SELECT_FG_COLOR, -1, Tk_Offset(Entry, selFgColorPtr),
+	0, (ClientData) DEF_ENTRY_SELECT_FG_MONO, 0},
     {TK_CONFIG_STRING, "-show", "show", "Show",
-	DEF_ENTRY_SHOW, Tk_Offset(Entry, showChar), TK_CONFIG_NULL_OK},
-    {TK_CONFIG_UID, "-state", "state", "State",
-	DEF_ENTRY_STATE, Tk_Offset(Entry, state), 0},
-    {TK_CONFIG_STRING, "-takefocus", "takeFocus", "TakeFocus",
-	DEF_ENTRY_TAKE_FOCUS, Tk_Offset(Entry, takeFocus), TK_CONFIG_NULL_OK},
-    {TK_CONFIG_STRING, "-textvariable", "textVariable", "Variable",
-	DEF_ENTRY_TEXT_VARIABLE, Tk_Offset(Entry, textVarName),
-	TK_CONFIG_NULL_OK},
-    {TK_CONFIG_INT, "-width", "width", "Width",
-	DEF_ENTRY_WIDTH, Tk_Offset(Entry, prefWidth), 0},
-    {TK_CONFIG_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
-	DEF_ENTRY_SCROLL_COMMAND, Tk_Offset(Entry, scrollCmd),
-	TK_CONFIG_NULL_OK},
-    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, 0}
+        DEF_ENTRY_SHOW, -1, Tk_Offset(Entry, showChar), 
+        TK_OPTION_NULL_OK, 0, 0},
+    {TK_OPTION_STRING_TABLE, "-state", "state", "State",
+	DEF_ENTRY_STATE, -1, Tk_Offset(Entry, state), 
+        0, (ClientData) stateStrings, 0},
+    {TK_OPTION_STRING, "-takefocus", "takeFocus", "TakeFocus",
+	DEF_ENTRY_TAKE_FOCUS, -1, Tk_Offset(Entry, takeFocus), 
+        TK_CONFIG_NULL_OK, 0, 0},
+    {TK_OPTION_STRING, "-textvariable", "textVariable", "Variable",
+	DEF_ENTRY_TEXT_VARIABLE, -1, Tk_Offset(Entry, textVarName),
+	TK_CONFIG_NULL_OK, 0, 0},
+    {TK_OPTION_INT, "-width", "width", "Width",
+	DEF_ENTRY_WIDTH, -1, Tk_Offset(Entry, prefWidth), 0, 0, 0},
+    {TK_OPTION_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
+	DEF_ENTRY_SCROLL_COMMAND, -1, Tk_Offset(Entry, scrollCmd),
+	TK_CONFIG_NULL_OK, 0, 0},
+    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
+	(char *) NULL, 0, -1, 0, 0, 0}
 };
 
 /*
@@ -274,12 +300,38 @@ static Tk_ConfigSpec configSpecs[] = {
 #define LAST_PLUS_ONE_OK	2
 
 /*
+ * The following tables define the entry widget commands (and sub-
+ * commands) and map the indexes into the string tables into 
+ * enumerated types used to dispatch the entry widget command.
+ */
+
+static char *commandNames[] = {
+    "bbox", "cget", "configure", "delete", "get", "icursor", "index", 
+    "insert", "scan", "selection", "xview", (char *) NULL
+};
+
+enum command {
+    COMMAND_BBOX, COMMAND_CGET, COMMAND_CONFIGURE, COMMAND_DELETE, 
+    COMMAND_GET, COMMAND_ICURSOR, COMMAND_INDEX, COMMAND_INSERT, 
+    COMMAND_SCAN, COMMAND_SELECTION, COMMAND_XVIEW
+};
+
+static char *selCommandNames[] = {
+    "adjust", "clear", "from", "present", "range", "to", (char *) NULL
+};
+
+enum selcommand {
+    SELECTION_ADJUST, SELECTION_CLEAR, SELECTION_FROM, 
+    SELECTION_PRESENT, SELECTION_RANGE, SELECTION_TO
+};
+
+/*
  * Forward declarations for procedures defined later in this file:
  */
 
 static int		ConfigureEntry _ANSI_ARGS_((Tcl_Interp *interp,
-			    Entry *entryPtr, int argc, char **argv,
-			    int flags));
+			    Entry *entryPtr, int objc, 
+                            Tcl_Obj *CONST objv[], int flags));
 static void		DeleteChars _ANSI_ARGS_((Entry *entryPtr, int index,
 			    int count));
 static void		DestroyEntry _ANSI_ARGS_((char *memPtr));
@@ -309,8 +361,9 @@ static void		EntryUpdateScrollbar _ANSI_ARGS_((Entry *entryPtr));
 static void		EntryValueChanged _ANSI_ARGS_((Entry *entryPtr));
 static void		EntryVisibleRange _ANSI_ARGS_((Entry *entryPtr,
 			    double *firstPtr, double *lastPtr));
-static int		EntryWidgetCmd _ANSI_ARGS_((ClientData clientData,
-			    Tcl_Interp *interp, int argc, char **argv));
+static int		EntryWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
+			    Tcl_Interp *interp, int objc, 
+			    Tcl_Obj *CONST objv[]));
 static void		EntryWorldChanged _ANSI_ARGS_((
 			    ClientData instanceData));
 static int		GetEntryIndex _ANSI_ARGS_((Tcl_Interp *interp,
@@ -333,7 +386,7 @@ static TkClassProcs entryClass = {
 /*
  *--------------------------------------------------------------
  *
- * Tk_EntryCmd --
+ * Tk_EntryObjCmd --
  *
  *	This procedure is invoked to process the "entry" Tcl
  *	command.  See the user documentation for details on what
@@ -349,25 +402,43 @@ static TkClassProcs entryClass = {
  */
 
 int
-Tk_EntryCmd(clientData, interp, argc, argv)
-    ClientData clientData;	/* Main window associated with
-				 * interpreter. */
+Tk_EntryObjCmd(clientData, interp, objc, objv)
+    ClientData clientData;	/* Either NULL or pointer to option table. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];      /* Argument objects. */
 {
-    Tk_Window tkwin = (Tk_Window) clientData;
     register Entry *entryPtr;
-    Tk_Window new;
+    Tk_OptionTable optionTable;
+    Tk_Window tkwin;
+
+    optionTable = (Tk_OptionTable) clientData;
+    if (optionTable == NULL) {
+	Tcl_CmdInfo info;
+	char *name;
+
+	/*
+	 * We haven't created the option table for this widget class
+	 * yet.  Do it now and save the table as the clientData for
+	 * the command, so we'll have access to it in future
+	 * invocations of the command.
+	 */
+
+	optionTable = Tk_CreateOptionTable(interp, optionSpecs);
+	name = Tcl_GetString(objv[0]);
+	Tcl_GetCommandInfo(interp, name, &info);
+	info.objClientData = (ClientData) optionTable;
+	Tcl_SetCommandInfo(interp, name, &info);
+    }
 
-    if (argc < 2) {
-	Tcl_AppendResult(interp, "wrong # args: should be \"",
-		argv[0], " pathName ?options?\"", (char *) NULL);
+    if (objc < 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "pathName ?options?");
 	return TCL_ERROR;
     }
 
-    new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL);
-    if (new == NULL) {
+    tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
+            Tcl_GetString(objv[1]), (char *) NULL);
+    if (tkwin == NULL) {
 	return TCL_ERROR;
     }
 
@@ -378,12 +449,13 @@ Tk_EntryCmd(clientData, interp, argc, argv)
      */
 
     entryPtr = (Entry *) ckalloc(sizeof(Entry));
-    entryPtr->tkwin = new;
-    entryPtr->display = Tk_Display(new);
+    entryPtr->tkwin = tkwin;
+    entryPtr->display = Tk_Display(tkwin);
     entryPtr->interp = interp;
-    entryPtr->widgetCmd = Tcl_CreateCommand(interp,
-	    Tk_PathName(entryPtr->tkwin), EntryWidgetCmd,
+    entryPtr->widgetCmd = Tcl_CreateObjCommand(interp,
+	    Tk_PathName(entryPtr->tkwin), EntryWidgetObjCmd,
 	    (ClientData) entryPtr, EntryCmdDeletedProc);
+    entryPtr->optionTable = optionTable;
     entryPtr->string = (char *) ckalloc(1);
     entryPtr->string[0] = '\0';
     entryPtr->insertPos = 0;
@@ -413,20 +485,21 @@ Tk_EntryCmd(clientData, interp, argc, argv)
     entryPtr->selBorderWidth = 0;
     entryPtr->selFgColorPtr = NULL;
     entryPtr->showChar = NULL;
-    entryPtr->state = tkNormalUid;
+    entryPtr->state = STATE_NORMAL;
     entryPtr->textVarName = NULL;
     entryPtr->takeFocus = NULL;
     entryPtr->prefWidth = 0;
     entryPtr->scrollCmd = NULL;
-
+    entryPtr->numBytes = 0;
     entryPtr->numChars = 0;
-    entryPtr->displayString = NULL;
+    entryPtr->displayString = entryPtr->string;
+    entryPtr->numDisplayBytes = 0;
     entryPtr->inset = XPAD;
     entryPtr->textLayout = NULL;
     entryPtr->layoutX = 0;
     entryPtr->layoutY = 0;
-    entryPtr->leftIndex = 0;
     entryPtr->leftX = 0;
+    entryPtr->leftIndex = 0;
     entryPtr->insertBlinkHandler = (Tcl_TimerToken) NULL;
     entryPtr->textGC = None;
     entryPtr->selTextGC = None;
@@ -441,11 +514,17 @@ Tk_EntryCmd(clientData, interp, argc, argv)
 	    EntryEventProc, (ClientData) entryPtr);
     Tk_CreateSelHandler(entryPtr->tkwin, XA_PRIMARY, XA_STRING,
 	    EntryFetchSelection, (ClientData) entryPtr, XA_STRING);
-    if (ConfigureEntry(interp, entryPtr, argc-2, argv+2, 0) != TCL_OK) {
+
+    if (Tk_InitOptions(interp, (char *) entryPtr, optionTable, tkwin)
+	    != TCL_OK) {
+	Tk_DestroyWindow(entryPtr->tkwin);
+	return TCL_ERROR;
+    }
+    if (ConfigureEntry(interp, entryPtr, objc-2, objv+2, 0) != TCL_OK) {
 	goto error;
     }
-
-    interp->result = Tk_PathName(entryPtr->tkwin);
+    
+    Tcl_SetResult(interp, Tk_PathName(entryPtr->tkwin), TCL_STATIC);
     return TCL_OK;
 
     error:
@@ -456,7 +535,7 @@ Tk_EntryCmd(clientData, interp, argc, argv)
 /*
  *--------------------------------------------------------------
  *
- * EntryWidgetCmd --
+ * EntryWidgetObjCmd --
  *
  *	This procedure is invoked to process the Tcl command
  *	that corresponds to a widget managed by this module.
@@ -472,321 +551,405 @@ Tk_EntryCmd(clientData, interp, argc, argv)
  */
 
 static int
-EntryWidgetCmd(clientData, interp, argc, argv)
-    ClientData clientData;		/* Information about entry widget. */
-    Tcl_Interp *interp;			/* Current interpreter. */
-    int argc;				/* Number of arguments. */
-    char **argv;			/* Argument strings. */
+EntryWidgetObjCmd(clientData, interp, objc, objv)
+    ClientData clientData;	/* Information about entry widget. */
+    Tcl_Interp *interp;		/* Current interpreter. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
 {
-    register Entry *entryPtr = (Entry *) clientData;
-    int result = TCL_OK;
-    size_t length;
-    int c;
+    Entry *entryPtr = (Entry *) clientData;
+    int cmdIndex, selIndex, result;
+    Tcl_Obj *objPtr;
 
-    if (argc < 2) {
-	Tcl_AppendResult(interp, "wrong # args: should be \"",
-		argv[0], " option ?arg arg ...?\"", (char *) NULL);
+    if (objc < 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
 	return TCL_ERROR;
     }
     Tcl_Preserve((ClientData) entryPtr);
-    c = argv[1][0];
-    length = strlen(argv[1]);
-    if ((c == 'b') && (strncmp(argv[1], "bbox", length) == 0)) {
-	int index;
-	int x, y, width, height;
-
-	if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " bbox index\"",
-		    (char *) NULL);
-	    goto error;
-	}
-	if (GetEntryIndex(interp, entryPtr, argv[2], &index) != TCL_OK) {
-	    goto error;
-	}
-	if ((index == entryPtr->numChars) && (index > 0)) {
-	    index--;
-	}
-	Tk_CharBbox(entryPtr->textLayout, index, &x, &y, &width, &height);
-	sprintf(interp->result, "%d %d %d %d",
-		x + entryPtr->layoutX, y + entryPtr->layoutY, width, height);
-    } else if ((c == 'c') && (strncmp(argv[1], "cget", length) == 0)
-	    && (length >= 2)) {
-	if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " cget option\"",
-		    (char *) NULL);
-	    goto error;
-	}
-	result = Tk_ConfigureValue(interp, entryPtr->tkwin, configSpecs,
-		(char *) entryPtr, argv[2], 0);
-    } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)
-	    && (length >= 2)) {
-	if (argc == 2) {
-	    result = Tk_ConfigureInfo(interp, entryPtr->tkwin, configSpecs,
-		    (char *) entryPtr, (char *) NULL, 0);
-	} else if (argc == 3) {
-	    result = Tk_ConfigureInfo(interp, entryPtr->tkwin, configSpecs,
-		    (char *) entryPtr, argv[2], 0);
-	} else {
-	    result = ConfigureEntry(interp, entryPtr, argc-2, argv+2,
-		    TK_CONFIG_ARGV_ONLY);
-	}
-    } else if ((c == 'd') && (strncmp(argv[1], "delete", length) == 0)) {
-	int first, last;
-
-	if ((argc < 3) || (argc > 4)) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " delete firstIndex ?lastIndex?\"",
-		    (char *) NULL);
-	    goto error;
-	}
-	if (GetEntryIndex(interp, entryPtr, argv[2], &first) != TCL_OK) {
-	    goto error;
-	}
-	if (argc == 3) {
-	    last = first+1;
-	} else {
-	    if (GetEntryIndex(interp, entryPtr, argv[3], &last) != TCL_OK) {
+
+    /* 
+     * Parse the widget command by looking up the second token in
+     * the list of valid command names. 
+     */
+
+    result = Tcl_GetIndexFromObj(interp, objv[1], commandNames,
+	    "option", 0, &cmdIndex);
+    if (result != TCL_OK) {
+	return result;
+    }
+
+    switch (cmdIndex) {
+        case COMMAND_BBOX: {
+	    int index, x, y, width, height;
+	    char *string;
+	    char buf[TCL_INTEGER_SPACE * 4];
+
+	    if (objc != 3) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "bbox index");
 		goto error;
 	    }
-	}
-	if ((last >= first) && (entryPtr->state == tkNormalUid)) {
-	    DeleteChars(entryPtr, first, last-first);
-	}
-    } else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) {
-	if (argc != 2) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " get\"", (char *) NULL);
-	    goto error;
-	}
-	interp->result = entryPtr->string;
-    } else if ((c == 'i') && (strncmp(argv[1], "icursor", length) == 0)
-	    && (length >= 2)) {
-	if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " icursor pos\"",
-		    (char *) NULL);
-	    goto error;
-	}
-	if (GetEntryIndex(interp, entryPtr, argv[2], &entryPtr->insertPos)
-		!= TCL_OK) {
-	    goto error;
-	}
-	EventuallyRedraw(entryPtr);
-    } else if ((c == 'i') && (strncmp(argv[1], "index", length) == 0)
-	    && (length >= 3)) {
-	int index;
-
-	if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " index string\"", (char *) NULL);
-	    goto error;
-	}
-	if (GetEntryIndex(interp, entryPtr, argv[2], &index) != TCL_OK) {
-	    goto error;
-	}
-	sprintf(interp->result, "%d", index);
-    } else if ((c == 'i') && (strncmp(argv[1], "insert", length) == 0)
-	    && (length >= 3)) {
-	int index;
-
-	if (argc != 4) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " insert index text\"",
-		    (char *) NULL);
-	    goto error;
-	}
-	if (GetEntryIndex(interp, entryPtr, argv[2], &index) != TCL_OK) {
-	    goto error;
-	}
-	if (entryPtr->state == tkNormalUid) {
-	    InsertChars(entryPtr, index, argv[3]);
-	}
-    } else if ((c == 's') && (length >= 2)
-	    && (strncmp(argv[1], "scan", length) == 0)) {
-	int x;
-
-	if (argc != 4) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " scan mark|dragto x\"", (char *) NULL);
-	    goto error;
-	}
-	if (Tcl_GetInt(interp, argv[3], &x) != TCL_OK) {
-	    goto error;
-	}
-	if ((argv[2][0] == 'm')
-		&& (strncmp(argv[2], "mark", strlen(argv[2])) == 0)) {
-	    entryPtr->scanMarkX = x;
-	    entryPtr->scanMarkIndex = entryPtr->leftIndex;
-	} else if ((argv[2][0] == 'd')
-		&& (strncmp(argv[2], "dragto", strlen(argv[2])) == 0)) {
-	    EntryScanTo(entryPtr, x);
-	} else {
-	    Tcl_AppendResult(interp, "bad scan option \"", argv[2],
-		    "\": must be mark or dragto", (char *) NULL);
-	    goto error;
-	}
-    } else if ((c == 's') && (length >= 2)
-	    && (strncmp(argv[1], "selection", length) == 0)) {
-	int index, index2;
-
-	if (argc < 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " select option ?index?\"", (char *) NULL);
-	    goto error;
-	}
-	length = strlen(argv[2]);
-	c = argv[2][0];
-	if ((c == 'c') && (strncmp(argv[2], "clear", length) == 0)) {
-	    if (argc != 3) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection clear\"", (char *) NULL);
-		goto error;
+	    if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]), 
+                    &index) != TCL_OK) {
+	        goto error;
 	    }
-	    if (entryPtr->selectFirst != -1) {
-		entryPtr->selectFirst = entryPtr->selectLast = -1;
-		EventuallyRedraw(entryPtr);
+	    if ((index == entryPtr->numChars) && (index > 0)) {
+	        index--;
 	    }
-	    goto done;
-	} else if ((c == 'p') && (strncmp(argv[2], "present", length) == 0)) {
-	    if (argc != 3) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection present\"", (char *) NULL);
+	    string = entryPtr->displayString;
+	    Tk_CharBbox(entryPtr->textLayout, index, &x, &y, 
+                    &width, &height);
+	    sprintf(buf, "%d %d %d %d", x + entryPtr->layoutX,
+		    y + entryPtr->layoutY, width, height);
+	    Tcl_SetResult(interp, buf, TCL_VOLATILE);
+	    break;
+	} 
+	
+        case COMMAND_CGET: {
+	    if (objc != 3) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "cget option");
 		goto error;
 	    }
-	    if (entryPtr->selectFirst == -1) {
-		interp->result = "0";
+	    
+	    objPtr = Tk_GetOptionValue(interp, (char *) entryPtr,
+		    entryPtr->optionTable, objv[2], entryPtr->tkwin);
+	    if (objPtr == NULL) {
+		 goto error;
 	    } else {
-		interp->result = "1";
+		Tcl_SetObjResult(interp, objPtr);
 	    }
-	    goto done;
+	    break;
 	}
-	if (argc >= 4) {
-	    if (GetEntryIndex(interp, entryPtr, argv[3], &index) != TCL_OK) {
-		goto error;
+
+        case COMMAND_CONFIGURE: {
+	    if (objc <= 3) {
+		objPtr = Tk_GetOptionInfo(interp, (char *) entryPtr,
+			entryPtr->optionTable,
+			(objc == 3) ? objv[2] : (Tcl_Obj *) NULL,
+			entryPtr->tkwin);
+		if (objPtr == NULL) {
+		    goto error;
+		} else {
+		    Tcl_SetObjResult(interp, objPtr);
+		}
+	    } else {
+		result = ConfigureEntry(interp, entryPtr, objc-2, objv+2, 0);
 	    }
+	    break;
 	}
-	if ((c == 'a') && (strncmp(argv[2], "adjust", length) == 0)) {
-	    if (argc != 4) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection adjust index\"",
-			(char *) NULL);
+
+        case COMMAND_DELETE: {
+	    int first, last;
+
+	    if ((objc < 3) || (objc > 4)) {
+	        Tcl_WrongNumArgs(interp, 1, objv, 
+                        "delete firstIndex ?lastIndex?");
 		goto error;
 	    }
-	    if (entryPtr->selectFirst >= 0) {
-		int half1, half2;
-
-		half1 = (entryPtr->selectFirst + entryPtr->selectLast)/2;
-		half2 = (entryPtr->selectFirst + entryPtr->selectLast + 1)/2;
-		if (index < half1) {
-		    entryPtr->selectAnchor = entryPtr->selectLast;
-		} else if (index > half2) {
-		    entryPtr->selectAnchor = entryPtr->selectFirst;
-		} else {
-		    /*
-		     * We're at about the halfway point in the selection;
-		     * just keep the existing anchor.
-		     */
+	    if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]), 
+                    &first) != TCL_OK) {
+	        goto error;
+	    }
+	    if (objc == 3) {
+	        last = first + 1;
+	    } else {
+	        if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[3]), 
+                        &last) != TCL_OK) {
+		    goto error;
 		}
 	    }
-	    EntrySelectTo(entryPtr, index);
-	} else if ((c == 'f') && (strncmp(argv[2], "from", length) == 0)) {
-	    if (argc != 4) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection from index\"",
-			(char *) NULL);
+	    if ((last >= first) && (entryPtr->state == STATE_NORMAL)) {
+	        DeleteChars(entryPtr, first, last - first);
+	    }
+	    break;
+	}
+
+        case COMMAND_GET: {
+	    if (objc != 2) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "get");
 		goto error;
 	    }
-	    entryPtr->selectAnchor = index;
-	} else if ((c == 'r') && (strncmp(argv[2], "range", length) == 0)) {
-	    if (argc != 5) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection range start end\"",
-			(char *) NULL);
+	    Tcl_SetResult(interp, entryPtr->string, TCL_STATIC);
+	    break;
+	}
+
+        case COMMAND_ICURSOR: {
+	    if (objc != 3) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "icursor pos");
 		goto error;
 	    }
-	    if (GetEntryIndex(interp, entryPtr, argv[4], &index2) != TCL_OK) {
+	    if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]),
+                    &entryPtr->insertPos) != TCL_OK) {
+	        goto error;
+	    }
+	    EventuallyRedraw(entryPtr);
+	    break;
+	}
+	
+        case COMMAND_INDEX: {
+	    int index;
+	    char buf[TCL_INTEGER_SPACE];
+
+	    if (objc != 3) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "index string");
 		goto error;
 	    }
-	    if (index >= index2) {
-		entryPtr->selectFirst = entryPtr->selectLast = -1;
-	    } else {
-		entryPtr->selectFirst = index;
-		entryPtr->selectLast = index2;
+	    if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]), 
+                    &index) != TCL_OK) {
+	        goto error;
 	    }
-	    if (!(entryPtr->flags & GOT_SELECTION)
-		    && (entryPtr->exportSelection)) {
-		Tk_OwnSelection(entryPtr->tkwin, XA_PRIMARY, 
-			EntryLostSelection, (ClientData) entryPtr);
-		entryPtr->flags |= GOT_SELECTION;
+	    sprintf(buf, "%d", index);
+	    Tcl_SetResult(interp, buf, TCL_VOLATILE);
+	    break;
+	}
+
+        case COMMAND_INSERT: {
+	    int index;
+
+	    if (objc != 4) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "insert index text");
+		goto error;
 	    }
-	    EventuallyRedraw(entryPtr);
-	} else if ((c == 't') && (strncmp(argv[2], "to", length) == 0)) {
-	    if (argc != 4) {
-		Tcl_AppendResult(interp, "wrong # args: should be \"",
-			argv[0], " selection to index\"",
-			(char *) NULL);
+	    if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]), 
+                    &index) != TCL_OK) {
+	        goto error;
+	    }
+	    if (entryPtr->state == STATE_NORMAL) {
+	        InsertChars(entryPtr, index, Tcl_GetString(objv[3]));
+	    }
+	    break;
+	}
+
+        case COMMAND_SCAN: {
+	    int x;
+	    char *minorCmd;
+
+	    if (objc != 4) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "scan mark|dragto x");
 		goto error;
 	    }
-	    EntrySelectTo(entryPtr, index);
-	} else {
-	    Tcl_AppendResult(interp, "bad selection option \"", argv[2],
-		    "\": must be adjust, clear, from, present, range, or to",
-		    (char *) NULL);
-	    goto error;
+	    if (Tcl_GetIntFromObj(interp, objv[3], &x) != TCL_OK) {
+	        goto error;
+	    }
+
+	    minorCmd = Tcl_GetString(objv[2]);
+	    if (minorCmd[0] == 'm' 
+                    && (strncmp(minorCmd, "mark", strlen(minorCmd)) == 0)) {
+	        entryPtr->scanMarkX = x;
+		entryPtr->scanMarkIndex = entryPtr->leftIndex;
+	    } else if ((minorCmd[0] == 'd')
+		&& (strncmp(minorCmd, "dragto", strlen(minorCmd)) == 0)) {
+	        EntryScanTo(entryPtr, x);
+	    } else {
+	        Tcl_AppendResult(interp, "bad scan option \"", 
+                        Tcl_GetString(objv[2]), "\": must be mark or dragto", 
+                        (char *) NULL);
+		goto error;
+	    }
+	    break;
 	}
-    } else if ((c == 'x') && (strncmp(argv[1], "xview", length) == 0)) {
-	int index, type, count, charsPerPage;
-	double fraction, first, last;
-
-	if (argc == 2) {
-	    EntryVisibleRange(entryPtr, &first, &last);
-	    sprintf(interp->result, "%g %g", first, last);
-	    goto done;
-	} else if (argc == 3) {
-	    if (GetEntryIndex(interp, entryPtr, argv[2], &index) != TCL_OK) {
+	    
+	case COMMAND_SELECTION: {
+	    int index, index2;
+
+	    if (objc < 3) {
+	        Tcl_WrongNumArgs(interp, 1, objv, "select option ?index?");
 		goto error;
 	    }
-	} else {
-	    type = Tk_GetScrollInfo(interp, argc, argv, &fraction, &count);
-	    index = entryPtr->leftIndex;
-	    switch (type) {
-		case TK_SCROLL_ERROR:
-		    goto error;
-		case TK_SCROLL_MOVETO:
-		    index = (int) ((fraction * entryPtr->numChars) + 0.5);
+
+	    /* 
+	     * Parse the selection sub-command, using the command
+	     * table "selCommandNames" defined above.
+	     */
+	    
+	    result = Tcl_GetIndexFromObj(interp, objv[2], selCommandNames,
+                    "selection option", 0, &selIndex);
+	    if (result != TCL_OK) {
+	        goto error;
+	    }
+
+	    switch(selIndex) {
+	        case SELECTION_ADJUST: {
+		    if (objc != 4) {
+		        Tcl_WrongNumArgs(interp, 1, objv, 
+                                "selection adjust index");
+			goto error;
+		    }
+		    if (GetEntryIndex(interp, entryPtr, 
+                            Tcl_GetString(objv[3]), &index) != TCL_OK) {
+		        goto error;
+		    }
+		    if (entryPtr->selectFirst >= 0) {
+		        int half1, half2;
+		
+			half1 = (entryPtr->selectFirst 
+			        + entryPtr->selectLast)/2;
+			half2 = (entryPtr->selectFirst 
+				+ entryPtr->selectLast + 1)/2;
+			if (index < half1) {
+			    entryPtr->selectAnchor = entryPtr->selectLast;
+			} else if (index > half2) {
+			    entryPtr->selectAnchor = entryPtr->selectFirst;
+			} else {
+			  /*
+			   * We're at about the halfway point in the 
+			   * selection; just keep the existing anchor.
+			   */
+			}
+		    }
+		    EntrySelectTo(entryPtr, index);
 		    break;
-		case TK_SCROLL_PAGES:
-		    charsPerPage = ((Tk_Width(entryPtr->tkwin)
-			    - 2*entryPtr->inset) / entryPtr->avgWidth) - 2;
-		    if (charsPerPage < 1) {
-			charsPerPage = 1;
+		}
+
+	        case SELECTION_CLEAR: {
+		    if (objc != 3) {
+		        Tcl_WrongNumArgs(interp, 1, objv, "selection clear");
+			goto error;
+		    }
+		    if (entryPtr->selectFirst >= 0) {
+		        entryPtr->selectFirst = -1;
+			entryPtr->selectLast = -1;
+			EventuallyRedraw(entryPtr);
+		    }
+		    goto done;
+		}
+
+	        case SELECTION_FROM: {
+		    if (objc != 4) {
+		        Tcl_WrongNumArgs(interp, 1, objv, 
+			        "selection from index");
+			goto error;
 		    }
-		    index += charsPerPage*count;
+		    if (GetEntryIndex(interp, entryPtr, 
+                            Tcl_GetString(objv[3]), &index) != TCL_OK) {
+		        goto error;
+		    }
+		    entryPtr->selectAnchor = index;
 		    break;
-		case TK_SCROLL_UNITS:
-		    index += count;
+		}
+
+	        case SELECTION_PRESENT: {
+		    if (objc != 3) {
+		        Tcl_WrongNumArgs(interp, 1, objv, "selection present");
+			goto error;
+		    }
+		    if (entryPtr->selectFirst < 0) {
+		        Tcl_SetResult(interp, "0", TCL_STATIC);
+		    } else {
+		        Tcl_SetResult(interp, "1", TCL_STATIC);
+		    }
+		    goto done;
+		}
+
+	        case SELECTION_RANGE: {
+		    if (objc != 5) {
+		        Tcl_WrongNumArgs(interp, 1, objv, 
+                                "selection range start end");
+			goto error;
+		    }
+		    if (GetEntryIndex(interp, entryPtr, 
+                            Tcl_GetString(objv[3]), &index) != TCL_OK) {
+		        goto error;
+		    }
+		    if (GetEntryIndex(interp, entryPtr, 
+                            Tcl_GetString(objv[4]),& index2) != TCL_OK) {
+		        goto error;
+		    }
+		    if (index >= index2) {
+		        entryPtr->selectFirst = -1;
+			entryPtr->selectLast = -1;
+		    } else {
+		        entryPtr->selectFirst = index;
+			entryPtr->selectLast = index2;
+		    }
+		    if (!(entryPtr->flags & GOT_SELECTION)
+			    && (entryPtr->exportSelection)) {
+		        Tk_OwnSelection(entryPtr->tkwin, XA_PRIMARY, 
+			        EntryLostSelection, (ClientData) entryPtr);
+			entryPtr->flags |= GOT_SELECTION;
+		    }
+		    EventuallyRedraw(entryPtr);
+		    break;
+		}
+		
+	        case SELECTION_TO: {
+		    if (objc != 4) {
+		        Tcl_WrongNumArgs(interp, 1, objv, 
+                                "selection to index");
+			goto error;
+		    }
+		    if (GetEntryIndex(interp, entryPtr, 
+                            Tcl_GetString(objv[3]), &index) != TCL_OK) {
+		        goto error;
+		    }
+		    EntrySelectTo(entryPtr, index);
 		    break;
+		}
 	    }
+	    break;
+	}
+
+        case COMMAND_XVIEW: {
+	    int index;
+
+	    if (objc == 2) {
+	        double first, last;
+		char buf[TCL_DOUBLE_SPACE * 2];
+	    
+		EntryVisibleRange(entryPtr, &first, &last);
+		sprintf(buf, "%g %g", first, last);
+		Tcl_SetResult(interp, buf, TCL_VOLATILE);
+		goto done;
+	    } else if (objc == 3) {
+	        if (GetEntryIndex(interp, entryPtr, Tcl_GetString(objv[2]), 
+                        &index) != TCL_OK) {
+		    goto error;
+		}
+	    } else {
+	        double fraction;
+		int count;
+
+		index = entryPtr->leftIndex;
+		switch (Tk_GetScrollInfoObj(interp, objc, objv, &fraction, 
+                        &count)) {
+		    case TK_SCROLL_ERROR: {
+		        goto error;
+		    }
+		    case TK_SCROLL_MOVETO: {
+		        index = (int) ((fraction * entryPtr->numChars) + 0.5);
+			break;
+		    }
+		    case TK_SCROLL_PAGES: {
+		        int charsPerPage;
+		    
+			charsPerPage = ((Tk_Width(entryPtr->tkwin)
+    			        - 2 * entryPtr->inset) 
+                                / entryPtr->avgWidth) - 2;
+			if (charsPerPage < 1) {
+			    charsPerPage = 1;
+			}
+			index += count * charsPerPage;
+			break;
+		    }
+		    case TK_SCROLL_UNITS: {
+		        index += count;
+			break;
+		    }
+		}
+	    }
+	    if (index >= entryPtr->numChars) {
+	        index = entryPtr->numChars - 1;
+	    }
+	    if (index < 0) {
+	        index = 0;
+	    }
+	    entryPtr->leftIndex = index;
+	    entryPtr->flags |= UPDATE_SCROLLBAR;
+	    EntryComputeGeometry(entryPtr);
+	    EventuallyRedraw(entryPtr);
+	    break;
 	}
-	if (index >= entryPtr->numChars) {
-	    index = entryPtr->numChars-1;
-	}
-	if (index < 0) {
-	    index = 0;
-	}
-	entryPtr->leftIndex = index;
-	entryPtr->flags |= UPDATE_SCROLLBAR;
-	EntryComputeGeometry(entryPtr);
-	EventuallyRedraw(entryPtr);
-    } else {
-	Tcl_AppendResult(interp, "bad option \"", argv[1],
-		"\": must be bbox, cget, configure, delete, get, ",
-		"icursor, index, insert, scan, selection, or xview",
-		(char *) NULL);
-	goto error;
     }
+
     done:
     Tcl_Release((ClientData) entryPtr);
     return result;
@@ -818,7 +981,13 @@ static void
 DestroyEntry(memPtr)
     char *memPtr;		/* Info about entry widget. */
 {
-    register Entry *entryPtr = (Entry *) memPtr;
+    Entry *entryPtr = (Entry *) memPtr;
+    entryPtr->flags |= ENTRY_DELETED;
+
+    Tcl_DeleteCommandFromToken(entryPtr->interp, entryPtr->widgetCmd);
+    if (entryPtr->flags & REDRAW_PENDING) {
+        Tcl_CancelIdleCall(DisplayEntry, (ClientData) entryPtr);
+    }
 
     /*
      * Free up all the stuff that requires special handling, then
@@ -839,11 +1008,13 @@ DestroyEntry(memPtr)
 	Tk_FreeGC(entryPtr->display, entryPtr->selTextGC);
     }
     Tcl_DeleteTimerHandler(entryPtr->insertBlinkHandler);
-    if (entryPtr->displayString != NULL) {
+    if (entryPtr->displayString != entryPtr->string) {
 	ckfree(entryPtr->displayString);
     }
     Tk_FreeTextLayout(entryPtr->textLayout);
-    Tk_FreeOptions(configSpecs, (char *) entryPtr, entryPtr->display, 0);
+    Tk_FreeConfigOptions((char *) entryPtr, entryPtr->optionTable,
+	    entryPtr->tkwin);
+    entryPtr->tkwin = NULL;
     ckfree((char *) entryPtr);
 }
 
@@ -858,7 +1029,7 @@ DestroyEntry(memPtr)
  *
  * Results:
  *	The return value is a standard Tcl result.  If TCL_ERROR is
- *	returned, then interp->result contains an error message.
+ *	returned, then the interp's result contains an error message.
  *
  * Side effects:
  *	Configuration information, such as colors, border width,
@@ -869,14 +1040,17 @@ DestroyEntry(memPtr)
  */
 
 static int
-ConfigureEntry(interp, entryPtr, argc, argv, flags)
+ConfigureEntry(interp, entryPtr, objc, objv, flags)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    register Entry *entryPtr;	/* Information about widget;  may or may
-				 * not already have values for some fields. */
-    int argc;			/* Number of valid entries in argv. */
-    char **argv;		/* Arguments. */
+    Entry *entryPtr;		/* Information about widget; may or may not
+				 * already have values for some fields. */
+    int objc;			/* Number of valid entries in argv. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
     int flags;			/* Flags to pass to Tk_ConfigureWidget. */
 {
+    Tk_SavedOptions savedOptions;
+    Tcl_Obj *errorResult = NULL;
+    int error;
     int oldExport;
 
     /*
@@ -890,9 +1064,79 @@ ConfigureEntry(interp, entryPtr, argc, argv, flags)
     }
 
     oldExport = entryPtr->exportSelection;
-    if (Tk_ConfigureWidget(interp, entryPtr->tkwin, configSpecs,
-	    argc, argv, (char *) entryPtr, flags) != TCL_OK) {
-	return TCL_ERROR;
+
+    for (error = 0; error <= 1; error++) {
+	if (!error) {
+	    /*
+	     * First pass: set options to new values.
+	     */
+
+	    if (Tk_SetOptions(interp, (char *) entryPtr,
+		    entryPtr->optionTable, objc, objv,
+		    entryPtr->tkwin, &savedOptions, (int *) NULL) != TCL_OK) {
+		continue;
+	    }
+	} else {
+	    /*
+	     * Second pass: restore options to old values.
+	     */
+
+	    errorResult = Tcl_GetObjResult(interp);
+	    Tcl_IncrRefCount(errorResult);
+	    Tk_RestoreSavedOptions(&savedOptions);
+	}
+
+	/*
+	 * A few other options also need special processing, such as parsing
+	 * the geometry and setting the background from a 3-D border.
+	 */
+
+	Tk_SetBackgroundFromBorder(entryPtr->tkwin, entryPtr->normalBorder);
+
+	if (entryPtr->insertWidth <= 0) {
+	    entryPtr->insertWidth = 2;
+	}
+	if (entryPtr->insertBorderWidth > entryPtr->insertWidth/2) {
+	    entryPtr->insertBorderWidth = entryPtr->insertWidth/2;
+	}
+
+	/*
+	 * Restart the cursor timing sequence in case the on-time or 
+	 * off-time just changed.
+	 */
+
+	if (entryPtr->flags & GOT_FOCUS) {
+	  EntryFocusProc(entryPtr, 1);
+	}
+
+	/*
+	 * Claim the selection if we've suddenly started exporting it.
+	 */
+
+	if (entryPtr->exportSelection && (!oldExport)
+	        && (entryPtr->selectFirst != -1)
+	        && !(entryPtr->flags & GOT_SELECTION)) {
+	    Tk_OwnSelection(entryPtr->tkwin, XA_PRIMARY, EntryLostSelection,
+		    (ClientData) entryPtr);
+	    entryPtr->flags |= GOT_SELECTION;
+	}
+
+	/*
+	 * Recompute the window's geometry and arrange for it to be
+	 * redisplayed.
+	 */
+
+	Tk_SetInternalBorder(entryPtr->tkwin,
+	        entryPtr->borderWidth + entryPtr->highlightWidth);
+	if (entryPtr->highlightWidth <= 0) {
+	    entryPtr->highlightWidth = 0;
+	}
+	entryPtr->inset = entryPtr->highlightWidth 
+	        + entryPtr->borderWidth + XPAD;
+	break;
+    }
+    if (!error) {
+	Tk_FreeSavedOptions(&savedOptions);
     }
 
     /*
@@ -915,63 +1159,14 @@ ConfigureEntry(interp, entryPtr, argc, argv, flags)
 		EntryTextVarProc, (ClientData) entryPtr);
     }
 
-    /*
-     * A few other options also need special processing, such as parsing
-     * the geometry and setting the background from a 3-D border.
-     */
-
-    if ((entryPtr->state != tkNormalUid)
-	    && (entryPtr->state != tkDisabledUid)) {
-	Tcl_AppendResult(interp, "bad state value \"", entryPtr->state,
-		"\": must be normal or disabled", (char *) NULL);
-	entryPtr->state = tkNormalUid;
+    EntryWorldChanged((ClientData) entryPtr);
+    if (error) {
+        Tcl_SetObjResult(interp, errorResult);
+	Tcl_DecrRefCount(errorResult);
 	return TCL_ERROR;
+    } else {
+        return TCL_OK;
     }
-
-    Tk_SetBackgroundFromBorder(entryPtr->tkwin, entryPtr->normalBorder);
-
-    if (entryPtr->insertWidth <= 0) {
-	entryPtr->insertWidth = 2;
-    }
-    if (entryPtr->insertBorderWidth > entryPtr->insertWidth/2) {
-	entryPtr->insertBorderWidth = entryPtr->insertWidth/2;
-    }
-
-    /*
-     * Restart the cursor timing sequence in case the on-time or off-time
-     * just changed.
-     */
-
-    if (entryPtr->flags & GOT_FOCUS) {
-	EntryFocusProc(entryPtr, 1);
-    }
-
-    /*
-     * Claim the selection if we've suddenly started exporting it.
-     */
-
-    if (entryPtr->exportSelection && (!oldExport)
-	    && (entryPtr->selectFirst != -1)
-	    && !(entryPtr->flags & GOT_SELECTION)) {
-	Tk_OwnSelection(entryPtr->tkwin, XA_PRIMARY, EntryLostSelection,
-		(ClientData) entryPtr);
-	entryPtr->flags |= GOT_SELECTION;
-    }
-
-    /*
-     * Recompute the window's geometry and arrange for it to be
-     * redisplayed.
-     */
-
-    Tk_SetInternalBorder(entryPtr->tkwin,
-	    entryPtr->borderWidth + entryPtr->highlightWidth);
-    if (entryPtr->highlightWidth <= 0) {
-	entryPtr->highlightWidth = 0;
-    }
-    entryPtr->inset = entryPtr->highlightWidth + entryPtr->borderWidth + XPAD;
-
-    EntryWorldChanged((ClientData) entryPtr);
-    return TCL_OK;
 }
 
 /*
@@ -1057,13 +1252,14 @@ static void
 DisplayEntry(clientData)
     ClientData clientData;	/* Information about window. */
 {
-    register Entry *entryPtr = (Entry *) clientData;
-    register Tk_Window tkwin = entryPtr->tkwin;
-    int baseY, selStartX, selEndX, cursorX, x, w;
+    Entry *entryPtr = (Entry *) clientData;
+    Tk_Window tkwin = entryPtr->tkwin;
+    int baseY, selStartX, selEndX, cursorX;
     int xBound;
     Tk_FontMetrics fm;
     Pixmap pixmap;
     int showSelection;
+    char *string;
 
     entryPtr->flags &= ~REDRAW_PENDING;
     if ((entryPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
@@ -1118,18 +1314,21 @@ DisplayEntry(clientData)
 
     Tk_Fill3DRectangle(tkwin, pixmap, entryPtr->normalBorder,
 	    0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
-    if (showSelection && (entryPtr->selectLast > entryPtr->leftIndex)) {
+
+    string = entryPtr->displayString;
+    if (showSelection
+	    && (entryPtr->selectLast > entryPtr->leftIndex)) {
 	if (entryPtr->selectFirst <= entryPtr->leftIndex) {
 	    selStartX = entryPtr->leftX;
 	} else {
 	    Tk_CharBbox(entryPtr->textLayout, entryPtr->selectFirst,
-		    &x, NULL, NULL, NULL);
-	    selStartX = x + entryPtr->layoutX;
+		    &selStartX, NULL, NULL, NULL);
+	    selStartX += entryPtr->layoutX;
 	}
 	if ((selStartX - entryPtr->selBorderWidth) < xBound) {
-	    Tk_CharBbox(entryPtr->textLayout, entryPtr->selectLast - 1,
-		    &x, NULL, &w, NULL);
-	    selEndX = x + w + entryPtr->layoutX;
+	    Tk_CharBbox(entryPtr->textLayout, entryPtr->selectLast,
+		    &selEndX, NULL, NULL, NULL);
+	    selEndX += entryPtr->layoutX;
 	    Tk_Fill3DRectangle(tkwin, pixmap, entryPtr->selBorder,
 		    selStartX - entryPtr->selBorderWidth,
 		    baseY - fm.ascent - entryPtr->selBorderWidth,
@@ -1149,32 +1348,22 @@ DisplayEntry(clientData)
      */
 
     if ((entryPtr->insertPos >= entryPtr->leftIndex)
-	    && (entryPtr->state == tkNormalUid)
+	    && (entryPtr->state == STATE_NORMAL)
 	    && (entryPtr->flags & GOT_FOCUS)) {
-	if (entryPtr->insertPos == 0) {
-	    cursorX = 0;
-	} else if (entryPtr->insertPos >= entryPtr->numChars) {
-	    Tk_CharBbox(entryPtr->textLayout, entryPtr->numChars - 1,
-		    &x, NULL, &w, NULL);
-	    cursorX = x + w;
-	} else {
-	    Tk_CharBbox(entryPtr->textLayout, entryPtr->insertPos,
-		    &x, NULL, NULL, NULL);
-	    cursorX = x;
-	}
+	Tk_CharBbox(entryPtr->textLayout, entryPtr->insertPos, &cursorX, NULL,
+		NULL, NULL);
 	cursorX += entryPtr->layoutX;
 	cursorX -= (entryPtr->insertWidth)/2;
 	if (cursorX < xBound) {
 	    if (entryPtr->flags & CURSOR_ON) {
 		Tk_Fill3DRectangle(tkwin, pixmap, entryPtr->insertBorder,
-			cursorX, baseY - fm.ascent,
-			entryPtr->insertWidth, fm.ascent + fm.descent, 
-			entryPtr->insertBorderWidth, TK_RELIEF_RAISED);
+			cursorX, baseY - fm.ascent, entryPtr->insertWidth,
+			fm.ascent + fm.descent, entryPtr->insertBorderWidth,
+			TK_RELIEF_RAISED);
 	    } else if (entryPtr->insertBorder == entryPtr->selBorder) {
 		Tk_Fill3DRectangle(tkwin, pixmap, entryPtr->normalBorder,
-			cursorX, baseY - fm.ascent,
-			entryPtr->insertWidth, fm.ascent + fm.descent,
-			0, TK_RELIEF_FLAT);
+			cursorX, baseY - fm.ascent, entryPtr->insertWidth,
+			fm.ascent + fm.descent, 0, TK_RELIEF_FLAT);
 	    }
 	}
     }
@@ -1188,18 +1377,19 @@ DisplayEntry(clientData)
 	    entryPtr->textLayout, entryPtr->layoutX, entryPtr->layoutY,
 	    entryPtr->leftIndex, entryPtr->numChars);
 
-    if (showSelection && (entryPtr->selTextGC != entryPtr->textGC) &&
-	    (entryPtr->selectFirst < entryPtr->selectLast)) {
-	int first;
+    if (showSelection
+	    && (entryPtr->selTextGC != entryPtr->textGC)
+	    && (entryPtr->selectFirst < entryPtr->selectLast)) {
+	int selFirst;
 
-	if (entryPtr->selectFirst - entryPtr->leftIndex < 0) {
-	    first = entryPtr->leftIndex;
+	if (entryPtr->selectFirst < entryPtr->leftIndex) {
+	    selFirst = entryPtr->leftIndex;
 	} else {
-	    first = entryPtr->selectFirst;
+	    selFirst = entryPtr->selectFirst;
 	}
 	Tk_DrawTextLayout(entryPtr->display, pixmap, entryPtr->selTextGC,
 		entryPtr->textLayout, entryPtr->layoutX, entryPtr->layoutY,
-		first, entryPtr->selectLast);
+		selFirst, entryPtr->selectLast);
     }
 
     /*
@@ -1210,8 +1400,8 @@ DisplayEntry(clientData)
     if (entryPtr->relief != TK_RELIEF_FLAT) {
 	Tk_Draw3DRectangle(tkwin, pixmap, entryPtr->normalBorder,
 		entryPtr->highlightWidth, entryPtr->highlightWidth,
-		Tk_Width(tkwin) - 2*entryPtr->highlightWidth,
-		Tk_Height(tkwin) - 2*entryPtr->highlightWidth,
+		Tk_Width(tkwin) - 2 * entryPtr->highlightWidth,
+		Tk_Height(tkwin) - 2 * entryPtr->highlightWidth,
 		entryPtr->borderWidth, entryPtr->relief);
     }
     if (entryPtr->highlightWidth != 0) {
@@ -1259,38 +1449,53 @@ DisplayEntry(clientData)
 
 static void
 EntryComputeGeometry(entryPtr)
-    Entry *entryPtr;			/* Widget record for entry. */
+    Entry *entryPtr;		/* Widget record for entry. */
 {
     int totalLength, overflow, maxOffScreen, rightX;
     int height, width, i;
     Tk_FontMetrics fm;
-    char *p, *displayString;
+    char *p;
+
+    if (entryPtr->displayString != entryPtr->string) {
+	ckfree(entryPtr->displayString);
+	entryPtr->displayString = entryPtr->string;
+	entryPtr->numDisplayBytes = entryPtr->numBytes;
+    }
 
     /*
      * If we're displaying a special character instead of the value of
      * the entry, recompute the displayString.
      */
 
-    if (entryPtr->displayString != NULL) {
-	ckfree(entryPtr->displayString);
-	entryPtr->displayString = NULL;
-    }
     if (entryPtr->showChar != NULL) {
-	entryPtr->displayString = (char *) ckalloc((unsigned)
-		(entryPtr->numChars + 1));
-	for (p = entryPtr->displayString, i = entryPtr->numChars; i > 0;
-		i--, p++) {
-	    *p = entryPtr->showChar[0];
+	Tcl_UniChar ch;
+	char buf[TCL_UTF_MAX];
+	int size;
+
+	/*
+	 * Normalize the special character so we can safely duplicate it
+	 * in the display string.  If we didn't do this, then two malformed
+	 * characters might end up looking like one valid UTF character in
+	 * the resulting string.
+	 */
+
+	Tcl_UtfToUniChar(entryPtr->showChar, &ch);
+	size = Tcl_UniCharToUtf(ch, buf);
+
+	entryPtr->numDisplayBytes = entryPtr->numChars * size;
+	entryPtr->displayString =
+		(char *) ckalloc((unsigned) (entryPtr->numDisplayBytes + 1));
+
+	p = entryPtr->displayString;
+	for (i = entryPtr->numChars; --i >= 0; ) {
+	    p += Tcl_UniCharToUtf(ch, p);
 	}
-	*p = 0;
-	displayString = entryPtr->displayString;
-    } else {
-	displayString = entryPtr->string;
+	*p = '\0';
     }
     Tk_FreeTextLayout(entryPtr->textLayout);
     entryPtr->textLayout = Tk_ComputeTextLayout(entryPtr->tkfont,
-	    displayString, entryPtr->numChars, 0, entryPtr->justify,
-	    TK_IGNORE_NEWLINES, &totalLength, &height);
+	    entryPtr->displayString, entryPtr->numChars, 0,
+	    entryPtr->justify, TK_IGNORE_NEWLINES, &totalLength, &height);
 
     entryPtr->layoutY = (Tk_Height(entryPtr->tkwin) - height) / 2;
 
@@ -1325,13 +1530,13 @@ EntryComputeGeometry(entryPtr)
 	Tk_CharBbox(entryPtr->textLayout, maxOffScreen,
 		&rightX, NULL, NULL, NULL);
 	if (rightX < overflow) {
-	    maxOffScreen += 1;
+	    maxOffScreen++;
 	}
 	if (entryPtr->leftIndex > maxOffScreen) {
 	    entryPtr->leftIndex = maxOffScreen;
 	}
-	Tk_CharBbox(entryPtr->textLayout, entryPtr->leftIndex,
-		&rightX, NULL, NULL, NULL);
+	Tk_CharBbox(entryPtr->textLayout, entryPtr->leftIndex, &rightX,
+		NULL, NULL, NULL);
 	entryPtr->leftX = entryPtr->inset;
 	entryPtr->layoutX = entryPtr->leftX - rightX;
     }
@@ -1368,28 +1573,51 @@ EntryComputeGeometry(entryPtr)
  */
 
 static void
-InsertChars(entryPtr, index, string)
-    register Entry *entryPtr;	/* Entry that is to get the new
-				 * elements. */
+InsertChars(entryPtr, index, value)
+    Entry *entryPtr;		/* Entry that is to get the new elements. */
     int index;			/* Add the new elements before this
-				 * element. */
-    char *string;		/* New characters to add (NULL-terminated
+				 * character index. */
+    char *value;		/* New characters to add (NULL-terminated
 				 * string). */
 {
-    int length;
-    char *new;
+    int byteIndex, byteCount, oldChars, charsAdded, newByteCount;
+    char *new, *string;
 
-    length = strlen(string);
-    if (length == 0) {
+    string = entryPtr->string;
+    byteIndex = Tcl_UtfAtIndex(string, index) - string;
+    byteCount = strlen(value);
+    if (byteCount == 0) {
 	return;
     }
-    new = (char *) ckalloc((unsigned) (entryPtr->numChars + length + 1));
-    strncpy(new, entryPtr->string, (size_t) index);
-    strcpy(new+index, string);
-    strcpy(new+index+length, entryPtr->string+index);
-    ckfree(entryPtr->string);
+
+    newByteCount = entryPtr->numBytes + byteCount + 1;
+    new = (char *) ckalloc((unsigned) newByteCount);
+    memcpy(new, string, (size_t) byteIndex);
+    strcpy(new + byteIndex, value);
+    strcpy(new + byteIndex + byteCount, string + byteIndex);
+
+    ckfree(string);
     entryPtr->string = new;
-    entryPtr->numChars += length;
+
+    /*
+     * The following construction is used because inserting improperly
+     * formed UTF-8 sequences between other improperly formed UTF-8
+     * sequences could result in actually forming valid UTF-8 sequences;
+     * the number of characters added may not be Tcl_NumUtfChars(string, -1),
+     * because of context.  The actual number of characters added is how
+     * many characters are in the string now minus the number that
+     * used to be there.
+     */
+
+    oldChars = entryPtr->numChars;
+    entryPtr->numChars = Tcl_NumUtfChars(new, -1);
+    charsAdded = entryPtr->numChars - oldChars;
+    entryPtr->numBytes += byteCount;
+
+    if (entryPtr->displayString == string) {
+	entryPtr->displayString = new;
+	entryPtr->numDisplayBytes = entryPtr->numBytes;
+    }
 
     /*
      * Inserting characters invalidates all indexes into the string.
@@ -1400,19 +1628,20 @@ InsertChars(entryPtr, index, string)
      */
 
     if (entryPtr->selectFirst >= index) {
-	entryPtr->selectFirst += length;
+	entryPtr->selectFirst += charsAdded;
     }
     if (entryPtr->selectLast > index) {
-	entryPtr->selectLast += length;
+	entryPtr->selectLast += charsAdded;
     }
-    if ((entryPtr->selectAnchor > index) || (entryPtr->selectFirst >= index)) {
-	entryPtr->selectAnchor += length;
+    if ((entryPtr->selectAnchor > index)
+	    || (entryPtr->selectFirst >= index)) {
+	entryPtr->selectAnchor += charsAdded;
     }
     if (entryPtr->leftIndex > index) {
-	entryPtr->leftIndex += length;
+	entryPtr->leftIndex += charsAdded;
     }
     if (entryPtr->insertPos >= index) {
-	entryPtr->insertPos += length;
+	entryPtr->insertPos += charsAdded;
     }
     EntryValueChanged(entryPtr);
 }
@@ -1436,11 +1665,12 @@ InsertChars(entryPtr, index, string)
 
 static void
 DeleteChars(entryPtr, index, count)
-    register Entry *entryPtr;	/* Entry widget to modify. */
+    Entry *entryPtr;		/* Entry widget to modify. */
     int index;			/* Index of first character to delete. */
     int count;			/* How many characters to delete. */
 {
-    char *new;
+    int byteIndex, byteCount, newByteCount;
+    char *new, *string;
 
     if ((index + count) > entryPtr->numChars) {
 	count = entryPtr->numChars - index;
@@ -1449,12 +1679,24 @@ DeleteChars(entryPtr, index, count)
 	return;
     }
 
-    new = (char *) ckalloc((unsigned) (entryPtr->numChars + 1 - count));
-    strncpy(new, entryPtr->string, (size_t) index);
-    strcpy(new+index, entryPtr->string+index+count);
+    string = entryPtr->string;
+    byteIndex = Tcl_UtfAtIndex(string, index) - string;
+    byteCount = Tcl_UtfAtIndex(string + byteIndex, count) - (string + byteIndex);
+
+    newByteCount = entryPtr->numBytes + 1 - byteCount;
+    new = (char *) ckalloc((unsigned) newByteCount);
+    memcpy(new, string, (size_t) byteIndex);
+    strcpy(new + byteIndex, string + byteIndex + byteCount);
+
     ckfree(entryPtr->string);
     entryPtr->string = new;
     entryPtr->numChars -= count;
+    entryPtr->numBytes -= byteCount;
+
+    if (entryPtr->displayString == string) {
+	entryPtr->displayString = new;
+	entryPtr->numDisplayBytes = entryPtr->numBytes;
+    }
 
     /*
      * Deleting characters results in the remaining characters being
@@ -1463,21 +1705,22 @@ DeleteChars(entryPtr, index, count)
      */
 
     if (entryPtr->selectFirst >= index) {
-	if (entryPtr->selectFirst >= (index+count)) {
+	if (entryPtr->selectFirst >= (index + count)) {
 	    entryPtr->selectFirst -= count;
 	} else {
 	    entryPtr->selectFirst = index;
 	}
     }
     if (entryPtr->selectLast >= index) {
-	if (entryPtr->selectLast >= (index+count)) {
+	if (entryPtr->selectLast >= (index + count)) {
 	    entryPtr->selectLast -= count;
 	} else {
 	    entryPtr->selectLast = index;
 	}
     }
     if (entryPtr->selectLast <= entryPtr->selectFirst) {
-	entryPtr->selectFirst = entryPtr->selectLast = -1;
+	entryPtr->selectFirst = -1;
+	entryPtr->selectLast = -1;
     }
     if (entryPtr->selectAnchor >= index) {
 	if (entryPtr->selectAnchor >= (index+count)) {
@@ -1487,14 +1730,14 @@ DeleteChars(entryPtr, index, count)
 	}
     }
     if (entryPtr->leftIndex > index) {
-	if (entryPtr->leftIndex >= (index+count)) {
+	if (entryPtr->leftIndex >= (index + count)) {
 	    entryPtr->leftIndex -= count;
 	} else {
 	    entryPtr->leftIndex = index;
 	}
     }
     if (entryPtr->insertPos >= index) {
-	if (entryPtr->insertPos >= (index+count)) {
+	if (entryPtr->insertPos >= (index + count)) {
 	    entryPtr->insertPos -= count;
 	} else {
 	    entryPtr->insertPos = index;
@@ -1580,24 +1823,37 @@ EntryValueChanged(entryPtr)
 
 static void
 EntrySetValue(entryPtr, value)
-    register Entry *entryPtr;		/* Entry whose value is to be
-					 * changed. */
-    char *value;			/* New text to display in entry. */
+    Entry *entryPtr;		/* Entry whose value is to be changed. */
+    char *value;		/* New text to display in entry. */
 {
+    char *oldSource;
+
+    oldSource = entryPtr->string;
+
     ckfree(entryPtr->string);
-    entryPtr->numChars = strlen(value);
-    entryPtr->string = (char *) ckalloc((unsigned) (entryPtr->numChars + 1));
+    entryPtr->numBytes = strlen(value);
+    entryPtr->numChars = Tcl_NumUtfChars(value, entryPtr->numBytes);
+    entryPtr->string =
+	    (char *) ckalloc((unsigned) (entryPtr->numBytes + 1));
     strcpy(entryPtr->string, value);
-    if (entryPtr->selectFirst != -1) {
+
+    if (entryPtr->displayString == oldSource) {
+	entryPtr->displayString = entryPtr->string;
+	entryPtr->numDisplayBytes = entryPtr->numBytes;
+    }
+
+    if (entryPtr->selectFirst >= 0) {
 	if (entryPtr->selectFirst >= entryPtr->numChars) {
-	    entryPtr->selectFirst = entryPtr->selectLast = -1;
+	    entryPtr->selectFirst = -1;
+	    entryPtr->selectLast = -1;
 	} else if (entryPtr->selectLast > entryPtr->numChars) {
 	    entryPtr->selectLast = entryPtr->numChars;
 	}
     }
     if (entryPtr->leftIndex >= entryPtr->numChars) {
-	entryPtr->leftIndex = entryPtr->numChars-1;
-	if (entryPtr->leftIndex < 0) {
+	if (entryPtr->numChars > 0) {
+	    entryPtr->leftIndex = entryPtr->numChars - 1;
+	} else {
 	    entryPtr->leftIndex = 0;
 	}
     }
@@ -1638,14 +1894,7 @@ EntryEventProc(clientData, eventPtr)
 	EventuallyRedraw(entryPtr);
 	entryPtr->flags |= BORDER_NEEDED;
     } else if (eventPtr->type == DestroyNotify) {
-	if (entryPtr->tkwin != NULL) {
-	    entryPtr->tkwin = NULL;
-            Tcl_DeleteCommandFromToken(entryPtr->interp, entryPtr->widgetCmd);
-	}
-	if (entryPtr->flags & REDRAW_PENDING) {
-	    Tcl_CancelIdleCall(DisplayEntry, (ClientData) entryPtr);
-	}
-	Tcl_EventuallyFree((ClientData) entryPtr, DestroyEntry);
+        DestroyEntry((char *) clientData);
     } else if (eventPtr->type == ConfigureNotify) {
 	Tcl_Preserve((ClientData) entryPtr);
 	entryPtr->flags |= UPDATE_SCROLLBAR;
@@ -1686,7 +1935,6 @@ EntryCmdDeletedProc(clientData)
     ClientData clientData;	/* Pointer to widget record for widget. */
 {
     Entry *entryPtr = (Entry *) clientData;
-    Tk_Window tkwin = entryPtr->tkwin;
 
     /*
      * This procedure could be invoked either because the window was
@@ -1695,14 +1943,13 @@ EntryCmdDeletedProc(clientData)
      * destroys the widget.
      */
 
-    if (tkwin != NULL) {
-	entryPtr->tkwin = NULL;
-	Tk_DestroyWindow(tkwin);
+    if (! entryPtr->flags & ENTRY_DELETED) {
+        Tk_DestroyWindow(entryPtr->tkwin);
     }
 }
 
 /*
- *--------------------------------------------------------------
+ *---------------------------------------------------------------------------
  *
  * GetEntryIndex --
  *
@@ -1711,15 +1958,15 @@ EntryCmdDeletedProc(clientData)
  *
  * Results:
  *	A standard Tcl result.  If all went well, then *indexPtr is
- *	filled in with the index (into entryPtr) corresponding to
+ *	filled in with the character index (into entryPtr) corresponding to
  *	string.  The index value is guaranteed to lie between 0 and
  *	the number of characters in the string, inclusive.  If an
- *	error occurs then an error message is left in interp->result.
+ *	error occurs then an error message is left in the interp's result.
  *
  * Side effects:
  *	None.
  *
- *--------------------------------------------------------------
+ *---------------------------------------------------------------------------
  */
 
 static int
@@ -1728,7 +1975,8 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
     Entry *entryPtr;		/* Entry for which the index is being
 				 * specified. */
     char *string;		/* Specifies character in entryPtr. */
-    int *indexPtr;		/* Where to store converted index. */
+    int *indexPtr;		/* Where to store converted character
+				 * index. */
 {
     size_t length;
 
@@ -1741,7 +1989,7 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
 	    badIndex:
 
 	    /*
-	     * Some of the paths here leave messages in interp->result,
+	     * Some of the paths here leave messages in the interp's result,
 	     * so we have to clear it out before storing our own message.
 	     */
 
@@ -1763,8 +2011,8 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
 	    goto badIndex;
 	}
     } else if (string[0] == 's') {
-	if (entryPtr->selectFirst == -1) {
-	    interp->result = "selection isn't in entry";
+	if (entryPtr->selectFirst < 0) {
+	    Tcl_SetResult(interp, "selection isn't in entry", TCL_STATIC);
 	    return TCL_ERROR;
 	}
 	if (length < 5) {
@@ -1780,7 +2028,7 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
     } else if (string[0] == '@') {
 	int x, roundUp;
 
-	if (Tcl_GetInt(interp, string+1, &x) != TCL_OK) {
+	if (Tcl_GetInt(interp, string + 1, &x) != TCL_OK) {
 	    goto badIndex;
 	}
 	if (x < entryPtr->inset) {
@@ -1812,7 +2060,7 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
 	    *indexPtr = 0;
 	} else if (*indexPtr > entryPtr->numChars) {
 	    *indexPtr = entryPtr->numChars;
-	}
+	} 
     }
     return TCL_OK;
 }
@@ -1836,9 +2084,8 @@ GetEntryIndex(interp, entryPtr, string, indexPtr)
 
 static void
 EntryScanTo(entryPtr, x)
-    register Entry *entryPtr;		/* Information about widget. */
-    int x;				/* X-coordinate to use for scan
-					 * operation. */
+    Entry *entryPtr;		/* Information about widget. */
+    int x;			/* X-coordinate to use for scan operation. */
 {
     int newLeftIndex;
 
@@ -1854,19 +2101,24 @@ EntryScanTo(entryPtr, x)
      */
 
     newLeftIndex = entryPtr->scanMarkIndex
-	    - (10*(x - entryPtr->scanMarkX))/entryPtr->avgWidth;
+	    - (10 * (x - entryPtr->scanMarkX)) / entryPtr->avgWidth;
     if (newLeftIndex >= entryPtr->numChars) {
-	newLeftIndex = entryPtr->scanMarkIndex = entryPtr->numChars-1;
+	newLeftIndex = entryPtr->scanMarkIndex = entryPtr->numChars - 1;
 	entryPtr->scanMarkX = x;
     }
     if (newLeftIndex < 0) {
 	newLeftIndex = entryPtr->scanMarkIndex = 0;
 	entryPtr->scanMarkX = x;
     } 
+
     if (newLeftIndex != entryPtr->leftIndex) {
 	entryPtr->leftIndex = newLeftIndex;
 	entryPtr->flags |= UPDATE_SCROLLBAR;
 	EntryComputeGeometry(entryPtr);
+	if (newLeftIndex != entryPtr->leftIndex) {
+	    entryPtr->scanMarkIndex = entryPtr->leftIndex;
+	    entryPtr->scanMarkX = x;
+	}
 	EventuallyRedraw(entryPtr);
     }
 }
@@ -1890,10 +2142,9 @@ EntryScanTo(entryPtr, x)
 
 static void
 EntrySelectTo(entryPtr, index)
-    register Entry *entryPtr;		/* Information about widget. */
-    int index;				/* Index of element that is to
-					 * become the "other" end of the
-					 * selection. */
+    Entry *entryPtr;		/* Information about widget. */
+    int index;			/* Character index of element that is to
+				 * become the "other" end of the selection. */
 {
     int newFirst, newLast;
 
@@ -1956,38 +2207,35 @@ EntrySelectTo(entryPtr, index)
 
 static int
 EntryFetchSelection(clientData, offset, buffer, maxBytes)
-    ClientData clientData;		/* Information about entry widget. */
-    int offset;				/* Offset within selection of first
-					 * character to be returned. */
-    char *buffer;			/* Location in which to place
-					 * selection. */
-    int maxBytes;			/* Maximum number of bytes to place
-					 * at buffer, not including terminating
-					 * NULL character. */
+    ClientData clientData;	/* Information about entry widget. */
+    int offset;			/* Byte offset within selection of first
+				 * character to be returned. */
+    char *buffer;		/* Location in which to place selection. */
+    int maxBytes;		/* Maximum number of bytes to place at
+				 * buffer, not including terminating NULL
+				 * character. */
 {
     Entry *entryPtr = (Entry *) clientData;
-    int count;
-    char *displayString;
+    int byteCount;
+    char *string, *selStart, *selEnd;
 
     if ((entryPtr->selectFirst < 0) || !(entryPtr->exportSelection)) {
 	return -1;
     }
-    count = entryPtr->selectLast - entryPtr->selectFirst - offset;
-    if (count > maxBytes) {
-	count = maxBytes;
+    string = entryPtr->displayString;
+    selStart = Tcl_UtfAtIndex(string, entryPtr->selectFirst);
+    selEnd = Tcl_UtfAtIndex(selStart,
+	    entryPtr->selectLast - entryPtr->selectFirst);
+    byteCount = selEnd - selStart - offset;
+    if (byteCount > maxBytes) {
+	byteCount = maxBytes;
     }
-    if (count <= 0) {
+    if (byteCount <= 0) {
 	return 0;
     }
-    if (entryPtr->displayString == NULL) {
-	displayString = entryPtr->string;
-    } else {
-	displayString = entryPtr->displayString;
-    }
-    strncpy(buffer, displayString + entryPtr->selectFirst + offset,
-	    (size_t) count);
-    buffer[count] = '\0';
-    return count;
+    memcpy(buffer, selStart + offset, (size_t) byteCount);
+    buffer[byteCount] = '\0';
+    return byteCount;
 }
 
 /*
@@ -2010,7 +2258,7 @@ EntryFetchSelection(clientData, offset, buffer, maxBytes)
 
 static void
 EntryLostSelection(clientData)
-    ClientData clientData;		/* Information about entry widget. */
+    ClientData clientData;	/* Information about entry widget. */
 {
     Entry *entryPtr = (Entry *) clientData;
 
@@ -2023,7 +2271,7 @@ EntryLostSelection(clientData)
      */
 
 #ifdef ALWAYS_SHOW_SELECTION
-    if ((entryPtr->selectFirst != -1) && entryPtr->exportSelection) {
+    if ((entryPtr->selectFirst >= 0) && entryPtr->exportSelection) {
 	entryPtr->selectFirst = -1;
 	entryPtr->selectLast = -1;
 	EventuallyRedraw(entryPtr);
@@ -2052,7 +2300,7 @@ EntryLostSelection(clientData)
 
 static void
 EventuallyRedraw(entryPtr)
-    register Entry *entryPtr;		/* Information about widget. */
+    Entry *entryPtr;		/* Information about widget. */
 {
     if ((entryPtr->tkwin == NULL) || !Tk_IsMapped(entryPtr->tkwin)) {
 	return;
@@ -2091,11 +2339,11 @@ EventuallyRedraw(entryPtr)
 
 static void
 EntryVisibleRange(entryPtr, firstPtr, lastPtr)
-    Entry *entryPtr;			/* Information about widget. */
-    double *firstPtr;			/* Return position of first visible
-					 * character in widget. */
-    double *lastPtr;			/* Return position of char just after
-					 * last visible one. */
+    Entry *entryPtr;		/* Information about widget. */
+    double *firstPtr;		/* Return position of first visible
+				 * character in widget. */
+    double *lastPtr;		/* Return position of char just after last
+				 * visible one. */
 {
     int charsInWindow;
 
@@ -2105,22 +2353,18 @@ EntryVisibleRange(entryPtr, firstPtr, lastPtr)
     } else {
 	charsInWindow = Tk_PointToChar(entryPtr->textLayout,
 		Tk_Width(entryPtr->tkwin) - entryPtr->inset
-			- entryPtr->layoutX - 1, 0) + 1;
-	if (charsInWindow > entryPtr->numChars) {
-	    /*
-	     * If all chars were visible, then charsInWindow will be
-	     * the index just after the last char that was visible.
-	     */
-	     
-	    charsInWindow = entryPtr->numChars;
+			- entryPtr->layoutX - 1, 0);
+	if (charsInWindow < entryPtr->numChars) {
+	    charsInWindow++;
 	}
 	charsInWindow -= entryPtr->leftIndex;
 	if (charsInWindow == 0) {
 	    charsInWindow = 1;
 	}
-	*firstPtr = ((double) entryPtr->leftIndex)/entryPtr->numChars;
-	*lastPtr = ((double) (entryPtr->leftIndex + charsInWindow))
-		/entryPtr->numChars;
+
+	*firstPtr = (double) entryPtr->leftIndex / entryPtr->numChars;
+	*lastPtr = (double) (entryPtr->leftIndex + charsInWindow)
+		/ entryPtr->numChars;
     }
 }
 
@@ -2148,7 +2392,7 @@ static void
 EntryUpdateScrollbar(entryPtr)
     Entry *entryPtr;			/* Information about widget. */
 {
-    char args[100];
+    char args[TCL_DOUBLE_SPACE * 2];
     int code;
     double first, last;
     Tcl_Interp *interp;
@@ -2193,7 +2437,7 @@ static void
 EntryBlinkProc(clientData)
     ClientData clientData;	/* Pointer to record describing entry. */
 {
-    register Entry *entryPtr = (Entry *) clientData;
+    Entry *entryPtr = (Entry *) clientData;
 
     if (!(entryPtr->flags & GOT_FOCUS) || (entryPtr->insertOffTime == 0)) {
 	return;
@@ -2230,7 +2474,7 @@ EntryBlinkProc(clientData)
 
 static void
 EntryFocusProc(entryPtr, gotFocus)
-    register Entry *entryPtr;	/* Entry that got or lost focus. */
+    Entry *entryPtr;		/* Entry that got or lost focus. */
     int gotFocus;		/* 1 means window is getting focus, 0 means
 				 * it's losing it. */
 {
@@ -2276,7 +2520,7 @@ EntryTextVarProc(clientData, interp, name1, name2, flags)
     char *name2;		/* Not used. */
     int flags;			/* Information about what happened. */
 {
-    register Entry *entryPtr = (Entry *) clientData;
+    Entry *entryPtr = (Entry *) clientData;
     char *value;
 
     /*