* Merged 8.1 branch into the main trunk

1 files changed, 705 insertions, 150 deletions

diff --git a/generic/tkBitmap.c b/generic/tkBitmap.c
index e7a14b9..6facc97 100644
--- a/generic/tkBitmap.c
+++ b/generic/tkBitmap.c
@@ -6,12 +6,12 @@
  *	also avoids interactions with the X server.
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
- * Copyright (c) 1994-1996 Sun Microsystems, Inc.
+ * Copyright (c) 1994-1998 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: tkBitmap.c,v 1.6 1998/09/14 18:23:03 stanton Exp $
+ * RCS: @(#) $Id: tkBitmap.c,v 1.7 1999/04/16 01:51:10 stanton Exp $
  */
 
 #include "tkPort.h"
@@ -51,69 +51,180 @@
  * "nameTable".
  */
 
-typedef struct {
+typedef struct TkBitmap {
     Pixmap bitmap;		/* X identifier for bitmap.  None means this
 				 * bitmap was created by Tk_DefineBitmap
 				 * and it isn't currently in use. */
     int width, height;		/* Dimensions of bitmap. */
     Display *display;		/* Display for which bitmap is valid. */
-    int refCount;		/* Number of active uses of bitmap. */
-    Tcl_HashEntry *hashPtr;	/* Entry in nameTable for this structure
+    int resourceRefCount;	/* Number of active uses of this bitmap (each
+				 * active use corresponds to a call to
+				 * Tk_AllocBitmapFromObj or Tk_GetBitmap).
+				 * If this count is 0, then this TkBitmap
+				 * structure is no longer valid and it isn't
+				 * present in nameTable: it is being kept
+				 * around only because there are objects
+				 * referring to it.  The structure is freed
+				 * when resourceRefCount and objRefCount
+				 * are both 0. */
+    int objRefCount;		/* Number of Tcl_Obj's that reference
+				 * this structure. */
+    Tcl_HashEntry *nameHashPtr;	/* Entry in nameTable for this structure
+				 * (needed when deleting). */
+    Tcl_HashEntry *idHashPtr;	/* Entry in idTable for this structure
 				 * (needed when deleting). */
+    struct TkBitmap *nextPtr;	/* Points to the next TkBitmap structure with
+				 * the same name.  All bitmaps with the
+				 * same name (but different displays) are
+				 * chained together off a single entry in
+				 * nameTable. */
 } TkBitmap;
 
-/*
- * Hash table to map from a textual description of a bitmap to the
- * TkBitmap record for the bitmap, and key structure used in that
- * hash table:
+/* 
+ * Used in bitmapDataTable, stored in the TkDisplay structure, to map
+ * between in-core data about a bitmap to its TkBitmap structure.
  */
 
-static Tcl_HashTable nameTable;
 typedef struct {
-    Tk_Uid name;		/* Textual name for desired bitmap. */
-    Screen *screen;		/* Screen on which bitmap will be used. */
-} NameKey;
+    char *source;		/* Bitmap bits. */
+    int width, height;		/* Dimensions of bitmap. */
+} DataKey;
+
+typedef struct ThreadSpecificData {
+    int initialized;            /* 0 means table below needs initializing. */
+    Tcl_HashTable predefBitmapTable;
+                                /* Hash table created by Tk_DefineBitmap 
+				 * to map from a name to a collection 
+				 * of in-core data about a bitmap.  The 
+				 * table is indexed by the address of the 
+				 * data for the bitmap, and the entries
+				 * contain pointers to TkPredefBitmap 
+				 * structures. */
+} ThreadSpecificData;
+static Tcl_ThreadDataKey dataKey;
 
 /*
- * Hash table that maps from <display + bitmap id> to the TkBitmap structure
- * for the bitmap.  This table is used by Tk_FreeBitmap.
+ * Forward declarations for procedures defined in this file:
  */
 
-static Tcl_HashTable idTable;
-typedef struct {
-    Display *display;		/* Display for which bitmap was allocated. */
-    Pixmap pixmap;		/* X identifier for pixmap. */
-} IdKey;
+static void		BitmapInit _ANSI_ARGS_((TkDisplay *dispPtr));
+static void		DupBitmapObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
+			    Tcl_Obj *dupObjPtr));
+static void		FreeBitmap _ANSI_ARGS_((TkBitmap *bitmapPtr));
+static void		FreeBitmapObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
+static TkBitmap *	GetBitmap _ANSI_ARGS_((Tcl_Interp *interp,
+			    Tk_Window tkwin, CONST char *name));
+static TkBitmap *	GetBitmapFromObj _ANSI_ARGS_((Tk_Window tkwin,
+			    Tcl_Obj *objPtr));
+static void		InitBitmapObj _ANSI_ARGS_((Tcl_Obj *objPtr));
 
 /*
- * Hash table create by Tk_DefineBitmap to map from a name to a
- * collection of in-core data about a bitmap.  The table is
- * indexed by the address of the data for the bitmap, and the entries
- * contain pointers to TkPredefBitmap structures.
+ * The following structure defines the implementation of the "bitmap" Tcl
+ * object, which maps a string bitmap name to a TkBitmap object.  The
+ * ptr1 field of the Tcl_Obj points to a TkBitmap object.
  */
 
