* generic/tkStubInit.c:

	* generic/tkDecls.h:
	* generic/tkIntXlibDecls.h:
	* generic/tkInt.decls: added XSetDashes and XWarpPointer
	* generic/tk.decls: added Tk_CreateSmoothMethod, and reserved
	two spots
	* generic/tk.h: added Tk_SmoothMethod struct,
	state item to canvas record, #defines for item state,
	support for using old char*-based canvas item C creation
	procedures with -DUSE_OLD_CANVAS,
	Tk_Dash, Tk_TSOffset (-offsets) & Tk_Outline structs and #defs,
	decls for dash, outline and postscript routines
	* generic/tkBind.c: added support for Quadruple clicks, and added
	the -warp option to 'event' with pointer warping routines
	* xlib/xgc.c:
	* generic/tkRectOval.c:
	* generic/tkCanvArc.c:
	* generic/tkCanvBmap.c:
	* generic/tkCanvImg.c:
	* generic/tkCanvLine.c:
	* generic/tkCanvPoly.c:
	* generic/tkCanvPs.c:
	* generic/tkCanvText.c:
	* generic/tkCanvUtil.c:
	* generic/tkCanvWind.c:
	* generic/tkCanvas.c:
	* generic/tkCanvas.h: Canvas and items received overhaul to with
	the addition of the dash patch (Nijtmans, et al)  This includes
	objectification of the 'canvas' command, as well as support for
	(where appropriate) dashes in items, extended stipple support,
	state for all items, and postscript generation of images and
	windows.  See the new canvas man page for related docs.
	* generic/tkEntry.c: added entry widget validation, see entry.n
	* generic/tkEvent.c: on simulated events, ButtonPress should
	be matched with ButtonRelease to be correct
	* generic/tkFont.c: corrected possible null reference
	* generic/tkFrame.c: made frame a Tcl_Obj based command
	* generic/tkGet.c: added TkGetDoublePixels
	* generic/tkImage.c: bug fixes from Img patch and new
	Tk_PostscriptImage and Tk_SetTSOrigin functions
	* generic/tkImgBmap.c: new ImgBmapPostscript function
	* generic/tkImgPhoto.c: new Tk_CreatePhotoOption, Tk_DitherPhoto
	* generic/tkInt.h: declarations for some new functions
	* generic/tkMessage.c: reworked relief drawing
	* generic/tkOldConfig.c: added TK_CONFIG_OBJS so old style
	ConfigureWidget calls can pass in Tcl_Obj arrays
	* generic/tkScrollbar.c:
	* generic/tkScrollbar.h: made -orient use an option table
	* generic/tkText.c:
	* generic/tkText.h: made -wrap and -state use option tables
	* generic/tkTextBTree.c:
	* generic/tkTextDisp.c:
	* generic/tkTextImage.c:
	* generic/tkTextMark.c:
	* generic/tkTextTag.c:
	* generic/tkTextWind.c: added support for -elide and -state hidden
	* generic/tkTrig.c: changed TkMakeBezierCurve to support returning
	the upper limit of points needed for spline
	* generic/tkUtil.c: new option table parsing routines
	* generic/tkWindow.c: init'ing of warp stuff, mouseButtonState

1 files changed, 455 insertions, 111 deletions

diff --git a/generic/tkRectOval.c b/generic/tkRectOval.c
index 70556b4..b509c04 100644
--- a/generic/tkRectOval.c
+++ b/generic/tkRectOval.c
@@ -10,13 +10,14 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkRectOval.c,v 1.3 1999/04/16 01:51:21 stanton Exp $
+ * RCS: @(#) $Id: tkRectOval.c,v 1.4 1999/12/14 06:52:30 hobbs Exp $
  */
 
 #include <stdio.h>
 #include "tk.h"
 #include "tkInt.h"
 #include "tkPort.h"
+#include "tkCanvas.h"
 
 /*
  * The structure below defines the record for each rectangle/oval item.
@@ -25,14 +26,17 @@
 typedef struct RectOvalItem  {
     Tk_Item header;		/* Generic stuff that's the same for all
 				 * types.  MUST BE FIRST IN STRUCTURE. */
+    Tk_Outline outline;		/* Outline structure */
     double bbox[4];		/* Coordinates of bounding box for rectangle
 				 * or oval (x1, y1, x2, y2).  Item includes
 				 * x1 and x2 but not y1 and y2. */
-    int width;			/* Width of outline. */
-    XColor *outlineColor;	/* Color for outline. */
+    Tk_TSOffset tsoffset;
     XColor *fillColor;		/* Color for filling rectangle/oval. */
+    XColor *activeFillColor;	/* Color for filling rectangle/oval if state is active. */
+    XColor *disabledFillColor;	/* Color for filling rectangle/oval if state is disabled. */
     Pixmap fillStipple;		/* Stipple bitmap for filling item. */
-    GC outlineGC;		/* Graphics context for outline. */
+    Pixmap activeFillStipple;	/* Stipple bitmap for filling item if state is active. */
+    Pixmap disabledFillStipple;	/* Stipple bitmap for filling item if state is disabled. */
     GC fillGC;			/* Graphics context for filling item. */
 } RectOvalItem;
 
