Merge 8.6

15 files changed, 149 insertions, 139 deletions

diff --git a/generic/tkCanvPoly.c b/generic/tkCanvPoly.c
index be80378..6a8f865 100644
--- a/generic/tkCanvPoly.c
+++ b/generic/tkCanvPoly.c
@@ -518,7 +518,7 @@ ConfigurePolygon(
 	 * Mac OS X CG drawing needs access to the outline linewidth
 	 * even for fills (as linewidth controls antialiasing).
 	 */
-	gcValues.line_width = polyPtr->outline.gc != None ?
+	gcValues.line_width = polyPtr->outline.gc != NULL ?
 		polyPtr->outline.gc->line_width : 0;
 	mask |= GCLineWidth;
 #endif
diff --git a/generic/tkFocus.c b/generic/tkFocus.c
index cb9c4ab..7a4bdbc 100644
--- a/generic/tkFocus.c
+++ b/generic/tkFocus.c
@@ -551,12 +551,17 @@ TkSetFocusWin(
 	return;
     }
 
+    /*
+     * Get the current focus window with the same display and application
+     * as winPtr.
+     */
+
     displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
 
     /*
-     * If force is set, we should make sure we grab the focus regardless of
-     * the current focus window since under Windows, we may need to take
-     * control away from another application.
+     * Do nothing if the window already has focus and force is not set.  If
+     * force is set, we need to grab the focus, since under Windows or macOS
+     * this may involve taking control away from another application.
      */
 
     if (winPtr == displayFocusPtr->focusWinPtr && !force) {
@@ -564,14 +569,15 @@ TkSetFocusWin(
     }
 
     /*
-     * Find the top-level window for winPtr, then find (or create) a record
-     * for the top-level. Also see whether winPtr and all its ancestors are
+     * Find the toplevel window for winPtr, then find (or create) a record
+     * for the toplevel. Also see whether winPtr and all its ancestors are
      * mapped.
      */
 
     allMapped = 1;
     for (topLevelPtr = winPtr; ; topLevelPtr = topLevelPtr->parentPtr) {
 	if (topLevelPtr == NULL) {
+
 	    /*
 	     * The window is being deleted. No point in worrying about giving
 	     * it the focus.
@@ -588,11 +594,11 @@ TkSetFocusWin(
     }
 
     /*
-     * If the new focus window isn't mapped, then we can't focus on it (X will
-     * generate an error, for example). Instead, create an event handler that
-     * will set the focus to this window once it gets mapped. At the same
-     * time, delete any old handler that might be around; it's no longer
-     * relevant.
+     * If any ancestor of the new focus window isn't mapped, then we can't set
+     * focus for it (X will generate an error, for example). Instead, create
+     * an event handler that will set the focus to this window once it gets
+     * mapped. At the same time, delete any old handler that might be around;
+     * it's no longer relevant.
      */
 
     if (displayFocusPtr->focusOnMapPtr != NULL) {
@@ -623,28 +629,36 @@ TkSetFocusWin(
     }
     tlFocusPtr->focusWinPtr = winPtr;
 
-    /*
-     * Reset the window system's focus window and generate focus events, with
-     * two special cases:
-     *
-     * 1. If the application is embedded and doesn't currently have the focus,
-     *    don't set the focus directly. Instead, see if the embedding code can
-     *    claim the focus from the enclosing container.
-     * 2. Otherwise, if the application doesn't currently have the focus,
-     *    don't change the window system's focus unless it was already in this
-     *    application or "force" was specified.
-     */
+    if (topLevelPtr->flags & TK_EMBEDDED) {
+
+	/*
+	 * We are assigning focus to an embedded toplevel.  The platform
+	 * specific function TkpClaimFocus needs to handle the job of
+	 * assigning focus to the container, since we have no way to find the
+	 * contaiuner.
+	 */
 
-    if ((topLevelPtr->flags & TK_EMBEDDED)
-	    && (displayFocusPtr->focusWinPtr == NULL)) {
 	TkpClaimFocus(topLevelPtr, force);
     } else if ((displayFocusPtr->focusWinPtr != NULL) || force) {
+
+	/*
+	 * If we are forcing removal of focus from a container hosting a
+	 * toplevel from a different application, clear the focus in that
+	 * application.
+	 */
+
+    	if (force) {
+	    TkWindow *focusPtr = winPtr->dispPtr->focusPtr;
+	    if (focusPtr && focusPtr->mainPtr != winPtr->mainPtr) {
+		DisplayFocusInfo *displayFocusPtr2 = FindDisplayFocusInfo(
+		    focusPtr->mainPtr, focusPtr->dispPtr);
+		displayFocusPtr2->focusWinPtr = NULL;
+	    }
+    	}
+
 	/*
-	 * Generate events to shift focus between Tk windows. We do this
-	 * regardless of what TkpChangeFocus does with the real X focus so
-	 * that Tk widgets track focus commands when there is no window
-	 * manager. GenerateFocusEvents will set up a serial number marker so
-	 * we discard focus events that are triggered by the ChangeFocus.
+	 * Call the platform specific function TkpChangeFocus to move the
+	 * window manager's focus to a new toplevel.
 	 */
 
 	serial = TkpChangeFocus(TkpGetWrapperWindow(topLevelPtr), force);
diff --git a/generic/tkImgGIF.c b/generic/tkImgGIF.c
index 7c4872b..0c32047 100644
--- a/generic/tkImgGIF.c
+++ b/generic/tkImgGIF.c
@@ -1034,7 +1034,7 @@ ReadImage(
     int transparent)
 {
     unsigned char initialCodeSize;
-    int xpos = 0, ypos = 0, pass = 0, i;
+    int xpos = 0, ypos = 0, pass = 0, i, count;
     register unsigned char *pixelPtr;
     static const int interlaceStep[] = { 8, 8, 4, 2 };
     static const int interlaceStart[] = { 0, 4, 2, 1 };
@@ -1252,6 +1252,25 @@ ReadImage(
 	}
 	pixelPtr = imagePtr + (ypos) * len * ((transparent>=0)?4:3);
     }
+
+    /*
+     * Now read until the final zero byte.
+     * It was observed that there might be 1 length blocks
+     * (test imgPhoto-14.1) which are not read.
+     *
+     * The field "stack" is abused for temporary buffer. it has 4096 bytes
+     * and we need 256.
+     *
+     * Loop until we hit a 0 length block which is the end sign.
+     */
+    while ( 0 < (count = GetDataBlock(gifConfPtr, chan, stack)))
+    {
+	if (-1 == count ) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		    "error reading GIF image: %s", Tcl_PosixError(interp)));
+	    return TCL_ERROR;
+	}
+    }
     return TCL_OK;
 }
 
diff --git a/generic/tkInt.decls b/generic/tkInt.decls
index d0b7678..a3e1f98 100644
--- a/generic/tkInt.decls
+++ b/generic/tkInt.decls
@@ -1009,7 +1009,7 @@ declare 47 aqua {
     Tk_Window TkMacOSXGetCapture(void)
 }
 declare 49 aqua {
-    Window TkGetTransientMaster(TkWindow *winPtr)
+    Tk_Window TkGetTransientMaster(TkWindow *winPtr)
 }
 declare 50 aqua {
     int TkGenerateButtonEvent(int x, int y, Window window, unsigned int state)
diff --git a/generic/tkIntPlatDecls.h b/generic/tkIntPlatDecls.h
index ded5ac5..26a5f46 100644
--- a/generic/tkIntPlatDecls.h
+++ b/generic/tkIntPlatDecls.h
@@ -243,7 +243,7 @@ EXTERN int		TkpIsWindowFloating(void *window);
 EXTERN Tk_Window	TkMacOSXGetCapture(void);
 /* Slot 48 is reserved */
 /* 49 */
-EXTERN Window		TkGetTransientMaster(TkWindow *winPtr);
+EXTERN Tk_Window	TkGetTransientMaster(TkWindow *winPtr);
 /* 50 */
 EXTERN int		TkGenerateButtonEvent(int x, int y, Window window,
 				unsigned int state);
@@ -392,7 +392,7 @@ typedef struct TkIntPlatStubs {
     int (*tkpIsWindowFloating) (void *window); /* 46 */
     Tk_Window (*tkMacOSXGetCapture) (void); /* 47 */
     void (*reserved48)(void);
-    Window (*tkGetTransientMaster) (TkWindow *winPtr); /* 49 */
+    Tk_Window (*tkGetTransientMaster) (TkWindow *winPtr); /* 49 */
     int (*tkGenerateButtonEvent) (int x, int y, Window window, unsigned int state); /* 50 */
     void (*tkGenWMDestroyEvent) (Tk_Window tkwin); /* 51 */
     void (*tkMacOSXSetDrawingEnabled) (TkWindow *winPtr, int flag); /* 52 */
diff --git a/generic/tkMain.c b/generic/tkMain.c
index a7d4ca1..b80ce4d 100644
--- a/generic/tkMain.c
+++ b/generic/tkMain.c
@@ -79,22 +79,31 @@ extern const TclIntPlatStubs *tclIntPlatStubsPtr;
 #endif
 
 /*
- * Further on, in UNICODE mode, we need to use Tcl_NewUnicodeObj,
- * while otherwise NewNativeObj is needed (which provides proper
- * conversion from native encoding to UTF-8).
+ * Further on, in UNICODE mode we just use Tcl_NewUnicodeObj, otherwise
+ * NewNativeObj is needed (which provides proper conversion from native
+ * encoding to UTF-8).
  */
+
+static inline Tcl_Obj *
+NewNativeObj(
+    TCHAR *string,
+    int length)
+{
+    Tcl_Obj *obj;
+    Tcl_DString ds;
+
 #ifdef UNICODE
-#   define NewNativeObj Tcl_NewUnicodeObj
-#else /* !UNICODE */
-    static Tcl_Obj *NewNativeObj(char *string, int length) {
-	Tcl_Obj *obj;
-	Tcl_DString ds;
-	Tcl_ExternalToUtfDString(NULL, string, length, &ds);
-	obj = Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
-	Tcl_DStringFree(&ds);
-	return obj;
+    if (length > 0) {
+	length *= sizeof(WCHAR);
+    }
+    Tcl_WinTCharToUtf(string, length, &ds);
+#else
+    Tcl_ExternalToUtfDString(NULL, (char *) string, length, &ds);
+#endif
+    obj = Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
+    Tcl_DStringFree(&ds);
+    return obj;
 }
-#endif /* !UNICODE */
 
 /*
  * Declarations for various library functions and variables (don't want to
diff --git a/generic/tkMenu.c b/generic/tkMenu.c
index a31666d..38e3bbd 100644
--- a/generic/tkMenu.c
+++ b/generic/tkMenu.c
@@ -870,32 +870,37 @@ MenuWidgetObjCmd(
 	break;
     }
     case MENU_POST: {
-	int x, y;
+	int x, y, index = -1;
 
-	if (objc != 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "x y");
+	if (objc != 4 && objc != 5) {
+	    Tcl_WrongNumArgs(interp, 2, objv, "x y ?index?");
 	    goto error;
 	}
 	if ((Tcl_GetIntFromObj(interp, objv[2], &x) != TCL_OK)
 		|| (Tcl_GetIntFromObj(interp, objv[3], &y) != TCL_OK)) {
 	    goto error;
 	}
+	if (objc == 5) {
+            if (TkGetMenuIndex(interp, menuPtr, objv[4], 0, &index) != TCL_OK) {
+                goto error;
+            }
+	}
 
 	/*
-	 * Tearoff menus are posted differently on Mac and Windows than
-	 * non-tearoffs. TkpPostMenu does not actually map the menu's window
-	 * on those platforms, and popup menus have to be handled specially.
-         * Also, menubar menues are not intended to be posted (bug 1567681,
-         * 2160206).
+	 * Tearoff menus are the same as ordinary menus on the Mac and are
+	 * posted differently on Windows than non-tearoffs. TkpPostMenu
+	 * does not actually map the menu's window on those platforms, and
+	 * popup menus have to be handled specially.  Also, menubar menus are
+	 * not intended to be posted (bug 1567681, 2160206).
 	 */
 
 	if (menuPtr->menuType == MENUBAR) {
             Tcl_AppendResult(interp, "a menubar menu cannot be posted", NULL);
             return TCL_ERROR;
         } else if (menuPtr->menuType != TEAROFF_MENU) {
-	    result = TkpPostMenu(interp, menuPtr, x, y);
+	    result = TkpPostMenu(interp, menuPtr, x, y, index);
 	} else {
-	    result = TkPostTearoffMenu(interp, menuPtr, x, y);
+	    result = TkpPostTearoffMenu(interp, menuPtr, x, y, index);
 	}
 	break;
     }
diff --git a/generic/tkMenu.h b/generic/tkMenu.h
index 9522db2..4cc3d1b 100644
--- a/generic/tkMenu.h
+++ b/generic/tkMenu.h
@@ -520,7 +520,7 @@ MODULE_SCOPE int	TkPostCommand(TkMenu *menuPtr);
 MODULE_SCOPE int	TkPostSubmenu(Tcl_Interp *interp, TkMenu *menuPtr,
 			    TkMenuEntry *mePtr);
 MODULE_SCOPE int	TkPostTearoffMenu(Tcl_Interp *interp, TkMenu *menuPtr,
-			    int x, int y);
+					   int x, int y);
 MODULE_SCOPE int	TkPreprocessMenu(TkMenu *menuPtr);
 MODULE_SCOPE void	TkRecomputeMenu(TkMenu *menuPtr);
 
@@ -543,7 +543,9 @@ MODULE_SCOPE void	TkpMenuInit(void);
 MODULE_SCOPE int	TkpMenuNewEntry(TkMenuEntry *mePtr);
 MODULE_SCOPE int	TkpNewMenu(TkMenu *menuPtr);
 MODULE_SCOPE int	TkpPostMenu(Tcl_Interp *interp, TkMenu *menuPtr,
-			    int x, int y);
+			    int x, int y, int index);
+MODULE_SCOPE int	TkpPostTearoffMenu(Tcl_Interp *interp, TkMenu *menuPtr,
+					   int x, int y, int index);
 MODULE_SCOPE void	TkpSetWindowMenuBar(Tk_Window tkwin, TkMenu *menuPtr);
 
 #endif /* _TKMENU */
diff --git a/generic/tkMenuDraw.c b/generic/tkMenuDraw.c
index 3abfc3c..bd00d38 100644
--- a/generic/tkMenuDraw.c
+++ b/generic/tkMenuDraw.c
@@ -807,9 +807,8 @@ TkMenuImageProc(
  *
  * TkPostTearoffMenu --
  *
- *	Posts a menu on the screen. Used to post tearoff menus. On Unix, all
- *	menus are posted this way. Adjusts the menu's position so that it fits
- *	on the screen, and maps and raises the menu.
+ *	Posts a tearoff menu on the screen. Adjusts the menu's position so
+ *	that it fits on the screen, and maps and raises the menu.
  *
  * Results:
  *	Returns a standard Tcl Error.
@@ -827,64 +826,7 @@ TkPostTearoffMenu(
     int x, int y)		/* The root X,Y coordinates where we are
 				 * posting */
 {
-    int vRootX, vRootY, vRootWidth, vRootHeight;
-    int result;
-
-    TkActivateMenuEntry(menuPtr, -1);
-    TkRecomputeMenu(menuPtr);
-    result = TkPostCommand(menuPtr);
-    if (result != TCL_OK) {
-    	return result;
-    }
-
-    /*
-     * The post commands could have deleted the menu, which means we are dead
-     * and should go away.
-     */
-
-    if (menuPtr->tkwin == NULL) {
-    	return TCL_OK;
-    }
-
-    /*
-     * Adjust the position of the menu if necessary to keep it visible on the
-     * screen. There are two special tricks to make this work right:
-     *
-     * 1. If a virtual root window manager is being used then the coordinates
-     *    are in the virtual root window of menuPtr's parent; since the menu
-     *    uses override-redirect mode it will be in the *real* root window for
-     *    the screen, so we have to map the coordinates from the virtual root
-     *    (if any) to the real root. Can't get the virtual root from the menu
-     *    itself (it will never be seen by the wm) so use its parent instead
-     *    (it would be better to have an an option that names a window to use
-     *    for this...).
-     * 2. The menu may not have been mapped yet, so its current size might be
-     *    the default 1x1. To compute how much space it needs, use its
-     *    requested size, not its actual size.
-     */
-
-    Tk_GetVRootGeometry(Tk_Parent(menuPtr->tkwin), &vRootX, &vRootY,
-	&vRootWidth, &vRootHeight);
-    vRootWidth -= Tk_ReqWidth(menuPtr->tkwin);
-    if (x > vRootX + vRootWidth) {
-	x = vRootX + vRootWidth;
-    }
-    if (x < vRootX) {
-	x = vRootX;
-    }
-    vRootHeight -= Tk_ReqHeight(menuPtr->tkwin);
-    if (y > vRootY + vRootHeight) {
-	y = vRootY + vRootHeight;
-    }
-    if (y < vRootY) {
-	y = vRootY;
-    }
-    Tk_MoveToplevelWindow(menuPtr->tkwin, x, y);
-    if (!Tk_IsMapped(menuPtr->tkwin)) {
-	Tk_MapWindow(menuPtr->tkwin);
-    }
-    TkWmRestackToplevel((TkWindow *) menuPtr->tkwin, Above, NULL);
-    return TCL_OK;
+    return TkpPostTearoffMenu(interp, menuPtr, x, y, -1);
 }
 
 /*
diff --git a/generic/tkPlace.c b/generic/tkPlace.c
index 2c06977..8eee5a1 100644
--- a/generic/tkPlace.c
+++ b/generic/tkPlace.c
@@ -1185,6 +1185,12 @@ PlaceRequestProc(
 
     if ((slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH))
 	    && (slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT))) {
+        /*
+         * Send a ConfigureNotify to indicate that the size change
+         * request was rejected.
+         */
+
+        TkDoConfigureNotify((TkWindow *)(slavePtr->tkwin));
 	return;
     }
     masterPtr = slavePtr->masterPtr;
diff --git a/generic/tkRectOval.c b/generic/tkRectOval.c
index daae092..359d3ef 100644
--- a/generic/tkRectOval.c
+++ b/generic/tkRectOval.c
@@ -515,8 +515,7 @@ ConfigureRectOval(
 	 * Mac OS X CG drawing needs access to the outline linewidth even for
 	 * fills (as linewidth controls antialiasing).
 	 */
-
-	gcValues.line_width = rectOvalPtr->outline.gc != None ?
+	gcValues.line_width = rectOvalPtr->outline.gc != NULL ?
 		rectOvalPtr->outline.gc->line_width : 0;
 	mask |= GCLineWidth;
 #endif
diff --git a/generic/tkScale.c b/generic/tkScale.c
index 6f61046..29f8722 100644
--- a/generic/tkScale.c
+++ b/generic/tkScale.c
@@ -611,7 +611,7 @@ ConfigureScale(
 		    TCL_GLOBAL_ONLY);
 	    if ((valuePtr != NULL) &&
 		    (Tcl_GetDoubleFromObj(NULL, valuePtr, &value) == TCL_OK)) {
-		scalePtr->value = TkRoundToResolution(scalePtr, value);
+		scalePtr->value = TkRoundValueToResolution(scalePtr, value);
 	    }
 	}
 
@@ -620,10 +620,10 @@ ConfigureScale(
 	 * orientation and creating GCs.
 	 */
 
-	scalePtr->fromValue = TkRoundToResolution(scalePtr,
+	scalePtr->fromValue = TkRoundValueToResolution(scalePtr,
 		scalePtr->fromValue);
-	scalePtr->toValue = TkRoundToResolution(scalePtr, scalePtr->toValue);
-	scalePtr->tickInterval = TkRoundToResolution(scalePtr,
+	scalePtr->toValue = TkRoundValueToResolution(scalePtr, scalePtr->toValue);
+	scalePtr->tickInterval = TkRoundIntervalToResolution(scalePtr,
 		scalePtr->tickInterval);
 
 	/*
@@ -1119,10 +1119,14 @@ TkEventuallyRedrawScale(
 /*
  *--------------------------------------------------------------
  *
- * TkRoundToResolution --
+ * TkRoundValueToResolution, TkRoundIntervalToResolution --
  *
  *	Round a given floating-point value to the nearest multiple of the
  *	scale's resolution.
+ *	TkRoundValueToResolution rounds an absolute value based on the from
+ *	value as a reference.
+ *	TkRoundIntervalToResolution rounds a relative value without
+ *	reference, i.e.	it rounds an interval.
  *
  * Results:
  *	The return value is the rounded result.
@@ -1134,7 +1138,16 @@ TkEventuallyRedrawScale(
  */
 
 double
-TkRoundToResolution(
+TkRoundValueToResolution(
+    TkScale *scalePtr,		/* Information about scale widget. */
+    double value)		/* Value to round. */
+{
+    return TkRoundIntervalToResolution(scalePtr, value - scalePtr->fromValue)
+            + scalePtr->fromValue;
+}
+
+double
+TkRoundIntervalToResolution(
     TkScale *scalePtr,		/* Information about scale widget. */
     double value)		/* Value to round. */
 {
@@ -1147,13 +1160,13 @@ TkRoundToResolution(
     rounded = scalePtr->resolution * tick;
     rem = value - rounded;
     if (rem < 0) {
-	if (rem <= -scalePtr->resolution/2) {
-	    rounded = (tick - 1.0) * scalePtr->resolution;
-	}
+        if (rem <= -scalePtr->resolution/2) {
+            rounded = (tick - 1.0) * scalePtr->resolution;
+        }
     } else {
-	if (rem >= scalePtr->resolution/2) {
-	    rounded = (tick + 1.0) * scalePtr->resolution;
-	}
+        if (rem >= scalePtr->resolution/2) {
+            rounded = (tick + 1.0) * scalePtr->resolution;
+        }
     }
     return rounded;
 }
@@ -1238,7 +1251,7 @@ ScaleVarProc(
 	resultStr = "can't assign non-numeric value to scale variable";
 	ScaleSetVariable(scalePtr);
     } else {
-	scalePtr->value = TkRoundToResolution(scalePtr, value);
+	scalePtr->value = TkRoundValueToResolution(scalePtr, value);
 
 	/*
 	 * This code is a bit tricky because it sets the scale's value before
@@ -1282,7 +1295,7 @@ TkScaleSetValue(
     int invokeCommand)		/* Non-zero means invoked -command option to
 				 * notify of new value, 0 means don't. */
 {
-    value = TkRoundToResolution(scalePtr, value);
+    value = TkRoundValueToResolution(scalePtr, value);
     if ((value < scalePtr->fromValue)
 	    ^ (scalePtr->toValue < scalePtr->fromValue)) {
 	value = scalePtr->fromValue;
@@ -1402,7 +1415,7 @@ TkScalePixelToValue(
     }
     value = scalePtr->fromValue +
 		value * (scalePtr->toValue - scalePtr->fromValue);
-    return TkRoundToResolution(scalePtr, value);
+    return TkRoundValueToResolution(scalePtr, value);
 }
 
 /*
diff --git a/generic/tkScale.h b/generic/tkScale.h
index 4f28738..d44e65b 100644
--- a/generic/tkScale.h
+++ b/generic/tkScale.h
@@ -219,7 +219,8 @@ typedef struct TkScale {
  */
 
 MODULE_SCOPE void	TkEventuallyRedrawScale(TkScale *scalePtr, int what);
-MODULE_SCOPE double	TkRoundToResolution(TkScale *scalePtr, double value);
+MODULE_SCOPE double	TkRoundValueToResolution(TkScale *scalePtr, double value);
+MODULE_SCOPE double	TkRoundIntervalToResolution(TkScale *scalePtr, double value);
 MODULE_SCOPE TkScale *	TkpCreateScale(Tk_Window tkwin);
 MODULE_SCOPE void	TkpDestroyScale(TkScale *scalePtr);
 MODULE_SCOPE void	TkpDisplayScale(ClientData clientData);
diff --git a/generic/tkSelect.c b/generic/tkSelect.c
index fcfd323..8ba0c5f 100644
--- a/generic/tkSelect.c
+++ b/generic/tkSelect.c
@@ -26,7 +26,7 @@ typedef struct {
     int charOffset;		/* The offset of the next char to retrieve. */
     int byteOffset;		/* The expected byte offset of the next
 				 * chunk. */
-    char buffer[TCL_UTF_MAX];	/* A buffer to hold part of a UTF character
+    char buffer[4];	/* A buffer to hold part of a UTF character
 				 * that is split across chunks. */
     char command[1];		/* Command to invoke. Actual space is
 				 * allocated as large as necessary. This must
diff --git a/generic/tkSquare.c b/generic/tkSquare.c
index 40d5e8f..e92c03c 100644
--- a/generic/tkSquare.c
+++ b/generic/tkSquare.c
@@ -335,7 +335,7 @@ SquareConfigure(
     Tk_SetWindowBackground(squarePtr->tkwin,
 	    Tk_3DBorderColor(bgBorder)->pixel);
     Tcl_GetBooleanFromObj(NULL, squarePtr->doubleBufferPtr, &doubleBuffer);
-    if ((squarePtr->gc == NULL) && (doubleBuffer)) {
+    if ((squarePtr->gc == NULL) && doubleBuffer) {
 	XGCValues gcValues;
 	gcValues.function = GXcopy;
 	gcValues.graphics_exposures = False;