-Tcl_HashTable tkPredefBitmapTable;
-
+static Tcl_ObjType bitmapObjType = {
+    "bitmap",			/* name */
+    FreeBitmapObjProc,		/* freeIntRepProc */
+    DupBitmapObjProc,		/* dupIntRepProc */
+    NULL,			/* updateStringProc */
+    NULL			/* setFromAnyProc */
+};
+
 /*
- * Hash table used by Tk_GetBitmapFromData to map from a collection
- * of in-core data about a bitmap to a Tk_Uid giving an automatically-
- * generated name for the bitmap:
+ *----------------------------------------------------------------------
+ *
+ * Tk_AllocBitmapFromObj --
+ *
+ *	Given a Tcl_Obj *, map the value to a corresponding
+ *	Pixmap structure based on the tkwin given.
+ *
+ * Results:
+ *	The return value is the X identifer for the desired bitmap
+ *	(i.e. a Pixmap with a single plane), unless string couldn't be
+ *	parsed correctly.  In this case, None is returned and an error
+ *	message is left in the interp's result.  The caller should never
+ *	modify the bitmap that is returned, and should eventually call
+ *	Tk_FreeBitmapFromObj when the bitmap is no longer needed.
+ *
+ * Side effects:
+ *	The bitmap is added to an internal database with a reference count.
+ *	For each call to this procedure, there should eventually be a call
+ *	to Tk_FreeBitmapFromObj, so that the database can be cleaned up 
+ *	when bitmaps aren't needed anymore.
+ *
+ *----------------------------------------------------------------------
  */
 
-static Tcl_HashTable dataTable;
-typedef struct {
-    char *source;		/* Bitmap bits. */
-    int width, height;		/* Dimensions of bitmap. */
-} DataKey;
+Pixmap
+Tk_AllocBitmapFromObj(interp, tkwin, objPtr)
+    Tcl_Interp *interp;		/* Interp for error results. This may 
+				 * be NULL. */
+    Tk_Window tkwin;		/* Need the screen the bitmap is used on.*/
+    Tcl_Obj *objPtr;		/* Object describing bitmap; see manual
+				 * entry for legal syntax of string value. */
+{
+    TkBitmap *bitmapPtr;
 
-static int initialized = 0;	/* 0 means static structures haven't been
-				 * initialized yet. */
+    if (objPtr->typePtr != &bitmapObjType) {
+	InitBitmapObj(objPtr);
+    }
+    bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
 
-/*
- * Forward declarations for procedures defined in this file:
- */
+    /*
+     * If the object currently points to a TkBitmap, see if it's the
+     * one we want.  If so, increment its reference count and return.
+     */
+
+    if (bitmapPtr != NULL) {
+	if (bitmapPtr->resourceRefCount == 0) {
+	    /*
+	     * This is a stale reference: it refers to a TkBitmap that's
+	     * no longer in use.  Clear the reference.
+	     */
+
+	    FreeBitmapObjProc(objPtr);
+	    bitmapPtr = NULL;
+	} else if (Tk_Display(tkwin) == bitmapPtr->display) {
+	    bitmapPtr->resourceRefCount++;
+	    return bitmapPtr->bitmap;
+	}
+    }
+
+    /*
+     * The object didn't point to the TkBitmap that we wanted.  Search
+     * the list of TkBitmaps with the same name to see if one of the
+     * others is the right one.
+     */
+
+    if (bitmapPtr != NULL) {
+	TkBitmap *firstBitmapPtr =
+		(TkBitmap *) Tcl_GetHashValue(bitmapPtr->nameHashPtr);
+	FreeBitmapObjProc(objPtr);
+	for (bitmapPtr = firstBitmapPtr; bitmapPtr != NULL;
+		bitmapPtr = bitmapPtr->nextPtr) {
+	    if (Tk_Display(tkwin) == bitmapPtr->display) {
+		bitmapPtr->resourceRefCount++;
+		bitmapPtr->objRefCount++;
+		objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+		return bitmapPtr->bitmap;
+	    }
+	}
+    }
+
+    /*
+     * Still no luck.  Call GetBitmap to allocate a new TkBitmap object.
+     */
 
-static void		BitmapInit _ANSI_ARGS_((void));
+    bitmapPtr = GetBitmap(interp, tkwin, Tcl_GetString(objPtr));
+    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+    if (bitmapPtr == NULL) {
+	return None;
+    }
+    bitmapPtr->objRefCount++;
+    return bitmapPtr->bitmap;
+}
 
 /*
  *----------------------------------------------------------------------
@@ -127,7 +238,7 @@ static void		BitmapInit _ANSI_ARGS_((void));
  *	The return value is the X identifer for the desired bitmap
  *	(i.e. a Pixmap with a single plane), unless string couldn't be
  *	parsed correctly.  In this case, None is returned and an error
- *	message is left in interp->result.  The caller should never
+ *	message is left in the interp's result.  The caller should never
  *	modify the bitmap that is returned, and should eventually call
  *	Tk_FreeBitmap when the bitmap is no longer needed.
  *
@@ -145,30 +256,78 @@ Tk_GetBitmap(interp, tkwin, string)
     Tcl_Interp *interp;		/* Interpreter to use for error reporting,
 				 * this may be NULL. */
     Tk_Window tkwin;		/* Window in which bitmap will be used. */