@@ -40,21 +44,93 @@ typedef struct RectOvalItem  {
  * Information used for parsing configuration specs:
  */
 
-static Tk_CustomOption tagsOption = {Tk_CanvasTagsParseProc,
+static Tk_CustomOption stateOption = {
+    (Tk_OptionParseProc *) TkStateParseProc,
+    TkStatePrintProc, (ClientData) 2
+};
+static Tk_CustomOption tagsOption = {
+    (Tk_OptionParseProc *) Tk_CanvasTagsParseProc,
     Tk_CanvasTagsPrintProc, (ClientData) NULL
 };
+static Tk_CustomOption dashOption = {
+    (Tk_OptionParseProc *) TkCanvasDashParseProc,
+    TkCanvasDashPrintProc, (ClientData) NULL
+};
+static Tk_CustomOption offsetOption = {
+    (Tk_OptionParseProc *) TkOffsetParseProc,
+    TkOffsetPrintProc, (ClientData) TK_OFFSET_RELATIVE
+};
+static Tk_CustomOption pixelOption = {
+    (Tk_OptionParseProc *) TkPixelParseProc,
+    TkPixelPrintProc, (ClientData) NULL
+};
 
 static Tk_ConfigSpec configSpecs[] = {
+    {TK_CONFIG_CUSTOM, "-activedash", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.activeDash),
+	TK_CONFIG_NULL_OK, &dashOption},
+    {TK_CONFIG_COLOR, "-activefill", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, activeFillColor),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_COLOR, "-activeoutline", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.activeColor),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_BITMAP, "-activeoutlinestipple", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.activeStipple),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_BITMAP, "-activestipple", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, activeFillStipple),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_CUSTOM, "-activewidth", (char *) NULL, (char *) NULL,
+	"0.0", Tk_Offset(RectOvalItem, outline.activeWidth),
+	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
+    {TK_CONFIG_CUSTOM, "-dash", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.dash),
+	TK_CONFIG_NULL_OK, &dashOption},
+    {TK_CONFIG_PIXELS, "-dashoffset", (char *) NULL, (char *) NULL,
+	"0", Tk_Offset(RectOvalItem, outline.offset),
+	TK_CONFIG_DONT_SET_DEFAULT},
+    {TK_CONFIG_CUSTOM, "-disableddash", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.disabledDash),
+	TK_CONFIG_NULL_OK, &dashOption},
+    {TK_CONFIG_COLOR, "-disabledfill", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, disabledFillColor),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_COLOR, "-disabledoutline", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.disabledColor),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_BITMAP, "-disabledoutlinestipple", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.disabledStipple),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_BITMAP, "-disabledstipple", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, disabledFillStipple),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_PIXELS, "-disabledwidth", (char *) NULL, (char *) NULL,
+	"0.0", Tk_Offset(RectOvalItem, outline.disabledWidth),
+	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
     {TK_CONFIG_COLOR, "-fill", (char *) NULL, (char *) NULL,
 	(char *) NULL, Tk_Offset(RectOvalItem, fillColor), TK_CONFIG_NULL_OK},
+    {TK_CONFIG_CUSTOM, "-offset", (char *) NULL, (char *) NULL,
+	"0,0", Tk_Offset(RectOvalItem, tsoffset),
+	TK_CONFIG_DONT_SET_DEFAULT, &offsetOption},
     {TK_CONFIG_COLOR, "-outline", (char *) NULL, (char *) NULL,
-	"black", Tk_Offset(RectOvalItem, outlineColor), TK_CONFIG_NULL_OK},
+	"black", Tk_Offset(RectOvalItem, outline.color), TK_CONFIG_NULL_OK},
+    {TK_CONFIG_CUSTOM, "-outlineoffset", (char *) NULL, (char *) NULL,
+	"0,0", Tk_Offset(RectOvalItem, outline.tsoffset),
+	TK_CONFIG_DONT_SET_DEFAULT, &offsetOption},
+    {TK_CONFIG_BITMAP, "-outlinestipple", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(RectOvalItem, outline.stipple),
+	TK_CONFIG_NULL_OK},
+    {TK_CONFIG_CUSTOM, "-state", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(Tk_Item, state),TK_CONFIG_NULL_OK,
+	&stateOption},
     {TK_CONFIG_BITMAP, "-stipple", (char *) NULL, (char *) NULL,
 	(char *) NULL, Tk_Offset(RectOvalItem, fillStipple), TK_CONFIG_NULL_OK},
     {TK_CONFIG_CUSTOM, "-tags", (char *) NULL, (char *) NULL,
 	(char *) NULL, 0, TK_CONFIG_NULL_OK, &tagsOption},
-    {TK_CONFIG_PIXELS, "-width", (char *) NULL, (char *) NULL,
-	"1", Tk_Offset(RectOvalItem, width), TK_CONFIG_DONT_SET_DEFAULT},
+    {TK_CONFIG_CUSTOM, "-width", (char *) NULL, (char *) NULL,
+	"1.0", Tk_Offset(RectOvalItem, outline.width),
+	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
 	(char *) NULL, 0, 0}
 };
@@ -67,10 +143,10 @@ static void		ComputeRectOvalBbox _ANSI_ARGS_((Tk_Canvas canvas,
 			    RectOvalItem *rectOvalPtr));
 static int		ConfigureRectOval _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tk_Canvas canvas, Tk_Item *itemPtr, int argc,
-			    char **argv, int flags));
+			    Tcl_Obj *CONST argv[], int flags));
 static int		CreateRectOval _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tk_Canvas canvas, struct Tk_Item *itemPtr,