-    Tk_Uid string;		/* Description of bitmap.  See manual entry
+    CONST char *string;		/* Description of bitmap.  See manual entry
 				 * for details on legal syntax. */
 {
-    NameKey nameKey;
-    IdKey idKey;
-    Tcl_HashEntry *nameHashPtr, *idHashPtr, *predefHashPtr;
-    register TkBitmap *bitmapPtr;
+    TkBitmap *bitmapPtr = GetBitmap(interp, tkwin, string);
+    if (bitmapPtr == NULL) {
+	return None;
+    }
+    return bitmapPtr->bitmap;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetBitmap --
+ *
+ *	Given a string describing a bitmap, locate (or create if necessary)
+ *	a bitmap that fits the description. This routine returns the
+ *	internal data structure for the bitmap. This avoids extra
+ *	hash table lookups in Tk_AllocBitmapFromObj.
+ *
+ * Results:
+ *	The return value is the X identifer for the desired bitmap
+ *	(i.e. a Pixmap with a single plane), unless string couldn't be
+ *	parsed correctly.  In this case, None is returned and an error
+ *	message is left in the interp's result.  The caller should never
+ *	modify the bitmap that is returned, and should eventually call
+ *	Tk_FreeBitmap when the bitmap is no longer needed.
+ *
+ * Side effects:
+ *	The bitmap is added to an internal database with a reference count.
+ *	For each call to this procedure, there should eventually be a call
+ *	to Tk_FreeBitmap or Tk_FreeBitmapFromObj, so that the database can
+ *	be cleaned up when bitmaps aren't needed anymore.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static TkBitmap *
+GetBitmap(interp, tkwin, string)
+    Tcl_Interp *interp;		/* Interpreter to use for error reporting,
+				 * this may be NULL. */
+    Tk_Window tkwin;		/* Window in which bitmap will be used. */
+    CONST char *string;		/* Description of bitmap.  See manual entry
+				 * for details on legal syntax. */
+{
+    Tcl_HashEntry *nameHashPtr, *predefHashPtr;
+    TkBitmap *bitmapPtr, *existingBitmapPtr;
     TkPredefBitmap *predefPtr;
     int new;
     Pixmap bitmap;
     int width, height;
     int dummy2;
+    TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-    if (!initialized) {
-	BitmapInit();
+    if (!dispPtr->bitmapInit) {
+	BitmapInit(dispPtr);
     }
 
-    nameKey.name = string;
-    nameKey.screen = Tk_Screen(tkwin);
-    nameHashPtr = Tcl_CreateHashEntry(&nameTable, (char *) &nameKey, &new);
+    nameHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapNameTable, string, &new);
     if (!new) {
-	bitmapPtr = (TkBitmap *) Tcl_GetHashValue(nameHashPtr);
-	bitmapPtr->refCount++;
-	return bitmapPtr->bitmap;
+	existingBitmapPtr = (TkBitmap *) Tcl_GetHashValue(nameHashPtr);
+	for (bitmapPtr = existingBitmapPtr; bitmapPtr != NULL;
+		bitmapPtr = bitmapPtr->nextPtr) {
+	    if (Tk_Display(tkwin) == bitmapPtr->display) {
+		bitmapPtr->resourceRefCount++;
+		return bitmapPtr;
+	    }
+	}
+    } else {
+	existingBitmapPtr = NULL;
     }
 
     /*
@@ -179,7 +338,7 @@ Tk_GetBitmap(interp, tkwin, string)
      * defined by a call to Tk_DefineBitmap.
      */
 
-    if (*string == '@') {
+    if (*string == '@') {	/* INTL: ISO char */
 	Tcl_DString buffer;
 	int result;
 
@@ -188,13 +347,19 @@ Tk_GetBitmap(interp, tkwin, string)
                     " safe interpreter", (char *) NULL);
             goto error;
         }
-        
-	string = Tcl_TranslateFileName(interp, string + 1, &buffer);
+
+	/*
+	 * Note that we need to cast away the CONST from the string because
+	 * Tcl_TranslateFileName is non const, even though it doesn't modify
+	 * the string.
+	 */
+
+	string = Tcl_TranslateFileName(interp, (char *) string + 1, &buffer);
 	if (string == NULL) {
 	    goto error;
 	}
 	result = TkReadBitmapFile(Tk_Display(tkwin),
-		RootWindowOfScreen(nameKey.screen), string,
+		RootWindowOfScreen(Tk_Screen(tkwin)), string,
 		(unsigned int *) &width, (unsigned int *) &height,
 		&bitmap, &dummy2, &dummy2);
 	if (result != BitmapSuccess) {
@@ -207,7 +372,8 @@ Tk_GetBitmap(interp, tkwin, string)
 	}
 	Tcl_DStringFree(&buffer);
     } else {
-	predefHashPtr = Tcl_FindHashEntry(&tkPredefBitmapTable, string);
+	predefHashPtr = Tcl_FindHashEntry(&tsdPtr->predefBitmapTable, 
+                string);
 	if (predefHashPtr == NULL) {
 	    /*
 	     * The following platform specific call allows the user to
@@ -236,7 +402,8 @@ Tk_GetBitmap(interp, tkwin, string)
 		}
 	    } else {
 		bitmap = XCreateBitmapFromData(Tk_Display(tkwin),
-		    RootWindowOfScreen(nameKey.screen), predefPtr->source,
+		    RootWindowOfScreen(Tk_Screen(tkwin)), 
+		    predefPtr->source,
 		    (unsigned) width, (unsigned) height);
 	    }
 	}
@@ -251,22 +418,24 @@ Tk_GetBitmap(interp, tkwin, string)
     bitmapPtr->width = width;
     bitmapPtr->height = height;
     bitmapPtr->display = Tk_Display(tkwin);
-    bitmapPtr->refCount = 1;
-    bitmapPtr->hashPtr = nameHashPtr;
-    idKey.display = bitmapPtr->display;
-    idKey.pixmap = bitmap;
-    idHashPtr = Tcl_CreateHashEntry(&idTable, (char *) &idKey,
-	    &new);
+    bitmapPtr->resourceRefCount = 1;
+    bitmapPtr->objRefCount = 0;
+    bitmapPtr->nameHashPtr = nameHashPtr;
+    bitmapPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapIdTable, 
+            (char *) bitmap, &new);
     if (!new) {
 	panic("bitmap already registered in Tk_GetBitmap");
     }
+    bitmapPtr->nextPtr = existingBitmapPtr;
     Tcl_SetHashValue(nameHashPtr, bitmapPtr);
-    Tcl_SetHashValue(idHashPtr, bitmapPtr);
-    return bitmapPtr->bitmap;
+    Tcl_SetHashValue(bitmapPtr->idHashPtr, bitmapPtr);
+    return bitmapPtr;
 
     error:
-    Tcl_DeleteHashEntry(nameHashPtr);
-    return None;
+    if (new) {
+	Tcl_DeleteHashEntry(nameHashPtr);
+    }
+    return NULL;
 }
 
 /*
@@ -280,7 +449,7 @@ Tk_GetBitmap(interp, tkwin, string)
  *
  * Results:
  *	A standard Tcl result.  If an error occurs then TCL_ERROR is
- *	returned and a message is left in interp->result.
+ *	returned and a message is left in the interp's result.
  *
  * Side effects:
  *	"Name" is entered into the bitmap table and may be used from
@@ -292,7 +461,7 @@ Tk_GetBitmap(interp, tkwin, string)
 int
 Tk_DefineBitmap(interp, name, source, width, height)
     Tcl_Interp *interp;		/* Interpreter to use for error reporting. */
-    Tk_Uid name;		/* Name to use for bitmap.  Must not already
+    CONST char *name;		/* Name to use for bitmap.  Must not already
 				 * be defined as a bitmap. */
     char *source;		/* Address of bits for bitmap. */
     int width;			/* Width of bitmap. */
@@ -301,12 +470,23 @@ Tk_DefineBitmap(interp, name, source, width, height)
     int new;
     Tcl_HashEntry *predefHashPtr;
     TkPredefBitmap *predefPtr;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+    /* 
+     * Initialize the Bitmap module if not initialized already for this
+     * thread.  Since the current TkDisplay structure cannot be 
+     * introspected from here, pass a NULL pointer to BitmapInit,
+     * which will know to initialize only the data in the 
+     * ThreadSpecificData structure for the current thread.
+     */ 
 
-    if (!initialized) {
-	BitmapInit();
+    if (!tsdPtr->initialized) {
+	BitmapInit((TkDisplay *) NULL);
     }
 
-    predefHashPtr = Tcl_CreateHashEntry(&tkPredefBitmapTable, name, &new);
+    predefHashPtr = Tcl_CreateHashEntry(&tsdPtr->predefBitmapTable, 
+            name, &new);
     if (!new) {
         Tcl_AppendResult(interp, "bitmap \"", name,
 		"\" is already defined", (char *) NULL);
@@ -338,29 +518,27 @@ Tk_DefineBitmap(interp, name, source, width, height)
  *--------------------------------------------------------------
  */
 
-Tk_Uid
+char *
 Tk_NameOfBitmap(display, bitmap)
     Display *display;			/* Display for which bitmap was
 					 * allocated. */
     Pixmap bitmap;			/* Bitmap whose name is wanted. */
 {
-    IdKey idKey;
     Tcl_HashEntry *idHashPtr;
     TkBitmap *bitmapPtr;
+    TkDisplay *dispPtr = TkGetDisplay(display);
 
-    if (!initialized) {
+    if (dispPtr == NULL || !dispPtr->bitmapInit) {
 	unknown:
 	panic("Tk_NameOfBitmap received unknown bitmap argument");
     }
 
-    idKey.display = display;
-    idKey.pixmap = bitmap;
-    idHashPtr = Tcl_FindHashEntry(&idTable, (char *) &idKey);
+    idHashPtr = Tcl_FindHashEntry(&dispPtr->bitmapIdTable, (char *) bitmap);
     if (idHashPtr == NULL) {
 	goto unknown;
     }
     bitmapPtr = (TkBitmap *) Tcl_GetHashValue(idHashPtr);
-    return ((NameKey *) bitmapPtr->hashPtr->key.words)->name;
+    return bitmapPtr->nameHashPtr->key.string;
 }
 
 /*
@@ -390,18 +568,16 @@ Tk_SizeOfBitmap(display, bitmap, widthPtr, heightPtr)
     int *widthPtr;			/* Store bitmap width here. */
     int *heightPtr;			/* Store bitmap height here. */
 {
-    IdKey idKey;
     Tcl_HashEntry *idHashPtr;
     TkBitmap *bitmapPtr;
+    TkDisplay *dispPtr = TkGetDisplay(display);
 
-    if (!initialized) {
+    if (!dispPtr->bitmapInit) {
 	unknownBitmap:
 	panic("Tk_SizeOfBitmap received unknown bitmap argument");
     }
 
-    idKey.display = display;
-    idKey.pixmap = bitmap;
-    idHashPtr = Tcl_FindHashEntry(&idTable, (char *) &idKey);
+    idHashPtr = Tcl_FindHashEntry(&dispPtr->bitmapIdTable, (char *) bitmap);
     if (idHashPtr == NULL) {
 	goto unknownBitmap;
     }
@@ -413,6 +589,56 @@ Tk_SizeOfBitmap(display, bitmap, widthPtr, heightPtr)
 /*
  *----------------------------------------------------------------------
  *
+ * FreeBitmap --
+ *
+ *	This procedure does all the work of releasing a bitmap allocated by
+ *	Tk_GetBitmap or TkGetBitmapFromData.  It is invoked by both
+ *	Tk_FreeBitmap and Tk_FreeBitmapFromObj
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The reference count associated with bitmap is decremented, and
+ *	it is officially deallocated if no-one is using it anymore.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+FreeBitmap(bitmapPtr)
+    TkBitmap *bitmapPtr;			/* Bitmap to be released. */
+{
+    TkBitmap *prevPtr;
+
+    bitmapPtr->resourceRefCount--;
+    if (bitmapPtr->resourceRefCount > 0) {
+	return;
+    }
+
+    Tk_FreePixmap(bitmapPtr->display, bitmapPtr->bitmap);
+    Tcl_DeleteHashEntry(bitmapPtr->idHashPtr);
+    prevPtr = (TkBitmap *) Tcl_GetHashValue(bitmapPtr->nameHashPtr);
+    if (prevPtr == bitmapPtr) {
+	if (bitmapPtr->nextPtr == NULL) {
+	    Tcl_DeleteHashEntry(bitmapPtr->nameHashPtr);
+	} else {
+	    Tcl_SetHashValue(bitmapPtr->nameHashPtr, bitmapPtr->nextPtr);
+	}
+    } else {
+	while (prevPtr->nextPtr != bitmapPtr) {
+	    prevPtr = prevPtr->nextPtr;
+	}
+	prevPtr->nextPtr = bitmapPtr->nextPtr;
+    }
+    if (bitmapPtr->objRefCount == 0) {
+	ckfree((char *) bitmapPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tk_FreeBitmap --
  *
  *	This procedure is called to release a bitmap allocated by
@@ -435,26 +661,115 @@ Tk_FreeBitmap(display, bitmap)
     Pixmap bitmap;			/* Bitmap to be released. */
 {
     Tcl_HashEntry *idHashPtr;
-    register TkBitmap *bitmapPtr;
-    IdKey idKey;
+    TkDisplay *dispPtr = TkGetDisplay(display);
 
-    if (!initialized) {
+    if (!dispPtr->bitmapInit) {
 	panic("Tk_FreeBitmap called before Tk_GetBitmap");
     }
 
-    idKey.display = display;
-    idKey.pixmap = bitmap;
-    idHashPtr = Tcl_FindHashEntry(&idTable, (char *) &idKey);
+    idHashPtr = Tcl_FindHashEntry(&dispPtr->bitmapIdTable, (char *) bitmap);
     if (idHashPtr == NULL) {
 	panic("Tk_FreeBitmap received unknown bitmap argument");
     }
-    bitmapPtr = (TkBitmap *) Tcl_GetHashValue(idHashPtr);
-    bitmapPtr->refCount--;
-    if (bitmapPtr->refCount == 0) {
-	Tk_FreePixmap(bitmapPtr->display, bitmapPtr->bitmap);
-	Tcl_DeleteHashEntry(idHashPtr);
-	Tcl_DeleteHashEntry(bitmapPtr->hashPtr);
-	ckfree((char *) bitmapPtr);
+    FreeBitmap((TkBitmap *) Tcl_GetHashValue(idHashPtr));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_FreeBitmapFromObj --
+ *
+ *	This procedure is called to release a bitmap allocated by
+ *	Tk_AllocBitmapFromObj. It does not throw away the Tcl_Obj *;
+ *	it only gets rid of the hash table entry for this bitmap
+ *	and clears the cached value that is normally stored in the object.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The reference count associated with the bitmap represented by
+ *	objPtr is decremented, and the bitmap is released to X if there are 
+ *	no remaining uses for it.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tk_FreeBitmapFromObj(tkwin, objPtr)
+    Tk_Window tkwin;		/* The window this bitmap lives in. Needed
+				 * for the display value. */
+    Tcl_Obj *objPtr;		/* The Tcl_Obj * to be freed. */
+{
+    FreeBitmap(GetBitmapFromObj(tkwin, objPtr));
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FreeBitmapObjProc -- 
+ *
+ *	This proc is called to release an object reference to a bitmap.
+ *	Called when the object's internal rep is released or when
+ *	the cached bitmapPtr needs to be changed.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object reference count is decremented. When both it
+ *	and the hash ref count go to zero, the color's resources
+ *	are released.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+FreeBitmapObjProc(objPtr)
+    Tcl_Obj *objPtr;		/* The object we are releasing. */
+{
+    TkBitmap *bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
+
+    if (bitmapPtr != NULL) {
+	bitmapPtr->objRefCount--;
+	if ((bitmapPtr->objRefCount == 0)
+		&& (bitmapPtr->resourceRefCount == 0)) {
+	    ckfree((char *) bitmapPtr);
+	}
+	objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+    }
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * DupBitmapObjProc -- 
+ *
+ *	When a cached bitmap object is duplicated, this is called to
+ *	update the internal reps.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The color's objRefCount is incremented and the internal rep
+ *	of the copy is set to point to it.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+DupBitmapObjProc(srcObjPtr, dupObjPtr)
+    Tcl_Obj *srcObjPtr;		/* The object we are copying from. */
+    Tcl_Obj *dupObjPtr;		/* The object we are copying to. */
+{
+    TkBitmap *bitmapPtr = (TkBitmap *) srcObjPtr->internalRep.twoPtrValue.ptr1;
+    
+    dupObjPtr->typePtr = srcObjPtr->typePtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+
+    if (bitmapPtr != NULL) {
+	bitmapPtr->objRefCount++;
     }
 }
 
@@ -471,7 +786,7 @@ Tk_FreeBitmap(display, bitmap)
  *	The return value is the X identifer for the desired bitmap
  *	(a one-plane Pixmap), unless it couldn't be created properly.
  *	In this case, None is returned and an error message is left in
- *	interp->result.  The caller should never modify the bitmap that
+ *	the interp's result.  The caller should never modify the bitmap that
  *	is returned, and should eventually call Tk_FreeBitmap when the
  *	bitmap is no longer needed.
  *
@@ -494,25 +809,24 @@ Tk_GetBitmapFromData(interp, tkwin, source, width, height)
 {
     DataKey nameKey;
     Tcl_HashEntry *dataHashPtr;
-    Tk_Uid name;
     int new;
-    char string[20];
-    static int autoNumber = 0;
+    char string[16 + TCL_INTEGER_SPACE];
+    char *name;
+    TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
 
-    if (!initialized) {
-	BitmapInit();
-    }
+    BitmapInit(dispPtr);
 
     nameKey.source = source;
     nameKey.width = width;
     nameKey.height = height;
-    dataHashPtr = Tcl_CreateHashEntry(&dataTable, (char *) &nameKey, &new);
+    dataHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapDataTable, 
+            (char *) &nameKey, &new);
     if (!new) {
-	name = (Tk_Uid) Tcl_GetHashValue(dataHashPtr);
+	name = (char *) Tcl_GetHashValue(dataHashPtr);
     } else {
-	autoNumber++;
-	sprintf(string, "_tk%d", autoNumber);
-	name = Tk_GetUid(string);
+	dispPtr->bitmapAutoNumber++;
+	sprintf(string, "_tk%d", dispPtr->bitmapAutoNumber);
+	name = string;
 	Tcl_SetHashValue(dataHashPtr, name);
 	if (Tk_DefineBitmap(interp, name, source, width, height) != TCL_OK) {
 	    Tcl_DeleteHashEntry(dataHashPtr);
@@ -525,63 +839,226 @@ Tk_GetBitmapFromData(interp, tkwin, source, width, height)
 /*
  *----------------------------------------------------------------------
  *
- * BitmapInit --
+ * Tk_GetBitmapFromObj --
+ *
+ *	Returns the bitmap referred to by a Tcl object.  The bitmap must
+ *	already have been allocated via a call to Tk_AllocBitmapFromObj
+ *	or Tk_GetBitmap.
+ *
+ * Results:
+ *	Returns the Pixmap that matches the tkwin and the string rep
+ *	of objPtr.
  *
- *	Initialize the structures used for bitmap management.
+ * Side effects:
+ *	If the object is not already a bitmap, the conversion will free
+ *	any old internal representation. 
+ *
+ *----------------------------------------------------------------------
+ */
+
+Pixmap
+Tk_GetBitmapFromObj(tkwin, objPtr)
+    Tk_Window tkwin;
+    Tcl_Obj *objPtr;		/* The object from which to get pixels. */
+{
+    TkBitmap *bitmapPtr = GetBitmapFromObj(tkwin, objPtr);
+    return bitmapPtr->bitmap;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetBitmapFromObj --
+ *
+ *	Returns the bitmap referred to by a Tcl object.  The bitmap must
+ *	already have been allocated via a call to Tk_AllocBitmapFromObj
+ *	or Tk_GetBitmap.
+ *
+ * Results:
+ *	Returns the TkBitmap * that matches the tkwin and the string rep
+ *	of  objPtr.
+ *
+ * Side effects:
+ *	If the object is not already a bitmap, the conversion will free
+ *	any old internal representation. 
+ *
+ *----------------------------------------------------------------------
+ */
+
+static TkBitmap *
+GetBitmapFromObj(tkwin, objPtr)
+    Tk_Window tkwin;		/* Window in which the bitmap will be used. */
+    Tcl_Obj *objPtr;		/* The object that describes the desired
+				 * bitmap. */
+{
+    TkBitmap *bitmapPtr; 
+    Tcl_HashEntry *hashPtr;
+    TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
+
+    if (objPtr->typePtr != &bitmapObjType) {
+	InitBitmapObj(objPtr);
+    }
+
+    bitmapPtr = (TkBitmap *) objPtr->internalRep.twoPtrValue.ptr1;
+    if (bitmapPtr != NULL) { 
+	if ((bitmapPtr->resourceRefCount > 0)
+		&& (Tk_Display(tkwin) == bitmapPtr->display)) {
+	    return bitmapPtr;
+	}
+	hashPtr = bitmapPtr->nameHashPtr;
+	FreeBitmapObjProc(objPtr);
+    } else {
+	hashPtr = Tcl_FindHashEntry(&dispPtr->bitmapNameTable, 
+                Tcl_GetString(objPtr));
+	if (hashPtr == NULL) {
+	    goto error;
+	}
+    } 
+
+    /*
+     * At this point we've got a hash table entry, off of which hang
+     * one or more TkBitmap structures.  See if any of them will work.
+     */
+
+    for (bitmapPtr = (TkBitmap *) Tcl_GetHashValue(hashPtr);
+	    bitmapPtr != NULL;  bitmapPtr = bitmapPtr->nextPtr) {
+	if (Tk_Display(tkwin) == bitmapPtr->display) {
+	    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) bitmapPtr;
+	    bitmapPtr->objRefCount++;
+	    return bitmapPtr;
+	}
+    }
+
+    error:
+    panic("GetBitmapFromObj called with non-existent bitmap!");
+    /*
+     * The following code isn't reached; it's just there to please compilers.
+     */
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * InitBitmapObj --
+ *
+ *	Bookeeping procedure to change an objPtr to a bitmap type.
  *
  * Results:
  *	None.
  *
  * Side effects:
+ *	The old internal rep of the object is freed. The internal
+ *	rep is cleared. The final form of the object is set
+ *	by either Tk_AllocBitmapFromObj or GetBitmapFromObj.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+InitBitmapObj(objPtr)
+    Tcl_Obj *objPtr;		/* The object to convert. */
+{
+    Tcl_ObjType *typePtr;
+
+    /*
+     * Free the old internalRep before setting the new one. 
+     */
+
+    Tcl_GetString(objPtr);
+    typePtr = objPtr->typePtr;
+    if ((typePtr != NULL) && (typePtr->freeIntRepProc != NULL)) {
+	(*typePtr->freeIntRepProc)(objPtr);
+    }
+    objPtr->typePtr = &bitmapObjType;
+    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * BitmapInit --
+ *	Initializes hash tables used by this module.  Initializes 
+ *      tables stored in TkDisplay structure if a TkDisplay pointer
+ *      is passed in.  Iinitializes the thread-local data
+ *      in the current thread's ThreadSpecificData structure.
+ *
+ * Results:
+ *      None.
+ *  
+ * Side effects:
  *	Read the code.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-BitmapInit()
+BitmapInit(dispPtr)
+    TkDisplay *dispPtr;         /* TkDisplay structure encapsulating 
+				 * thread-specific data used by this 
+				 * module, or NULL if unavailable. */
 {
     Tcl_Interp *dummy;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+    /* 
+     * First initialize the data in the ThreadSpecificData strucuture,
+     * if needed.
+     */
 
-    dummy = Tcl_CreateInterp();
-    initialized = 1;
-    Tcl_InitHashTable(&nameTable, sizeof(NameKey)/sizeof(int));
-    Tcl_InitHashTable(&dataTable, sizeof(DataKey)/sizeof(int));
-    Tcl_InitHashTable(&tkPredefBitmapTable, TCL_ONE_WORD_KEYS);
+    if (!tsdPtr->initialized) {
+	tsdPtr->initialized = 1;
+        dummy = Tcl_CreateInterp();
+	Tcl_InitHashTable(&tsdPtr->predefBitmapTable, TCL_STRING_KEYS);
+
+        Tk_DefineBitmap(dummy, "error", (char *) error_bits,
+		error_width, error_height);
+        Tk_DefineBitmap(dummy, "gray75", (char *) gray75_bits,
+                gray75_width, gray75_height);
+        Tk_DefineBitmap(dummy, "gray50", (char *) gray50_bits,
+                gray50_width, gray50_height);
+        Tk_DefineBitmap(dummy, "gray25", (char *) gray25_bits,
+                gray25_width, gray25_height);
+        Tk_DefineBitmap(dummy, "gray12", (char *) gray12_bits,
+                gray12_width, gray12_height);
+        Tk_DefineBitmap(dummy, "hourglass", (char *) hourglass_bits,
+                hourglass_width, hourglass_height);
+        Tk_DefineBitmap(dummy, "info", (char *) info_bits,
+	        info_width, info_height);
+        Tk_DefineBitmap(dummy, "questhead", (char *) questhead_bits,
+	        questhead_width, questhead_height);
+        Tk_DefineBitmap(dummy, "question", (char *) question_bits,
+	        question_width, question_height);
+        Tk_DefineBitmap(dummy, "warning", (char *) warning_bits,
+	        warning_width, warning_height);
+
+        TkpDefineNativeBitmaps();
+        Tcl_DeleteInterp(dummy);
+    }
 
     /*
-     * The call below is tricky:  can't use sizeof(IdKey) because it
-     * gets padded with extra unpredictable bytes on some 64-bit
-     * machines.
+     * Was a valid TkDisplay pointer passed?  If so, initialize the
+     * Bitmap module tables in that structure.
      */
 
-    Tcl_InitHashTable(&idTable, (sizeof(Display *) + sizeof(Pixmap))
-	    /sizeof(int));
-
-    Tk_DefineBitmap(dummy, Tk_GetUid("error"), (char *) error_bits,
-	    error_width, error_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("gray75"), (char *) gray75_bits,
-	    gray75_width, gray75_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("gray50"), (char *) gray50_bits,
-	    gray50_width, gray50_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("gray25"), (char *) gray25_bits,
-	    gray25_width, gray25_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("gray12"), (char *) gray12_bits,
-	    gray12_width, gray12_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("hourglass"), (char *) hourglass_bits,
-	    hourglass_width, hourglass_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("info"), (char *) info_bits,
-	    info_width, info_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("questhead"), (char *) questhead_bits,
-	    questhead_width, questhead_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("question"), (char *) question_bits,
-	    question_width, question_height);
-    Tk_DefineBitmap(dummy, Tk_GetUid("warning"), (char *) warning_bits,
-	    warning_width, warning_height);
-
-    TkpDefineNativeBitmaps();
-
-    Tcl_DeleteInterp(dummy);
+    if (dispPtr != NULL) {
+        dispPtr->bitmapInit = 1;
+	Tcl_InitHashTable(&dispPtr->bitmapNameTable, TCL_STRING_KEYS);
+	Tcl_InitHashTable(&dispPtr->bitmapDataTable, sizeof(DataKey)
+                /sizeof(int));
+
+	/*
+	 * The call below is tricky:  can't use sizeof(IdKey) because it
+	 * gets padded with extra unpredictable bytes on some 64-bit
+	 * machines.
+	 */
+
+	/*
+	 * The comment above doesn't make sense...
+	 */
+	Tcl_InitHashTable(&dispPtr->bitmapIdTable, TCL_ONE_WORD_KEYS);
+    }
 }
 
 /*
@@ -627,4 +1104,82 @@ TkReadBitmapFile(display, d, filename, width_return, height_return,
 
     ckfree(data);
     return BitmapSuccess;
+  }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkDebugBitmap --
+ *
+ *	This procedure returns debugging information about a bitmap.
+ *
+ * Results:
+ *	The return value is a list with one sublist for each TkBitmap
+ *	corresponding to "name".  Each sublist has two elements that
+ *	contain the resourceRefCount and objRefCount fields from the
+ *	TkBitmap structure.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Obj *
+TkDebugBitmap(tkwin, name)
+    Tk_Window tkwin;		/* The window in which the bitmap will be
+				 * used (not currently used). */
+    char *name;			/* Name of the desired color. */
+{
+    TkBitmap *bitmapPtr;
+    Tcl_HashEntry *hashPtr;
+    Tcl_Obj *resultPtr, *objPtr;
+    TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
+
+    resultPtr = Tcl_NewObj();
+    hashPtr = Tcl_FindHashEntry(&dispPtr->bitmapNameTable, name);
+    if (hashPtr != NULL) {
+	bitmapPtr = (TkBitmap *) Tcl_GetHashValue(hashPtr);
+	if (bitmapPtr == NULL) {
+	    panic("TkDebugBitmap found empty hash table entry");
+	}
+	for ( ; (bitmapPtr != NULL); bitmapPtr = bitmapPtr->nextPtr) {
+	    objPtr = Tcl_NewObj();
+	    Tcl_ListObjAppendElement(NULL, objPtr,
+		    Tcl_NewIntObj(bitmapPtr->resourceRefCount));
+	    Tcl_ListObjAppendElement(NULL, objPtr,
+		    Tcl_NewIntObj(bitmapPtr->objRefCount)); 
+	    Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
+	}
+    }
+    return resultPtr;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkGetBitmapPredefTable --
+ *      This procedure is used by tkMacBitmap.c to access the thread-
+ *      specific predefBitmap table that maps from the names of 
+ *      the predefined bitmaps to data associated with those 
+ *      bitmaps.  It is required because the table is allocated in 
+ *      thread-local storage and is not visible outside this file.
+
+ * Results:
+ *      Returns a pointer to the predefined bitmap hash table for 
+ *      the current thread.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+Tcl_HashTable *
+TkGetBitmapPredefTable()
+{
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+    return &tsdPtr->predefBitmapTable;
 }