-			    int argc, char **argv));
+			    int argc, Tcl_Obj *CONST argv[]));
 static void		DeleteRectOval _ANSI_ARGS_((Tk_Canvas canvas,
 			    Tk_Item *itemPtr, Display *display));
 static void		DisplayRectOval _ANSI_ARGS_((Tk_Canvas canvas,
@@ -82,7 +158,7 @@ static double		OvalToPoint _ANSI_ARGS_((Tk_Canvas canvas,
 			    Tk_Item *itemPtr, double *pointPtr));
 static int		RectOvalCoords _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tk_Canvas canvas, Tk_Item *itemPtr, int argc,
-			    char **argv));
+			    Tcl_Obj *CONST argv[]));
 static int		RectOvalToPostscript _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tk_Canvas canvas, Tk_Item *itemPtr, int prepass));
 static int		RectToArea _ANSI_ARGS_((Tk_Canvas canvas,
@@ -109,7 +185,7 @@ Tk_ItemType tkRectangleType = {
     RectOvalCoords,			/* coordProc */
     DeleteRectOval,			/* deleteProc */
     DisplayRectOval,			/* displayProc */
-    0,					/* alwaysRedraw */
+    TK_CONFIG_OBJS,			/* flags */
     RectToPoint,			/* pointProc */
     RectToArea,				/* areaProc */
     RectOvalToPostscript,		/* postscriptProc */
@@ -120,7 +196,7 @@ Tk_ItemType tkRectangleType = {
     (Tk_ItemSelectionProc *) NULL,	/* selectionProc */
     (Tk_ItemInsertProc *) NULL,		/* insertProc */
     (Tk_ItemDCharsProc *) NULL,		/* dTextProc */
-    (Tk_ItemType *) NULL		/* nextPtr */
+    (Tk_ItemType *) NULL,		/* nextPtr */
 };
 
 Tk_ItemType tkOvalType = {
@@ -132,7 +208,7 @@ Tk_ItemType tkOvalType = {
     RectOvalCoords,			/* coordProc */
     DeleteRectOval,			/* deleteProc */
     DisplayRectOval,			/* displayProc */
-    0,					/* alwaysRedraw */
+    TK_CONFIG_OBJS,			/* flags */
     OvalToPoint,			/* pointProc */
     OvalToArea,				/* areaProc */
     RectOvalToPostscript,		/* postscriptProc */
@@ -143,7 +219,7 @@ Tk_ItemType tkOvalType = {
     (Tk_ItemSelectionProc *) NULL,	/* selectionProc */
     (Tk_ItemInsertProc *) NULL,		/* insertProc */
     (Tk_ItemDCharsProc *) NULL,		/* dTextProc */
-    (Tk_ItemType *) NULL		/* nextPtr */
+    (Tk_ItemType *) NULL,		/* nextPtr */
 };
 
 /*
@@ -173,11 +249,25 @@ CreateRectOval(interp, canvas, itemPtr, argc, argv)
     Tk_Item *itemPtr;			/* Record to hold new item;  header
 					 * has been initialized by caller. */
     int argc;				/* Number of arguments in argv. */
-    char **argv;			/* Arguments describing rectangle. */
+    Tcl_Obj *CONST argv[];		/* Arguments describing rectangle. */
 {
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
+    int i;
+
+
+    if (argc==1) {
+	i = 1;
+    } else {
+	char *arg = Tcl_GetStringFromObj(argv[1], NULL);
+	if ((argc>1) && (arg[0] == '-')
+		&& (arg[1] >= 'a') && (arg[1] <= 'z')) {
+	    i = 1;
+	} else {
+	    i = 4;
+	}
+    }
 
-    if (argc < 4) {
+    if (argc < i) {
 	Tcl_AppendResult(interp, "wrong # args: should be \"",
 		Tk_PathName(Tk_CanvasTkwin(canvas)), " create ",
 		itemPtr->typePtr->name, " x1 y1 x2 y2 ?options?\"",
@@ -190,34 +280,33 @@ CreateRectOval(interp, canvas, itemPtr, argc, argv)
      * up after errors during the the remainder of this procedure.
      */
 
-    rectOvalPtr->width = 1;
-    rectOvalPtr->outlineColor = NULL;
+    Tk_CreateOutline(&(rectOvalPtr->outline));
+    rectOvalPtr->tsoffset.flags = 0;
+    rectOvalPtr->tsoffset.xoffset = 0;
+    rectOvalPtr->tsoffset.yoffset = 0;
     rectOvalPtr->fillColor = NULL;
+    rectOvalPtr->activeFillColor = NULL;
+    rectOvalPtr->disabledFillColor = NULL;
     rectOvalPtr->fillStipple = None;
-    rectOvalPtr->outlineGC = None;
+    rectOvalPtr->activeFillStipple = None;
+    rectOvalPtr->disabledFillStipple = None;
     rectOvalPtr->fillGC = None;
 
     /*
      * Process the arguments to fill in the item record.
      */
 
-    if ((Tk_CanvasGetCoord(interp, canvas, argv[0],
-		&rectOvalPtr->bbox[0]) != TCL_OK)
-	    || (Tk_CanvasGetCoord(interp, canvas, argv[1],
-		&rectOvalPtr->bbox[1]) != TCL_OK)
-	    || (Tk_CanvasGetCoord(interp, canvas, argv[2],
-		    &rectOvalPtr->bbox[2]) != TCL_OK)
-	    || (Tk_CanvasGetCoord(interp, canvas, argv[3],
-		    &rectOvalPtr->bbox[3]) != TCL_OK)) {
-	return TCL_ERROR;
+    if ((RectOvalCoords(interp, canvas, itemPtr, i, argv) != TCL_OK)) {
+	goto error;
     }
-
-    if (ConfigureRectOval(interp, canvas, itemPtr, argc-4, argv+4, 0)
-	    != TCL_OK) {
-	DeleteRectOval(canvas, itemPtr, Tk_Display(Tk_CanvasTkwin(canvas)));
-	return TCL_ERROR;
+    if (ConfigureRectOval(interp, canvas, itemPtr, argc-i, argv+i, 0)
+	    == TCL_OK) {
+	return TCL_OK;
     }
-    return TCL_OK;
+
+    error:
+    DeleteRectOval(canvas, itemPtr, Tk_Display(Tk_CanvasTkwin(canvas)));
+    return TCL_ERROR;
 }
 
 /*
@@ -246,28 +335,42 @@ RectOvalCoords(interp, canvas, itemPtr, argc, argv)
 					 * read or modified. */
     int argc;				/* Number of coordinates supplied in
 					 * argv. */
-    char **argv;			/* Array of coordinates: x1, y1,
+    Tcl_Obj *CONST argv[];		/* Array of coordinates: x1, y1,
 					 * x2, y2, ... */
 {
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
-    char c0[TCL_DOUBLE_SPACE], c1[TCL_DOUBLE_SPACE];
-    char c2[TCL_DOUBLE_SPACE], c3[TCL_DOUBLE_SPACE];
 
     if (argc == 0) {
-	Tcl_PrintDouble(interp, rectOvalPtr->bbox[0], c0);
-	Tcl_PrintDouble(interp, rectOvalPtr->bbox[1], c1);
-	Tcl_PrintDouble(interp, rectOvalPtr->bbox[2], c2);
-	Tcl_PrintDouble(interp, rectOvalPtr->bbox[3], c3);
-	Tcl_AppendResult(interp, c0, " ", c1, " ", c2, " ", c3,
-		(char *) NULL);
-    } else if (argc == 4) {
-	if ((Tk_CanvasGetCoord(interp, canvas, argv[0],
-		    &rectOvalPtr->bbox[0]) != TCL_OK)
-		|| (Tk_CanvasGetCoord(interp, canvas, argv[1],
+	Tcl_Obj *obj = Tcl_NewObj();
+	Tcl_Obj *subobj = Tcl_NewDoubleObj(rectOvalPtr->bbox[0]);
+	Tcl_ListObjAppendElement(interp, obj, subobj);
+	subobj = Tcl_NewDoubleObj(rectOvalPtr->bbox[1]);
+	Tcl_ListObjAppendElement(interp, obj, subobj);
+	subobj = Tcl_NewDoubleObj(rectOvalPtr->bbox[2]);
+	Tcl_ListObjAppendElement(interp, obj, subobj);
+	subobj = Tcl_NewDoubleObj(rectOvalPtr->bbox[3]);
+	Tcl_ListObjAppendElement(interp, obj, subobj);
+	Tcl_SetObjResult(interp, obj);
+    } else if ((argc == 1)||(argc == 4)) {
+ 	if (argc==1) {
+	    if (Tcl_ListObjGetElements(interp, argv[0], &argc,
+		    (Tcl_Obj ***) &argv) != TCL_OK) {
+		return TCL_ERROR;
+	    } else if (argc != 4) {
+		char buf[64 + TCL_INTEGER_SPACE];
+
+		sprintf(buf, "wrong # coordinates: expected 0 or 4, got %d", argc);
+		Tcl_SetResult(interp, buf, TCL_VOLATILE);
+		return TCL_ERROR;
+	    }
+	}
+	if ((Tk_CanvasGetCoordFromObj(interp, canvas, argv[0],
+ 		    &rectOvalPtr->bbox[0]) != TCL_OK)
+		|| (Tk_CanvasGetCoordFromObj(interp, canvas, argv[1],
 		    &rectOvalPtr->bbox[1]) != TCL_OK)
-		|| (Tk_CanvasGetCoord(interp, canvas, argv[2],
+		|| (Tk_CanvasGetCoordFromObj(interp, canvas, argv[2],
 			&rectOvalPtr->bbox[2]) != TCL_OK)
-		|| (Tk_CanvasGetCoord(interp, canvas, argv[3],
+		|| (Tk_CanvasGetCoordFromObj(interp, canvas, argv[3],
 			&rectOvalPtr->bbox[3]) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
@@ -308,7 +411,7 @@ ConfigureRectOval(interp, canvas, itemPtr, argc, argv, flags)
     Tk_Canvas canvas;		/* Canvas containing itemPtr. */
     Tk_Item *itemPtr;		/* Rectangle item to reconfigure. */
     int argc;			/* Number of elements in argv.  */
-    char **argv;		/* Arguments describing things to configure. */
+    Tcl_Obj *CONST argv[];	/* Arguments describing things to configure. */
     int flags;			/* Flags to pass to Tk_ConfigureWidget. */
 {
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
@@ -316,41 +419,99 @@ ConfigureRectOval(interp, canvas, itemPtr, argc, argv, flags)
     GC newGC;
     unsigned long mask;
     Tk_Window tkwin;
+    Tk_TSOffset *tsoffset;
+    XColor *color;
+    Pixmap stipple;
+    Tk_State state;
 
     tkwin = Tk_CanvasTkwin(canvas);
-    if (Tk_ConfigureWidget(interp, tkwin, configSpecs, argc, argv,
-	    (char *) rectOvalPtr, flags) != TCL_OK) {
+
+    if (Tk_ConfigureWidget(interp, tkwin, configSpecs, argc, (char **) argv,
+	    (char *) rectOvalPtr, flags|TK_CONFIG_OBJS) != TCL_OK) {
 	return TCL_ERROR;
     }
 
+    state = itemPtr->state;
+
     /*
      * A few of the options require additional processing, such as
      * graphics contexts.
      */
 
-    if (rectOvalPtr->width < 1) {
-	rectOvalPtr->width = 1;
-    }
-    if (rectOvalPtr->outlineColor == NULL) {
-	newGC = None;
+    if (rectOvalPtr->outline.activeWidth > rectOvalPtr->outline.width ||
+	    rectOvalPtr->outline.activeDash.number > 0 ||
+	    rectOvalPtr->outline.activeColor != NULL ||
+	    rectOvalPtr->outline.activeStipple != None ||
+	    rectOvalPtr->activeFillColor != NULL ||
+	    rectOvalPtr->activeFillStipple != None) {
+	itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
     } else {
-	gcValues.foreground = rectOvalPtr->outlineColor->pixel;
+	itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
+    }
+
+    tsoffset = &rectOvalPtr->outline.tsoffset;
+    flags = tsoffset->flags;
+    if (flags & TK_OFFSET_LEFT) {
+	tsoffset->xoffset = (int) (rectOvalPtr->bbox[0] + 0.5);
+    } else if (flags & TK_OFFSET_CENTER) {
+	tsoffset->xoffset = (int) ((rectOvalPtr->bbox[0]+rectOvalPtr->bbox[2]+1)/2);
+    } else if (flags & TK_OFFSET_RIGHT) {
+	tsoffset->xoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
+    }
+    if (flags & TK_OFFSET_TOP) {
+	tsoffset->yoffset = (int) (rectOvalPtr->bbox[1] + 0.5);
+    } else if (flags & TK_OFFSET_MIDDLE) {
+	tsoffset->yoffset = (int) ((rectOvalPtr->bbox[1]+rectOvalPtr->bbox[3]+1)/2);
+    } else if (flags & TK_OFFSET_BOTTOM) {
+	tsoffset->yoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
+    }
+
+    mask = Tk_ConfigOutlineGC(&gcValues, canvas, itemPtr,
+	     &(rectOvalPtr->outline));
+    if (mask) {
 	gcValues.cap_style = CapProjecting;
-	gcValues.line_width = rectOvalPtr->width;
-	mask = GCForeground|GCCapStyle|GCLineWidth;
+	mask |= GCCapStyle;
 	newGC = Tk_GetGC(tkwin, mask, &gcValues);
+    } else {
+	newGC = None;
+    }
+    if (rectOvalPtr->outline.gc != None) {
+	Tk_FreeGC(Tk_Display(tkwin), rectOvalPtr->outline.gc);
     }
-    if (rectOvalPtr->outlineGC != None) {
-	Tk_FreeGC(Tk_Display(tkwin), rectOvalPtr->outlineGC);
+    rectOvalPtr->outline.gc = newGC;
+
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+    if (state==TK_STATE_HIDDEN) {
+	ComputeRectOvalBbox(canvas, rectOvalPtr);
+	return TCL_OK;
+    }
+
+    color = rectOvalPtr->fillColor;
+    stipple = rectOvalPtr->fillStipple;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (rectOvalPtr->activeFillColor!=NULL) {
+	    color = rectOvalPtr->activeFillColor;
+	}
+	if (rectOvalPtr->activeFillStipple!=None) {
+	    stipple = rectOvalPtr->activeFillStipple;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectOvalPtr->disabledFillColor!=NULL) {
+	    color = rectOvalPtr->disabledFillColor;
+	}
+	if (rectOvalPtr->disabledFillStipple!=None) {
+	    stipple = rectOvalPtr->disabledFillStipple;
+	}
     }
-    rectOvalPtr->outlineGC = newGC;
 
-    if (rectOvalPtr->fillColor == NULL) {
+    if (color == NULL) {
 	newGC = None;
     } else {
-	gcValues.foreground = rectOvalPtr->fillColor->pixel;
-	if (rectOvalPtr->fillStipple != None) {
-	    gcValues.stipple = rectOvalPtr->fillStipple;
+	gcValues.foreground = color->pixel;
+	if (stipple != None) {
+	    gcValues.stipple = stipple;
 	    gcValues.fill_style = FillStippled;
 	    mask = GCForeground|GCStipple|GCFillStyle;
 	} else {
@@ -362,6 +523,24 @@ ConfigureRectOval(interp, canvas, itemPtr, argc, argv, flags)
 	Tk_FreeGC(Tk_Display(tkwin), rectOvalPtr->fillGC);
     }
     rectOvalPtr->fillGC = newGC;
+
+    tsoffset = &rectOvalPtr->tsoffset;
+    flags = tsoffset->flags;
+    if (flags & TK_OFFSET_LEFT) {
+	tsoffset->xoffset = (int) (rectOvalPtr->bbox[0] + 0.5);
+    } else if (flags & TK_OFFSET_CENTER) {
+	tsoffset->xoffset = (int) ((rectOvalPtr->bbox[0]+rectOvalPtr->bbox[2]+1)/2);
+    } else if (flags & TK_OFFSET_RIGHT) {
+	tsoffset->xoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
+    }
+    if (flags & TK_OFFSET_TOP) {
+	tsoffset->yoffset = (int) (rectOvalPtr->bbox[1] + 0.5);
+    } else if (flags & TK_OFFSET_MIDDLE) {
+	tsoffset->yoffset = (int) ((rectOvalPtr->bbox[1]+rectOvalPtr->bbox[3]+1)/2);
+    } else if (flags & TK_OFFSET_BOTTOM) {
+	tsoffset->yoffset = (int) (rectOvalPtr->bbox[3] + 0.5);
+    }
+
     ComputeRectOvalBbox(canvas, rectOvalPtr);
 
     return TCL_OK;
@@ -393,17 +572,24 @@ DeleteRectOval(canvas, itemPtr, display)
 {
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
 
-    if (rectOvalPtr->outlineColor != NULL) {
-	Tk_FreeColor(rectOvalPtr->outlineColor);
-    }
+    Tk_DeleteOutline(display, &(rectOvalPtr->outline));
     if (rectOvalPtr->fillColor != NULL) {
 	Tk_FreeColor(rectOvalPtr->fillColor);
     }
+    if (rectOvalPtr->activeFillColor != NULL) {
+	Tk_FreeColor(rectOvalPtr->activeFillColor);
+    }
+    if (rectOvalPtr->disabledFillColor != NULL) {
+	Tk_FreeColor(rectOvalPtr->disabledFillColor);
+    }
     if (rectOvalPtr->fillStipple != None) {
 	Tk_FreeBitmap(display, rectOvalPtr->fillStipple);
     }
-    if (rectOvalPtr->outlineGC != None) {
-	Tk_FreeGC(display, rectOvalPtr->outlineGC);
+    if (rectOvalPtr->activeFillStipple != None) {
+	Tk_FreeBitmap(display, rectOvalPtr->activeFillStipple);
+    }
+    if (rectOvalPtr->disabledFillStipple != None) {
+	Tk_FreeBitmap(display, rectOvalPtr->disabledFillStipple);
     }
     if (rectOvalPtr->fillGC != None) {
 	Tk_FreeGC(display, rectOvalPtr->fillGC);
@@ -437,7 +623,28 @@ ComputeRectOvalBbox(canvas, rectOvalPtr)
 					 * recomputed. */
 {
     int bloat, tmp;
-    double dtmp;
+    double dtmp, width;
+    Tk_State state = rectOvalPtr->header.state;
+
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+
+    width = rectOvalPtr->outline.width;
+    if (state==TK_STATE_HIDDEN) {
+	rectOvalPtr->header.x1 = rectOvalPtr->header.y1 =
+	rectOvalPtr->header.x2 = rectOvalPtr->header.y2 = -1;
+	return;
+    }
+    if (((TkCanvas *)canvas)->currentItemPtr == (Tk_Item *)rectOvalPtr) {
+	if (rectOvalPtr->outline.activeWidth>width) {
+	    width = rectOvalPtr->outline.activeWidth;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectOvalPtr->outline.disabledWidth>0) {
+	    width = rectOvalPtr->outline.disabledWidth;
+	}
+    }
 
     /*
      * Make sure that the first coordinates are the lowest ones.
@@ -456,10 +663,10 @@ ComputeRectOvalBbox(canvas, rectOvalPtr)
 	rectOvalPtr->bbox[0] = tmp;
     }
 
-    if (rectOvalPtr->outlineColor == NULL) {
-	bloat = 0;
+    if (rectOvalPtr->outline.gc == None) {
+	bloat = 1;
     } else {
-	bloat = (rectOvalPtr->width+1)/2;
+	bloat = (int) (width+1)/2;
     }
 
     /*
@@ -518,6 +725,8 @@ DisplayRectOval(canvas, itemPtr, display, drawable, x, y, width, height)
 {
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
     short x1, y1, x2, y2;
+    Pixmap fillStipple;
+    Tk_State state = itemPtr->state;
 
     /*
      * Compute the screen coordinates of the bounding box for the item.
@@ -543,9 +752,48 @@ DisplayRectOval(canvas, itemPtr, display, drawable, x, y, width, height)
      * read-only.
      */
 
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+    fillStipple = rectOvalPtr->fillStipple;
+    if (((TkCanvas *)canvas)->currentItemPtr == (Tk_Item *)rectOvalPtr) {
+	if (rectOvalPtr->activeFillStipple!=None) {
+	    fillStipple = rectOvalPtr->activeFillStipple;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectOvalPtr->disabledFillStipple!=None) {
+	    fillStipple = rectOvalPtr->disabledFillStipple;
+	}
+    }
+
     if (rectOvalPtr->fillGC != None) {
-	if (rectOvalPtr->fillStipple != None) {
-	    Tk_CanvasSetStippleOrigin(canvas, rectOvalPtr->fillGC);
+	if (fillStipple != None) {
+	    Tk_TSOffset *tsoffset;
+	    int w=0; int h=0;
+	    tsoffset = &rectOvalPtr->tsoffset;
+	    if (tsoffset) {
+		int flags = tsoffset->flags;
+		if (flags & (TK_OFFSET_CENTER|TK_OFFSET_MIDDLE)) {
+		    Tk_SizeOfBitmap(display, fillStipple, &w, &h);
+		    if (flags & TK_OFFSET_CENTER) {
+			w /= 2;
+		    } else {
+			w = 0;
+		    }
+		    if (flags & TK_OFFSET_MIDDLE) {
+			h /= 2;
+		    } else {
+			h = 0;
+		    }
+		}
+		tsoffset->xoffset -= w;
+		tsoffset->yoffset -= h;
+	    }
+	    Tk_CanvasSetOffset(canvas, rectOvalPtr->fillGC, tsoffset);
+	    if (tsoffset) {
+		tsoffset->xoffset += w;
+		tsoffset->yoffset += h;
+	    }
 	}
 	if (rectOvalPtr->header.typePtr == &tkRectangleType) {
 	    XFillRectangle(display, drawable, rectOvalPtr->fillGC,
@@ -555,18 +803,20 @@ DisplayRectOval(canvas, itemPtr, display, drawable, x, y, width, height)
 		    x1, y1, (unsigned) (x2-x1), (unsigned) (y2-y1),
 		    0, 360*64);
 	}
-	if (rectOvalPtr->fillStipple != None) {
+	if (fillStipple != None) {
 	    XSetTSOrigin(display, rectOvalPtr->fillGC, 0, 0);
 	}
     }
-    if (rectOvalPtr->outlineGC != None) {
+    if (rectOvalPtr->outline.gc != None) {
+	Tk_ChangeOutlineGC(canvas, itemPtr, &(rectOvalPtr->outline));
 	if (rectOvalPtr->header.typePtr == &tkRectangleType) {
-	    XDrawRectangle(display, drawable, rectOvalPtr->outlineGC,
+	    XDrawRectangle(display, drawable, rectOvalPtr->outline.gc,
 		    x1, y1, (unsigned) (x2-x1), (unsigned) (y2-y1));
 	} else {
-	    XDrawArc(display, drawable, rectOvalPtr->outlineGC,
+	    XDrawArc(display, drawable, rectOvalPtr->outline.gc,
 		    x1, y1, (unsigned) (x2-x1), (unsigned) (y2-y1), 0, 360*64);
 	}
+	Tk_ResetOutlineGC(canvas, itemPtr, &(rectOvalPtr->outline));
     }
 }
 
@@ -602,6 +852,23 @@ RectToPoint(canvas, itemPtr, pointPtr)
 {
     RectOvalItem *rectPtr = (RectOvalItem *) itemPtr;
     double xDiff, yDiff, x1, y1, x2, y2, inc, tmp;
+    double width;
+    Tk_State state = itemPtr->state;
+
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+
+    width = rectPtr->outline.width;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (rectPtr->outline.activeWidth>width) {
+	    width = rectPtr->outline.activeWidth;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectPtr->outline.disabledWidth>0) {
+	    width = rectPtr->outline.disabledWidth;
+	}
+    }
 
     /*
      * Generate a new larger rectangle that includes the border
@@ -612,8 +879,8 @@ RectToPoint(canvas, itemPtr, pointPtr)
     y1 = rectPtr->bbox[1];
     x2 = rectPtr->bbox[2];
     y2 = rectPtr->bbox[3];
-    if (rectPtr->outlineGC != None) {
-	inc = rectPtr->width/2.0;
+    if (rectPtr->outline.gc != None) {
+	inc = width/2.0;
 	x1 -= inc;
 	y1 -= inc;
 	x2 += inc;
@@ -629,7 +896,7 @@ RectToPoint(canvas, itemPtr, pointPtr)
 
     if ((pointPtr[0] >= x1) && (pointPtr[0] < x2)
 		&& (pointPtr[1] >= y1) && (pointPtr[1] < y2)) {
-	if ((rectPtr->fillGC != None) || (rectPtr->outlineGC == None)) {
+	if ((rectPtr->fillGC != None) || (rectPtr->outline.gc == None)) {
 	    return 0.0;
 	}
 	xDiff = pointPtr[0] - x1;
@@ -645,7 +912,7 @@ RectToPoint(canvas, itemPtr, pointPtr)
 	if (yDiff < xDiff) {
 	    xDiff = yDiff;
 	}
-	xDiff -= rectPtr->width;
+	xDiff -= width;
 	if (xDiff < 0.0) {
 	    return 0.0;
 	}
@@ -708,10 +975,26 @@ OvalToPoint(canvas, itemPtr, pointPtr)
     RectOvalItem *ovalPtr = (RectOvalItem *) itemPtr;
     double width;
     int filled;
+    Tk_State state = itemPtr->state;
+
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+
+    width = (double) ovalPtr->outline.width;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (ovalPtr->outline.activeWidth>width) {
+	    width = (double) ovalPtr->outline.activeWidth;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (ovalPtr->outline.disabledWidth>0) {
+	    width = (double) ovalPtr->outline.disabledWidth;
+	}
+    }
+
 
-    width = ovalPtr->width;
     filled = ovalPtr->fillGC != None;
-    if (ovalPtr->outlineGC == None) {
+    if (ovalPtr->outline.gc == None) {
 	width = 0.0;
 	filled = 1;
     }
@@ -749,9 +1032,26 @@ RectToArea(canvas, itemPtr, areaPtr)
 {
     RectOvalItem *rectPtr = (RectOvalItem *) itemPtr;
     double halfWidth;
+    double width;
+    Tk_State state = itemPtr->state;
 
-    halfWidth = rectPtr->width/2.0;
-    if (rectPtr->outlineGC == None) {
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+
+    width = rectPtr->outline.width;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (rectPtr->outline.activeWidth>width) {
+	    width = rectPtr->outline.activeWidth;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectPtr->outline.disabledWidth>0) {
+	    width = rectPtr->outline.disabledWidth;
+	}
+    }
+
+    halfWidth = width/2.0;
+    if (rectPtr->outline.gc == None) {
 	halfWidth = 0.0;
     }
 
@@ -761,7 +1061,7 @@ RectToArea(canvas, itemPtr, areaPtr)
 	    || (areaPtr[1] >= (rectPtr->bbox[3] + halfWidth))) {
 	return -1;
     }
-    if ((rectPtr->fillGC == None) && (rectPtr->outlineGC != None)
+    if ((rectPtr->fillGC == None) && (rectPtr->outline.gc != None)
 	    && (areaPtr[0] >= (rectPtr->bbox[0] + halfWidth))
 	    && (areaPtr[1] >= (rectPtr->bbox[1] + halfWidth))
 	    && (areaPtr[2] <= (rectPtr->bbox[2] - halfWidth))
@@ -809,13 +1109,30 @@ OvalToArea(canvas, itemPtr, areaPtr)
     RectOvalItem *ovalPtr = (RectOvalItem *) itemPtr;
     double oval[4], halfWidth;
     int result;
+    double width;
+    Tk_State state = itemPtr->state;
+
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+
+    width = ovalPtr->outline.width;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (ovalPtr->outline.activeWidth>width) {
+	    width = ovalPtr->outline.activeWidth;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (ovalPtr->outline.disabledWidth>0) {
+	    width = ovalPtr->outline.disabledWidth;
+	}
+    }
 
     /*
      * Expand the oval to include the width of the outline, if any.
      */
 
-    halfWidth = ovalPtr->width/2.0;
-    if (ovalPtr->outlineGC == None) {
+    halfWidth = width/2.0;
+    if (ovalPtr->outline.gc == None) {
 	halfWidth = 0.0;
     }
     oval[0] = ovalPtr->bbox[0] - halfWidth;
@@ -832,9 +1149,9 @@ OvalToArea(canvas, itemPtr, areaPtr)
      * unfilled center, in which case we should return "outside".
      */
 
-    if ((result == 0) && (ovalPtr->outlineGC != None)
+    if ((result == 0) && (ovalPtr->outline.gc != None)
 	    && (ovalPtr->fillGC == None)) {
-	double centerX, centerY, width, height;
+	double centerX, centerY, height;
 	double xDelta1, yDelta1, xDelta2, yDelta2;
 
 	centerX = (ovalPtr->bbox[0] + ovalPtr->bbox[2])/2.0;
@@ -966,6 +1283,10 @@ RectOvalToPostscript(interp, canvas, itemPtr, prepass)
     char pathCmd[500];
     RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
     double y1, y2;
+    XColor *color;
+    XColor *fillColor;
+    Pixmap fillStipple;
+    Tk_State state = itemPtr->state;
 
     y1 = Tk_CanvasPsY(canvas, rectOvalPtr->bbox[1]);
     y2 = Tk_CanvasPsY(canvas, rectOvalPtr->bbox[3]);
@@ -988,23 +1309,51 @@ RectOvalToPostscript(interp, canvas, itemPtr, prepass)
 		(rectOvalPtr->bbox[2] - rectOvalPtr->bbox[0])/2, (y1 - y2)/2);
     }
 
+    if(state == TK_STATE_NULL) {
+	state = ((TkCanvas *)canvas)->canvas_state;
+    }
+    color = rectOvalPtr->outline.color;
+    fillColor = rectOvalPtr->fillColor;
+    fillStipple = rectOvalPtr->fillStipple;
+    if (((TkCanvas *)canvas)->currentItemPtr == itemPtr) {
+	if (rectOvalPtr->outline.activeColor!=NULL) {
+	    color = rectOvalPtr->outline.activeColor;
+	}
+	if (rectOvalPtr->activeFillColor!=NULL) {
+	    fillColor = rectOvalPtr->activeFillColor;
+	}
+	if (rectOvalPtr->activeFillStipple!=None) {
+	    fillStipple = rectOvalPtr->activeFillStipple;
+	}
+    } else if (state==TK_STATE_DISABLED) {
+	if (rectOvalPtr->outline.disabledColor!=NULL) {
+	    color = rectOvalPtr->outline.disabledColor;
+	}
+	if (rectOvalPtr->disabledFillColor!=NULL) {
+	    fillColor = rectOvalPtr->disabledFillColor;
+	}
+	if (rectOvalPtr->disabledFillStipple!=None) {
+	    fillStipple = rectOvalPtr->disabledFillStipple;
+	}
+    }
+
     /*
      * First draw the filled area of the rectangle.
      */
 
-    if (rectOvalPtr->fillColor != NULL) {
+    if (fillColor != NULL) {
 	Tcl_AppendResult(interp, pathCmd, (char *) NULL);
-	if (Tk_CanvasPsColor(interp, canvas, rectOvalPtr->fillColor)
+	if (Tk_CanvasPsColor(interp, canvas, fillColor)
 		!= TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (rectOvalPtr->fillStipple != None) {
+	if (fillStipple != None) {
 	    Tcl_AppendResult(interp, "clip ", (char *) NULL);
-	    if (Tk_CanvasPsStipple(interp, canvas, rectOvalPtr->fillStipple)
+	    if (Tk_CanvasPsStipple(interp, canvas, fillStipple)
 		    != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (rectOvalPtr->outlineColor != NULL) {
+	    if (color != NULL) {
 		Tcl_AppendResult(interp, "grestore gsave\n", (char *) NULL);
 	    }
 	} else {
@@ -1016,18 +1365,13 @@ RectOvalToPostscript(interp, canvas, itemPtr, prepass)
      * Now draw the outline, if there is one.
      */
 
-    if (rectOvalPtr->outlineColor != NULL) {
-	char string[32 + TCL_INTEGER_SPACE];
-
-	Tcl_AppendResult(interp, pathCmd, (char *) NULL);
-	sprintf(string, "%d setlinewidth", rectOvalPtr->width);
-	Tcl_AppendResult(interp, string,
-		" 0 setlinejoin 2 setlinecap\n", (char *) NULL);
-	if (Tk_CanvasPsColor(interp, canvas, rectOvalPtr->outlineColor)
-		!= TCL_OK) {
+    if (color != NULL) {
+	Tcl_AppendResult(interp, pathCmd, "0 setlinejoin 2 setlinecap\n",
+		(char *) NULL);
+	if (Tk_CanvasPsOutline(canvas, itemPtr,
+		&(rectOvalPtr->outline))!= TCL_OK) {
 	    return TCL_ERROR;
 	}
-	Tcl_AppendResult(interp, "stroke\n", (char *) NULL);
     }
     return TCL_OK;
 }