Index: tkWinWm.c
===================================================================
RCS file: /cvsroot/tk/win/tkWinWm.c,v
retrieving revision 1.27
diff -c -r1.27 tkWinWm.c
*** tkWinWm.c	2000/11/03 01:22:17	1.27
--- tkWinWm.c	2000/11/13 19:12:49
***************
*** 53,58 ****
--- 53,116 ----
  #define HANDLER_SIZE(cmdLength) \
      ((unsigned) (sizeof(ProtocolHandler) - 3 + cmdLength))
  
+ /* 
+  * These next four structs represent how the icon information is stored
+  * in an ICO file, and in an icon resource.
+  */
+ typedef struct {
+ 	UINT			Width, Height, Colors; /*  Width, Height and bpp */
+ 	LPBYTE			lpBits;                /*  ptr to DIB bits */
+ 	DWORD			dwNumBytes;            /*  how many bytes? */
+ 	LPBITMAPINFO	lpbi;                          /*  ptr to header */
+ 	LPBYTE			lpXOR;                 /*  ptr to XOR image bits */
+ 	LPBYTE			lpAND;                 /*  ptr to AND image bits */
+ 	HICON			hIcon;                 /*  DAS ICON */
+ } ICONIMAGE, *LPICONIMAGE;
+ typedef struct {
+ 	BOOL		bHasChanged;                     /*  Has image changed? */
+ 	TCHAR		szOriginalICOFileName[MAX_PATH]; /*  Original name */
+ 	TCHAR		szOriginalDLLFileName[MAX_PATH]; /*  Original name */
+ 	int		nNumImages;                      /*  How many images? */
+ 	ICONIMAGE	IconImages[1];                   /*  Image entries */
+ } ICONRESOURCE, *LPICONRESOURCE;
+ typedef struct {
+ 	BYTE	bWidth;               /*  Width of the image */
+ 	BYTE	bHeight;              /*  Height of the image (times 2) */
+ 	BYTE	bColorCount;          /*  Number of colors in image (0 if >=8bpp) */
+ 	BYTE	bReserved;            /*  Reserved */
+ 	WORD	wPlanes;              /*  Color Planes */
+ 	WORD	wBitCount;            /*  Bits per pixel */
+ 	DWORD	dwBytesInRes;         /*  how many bytes in this resource? */
+ 	DWORD	dwImageOffset;        /*  where in the file is this image */
+ } ICONDIRENTRY, *LPICONDIRENTRY;
+ typedef struct {
+ 	WORD			idReserved;   /*  Reserved */
+ 	WORD			idType;       /*  resource type (1 for icons) */
+ 	WORD			idCount;      /*  how many images? */
+ 	ICONDIRENTRY	idEntries[1];         /*  the entries for each image */
+ } ICONDIR, *LPICONDIR;
+ 
+ /* 
+  * A pointer to one of these strucutures is associated with each
+  * toplevel.  This allows us to free up all memory associated with icon
+  * resources when a window is deleted or if the window's icon is
+  * changed.  They are simply reference counted according to:
+  * 
+  * (i) how many WmInfo structures point to this object
+  * (ii) whether the ThreadSpecificData defined in this file contains
+  * a pointer to this object.
+  * 
+  * The former count is for windows whose icons are individually
+  * set, and the latter is for the global default icon choice.
+  */
+ typedef struct WinIconInstance {
+     int refCount;		/* Number of instances that share this
+ 				  * data structure. */
+     LPICONRESOURCE iconResource; /* Pointer to icon resource data for image. */
+ } WinIconInstance;
+ 
+ typedef struct WinIconInstance *WinIconPtr;
+ 
  /*
   * A data structure of the following type holds window-manager-related
   * information for each top-level window in an application.

***************
*** 165,170 ****
--- 223,230 ----
  				* property, or NULL. */
      int flags;			/* Miscellaneous flags, defined below. */
      int numTransients;		/* number of transients on this window */
+     WinIconPtr iconPtr;     /* pointer to titlebar icon structure for
+                                  * this window, or NULL. */
      struct TkWmInfo *nextPtr;	/* Next in list of all top-level windows. */
  } WmInfo;
  
***************
*** 256,261 ****
--- 316,323 ----
  				  * been initialized. */
      int firstWindow;             /* Flag, cleared when the first window
  				  * is mapped in a non-iconic state. */
+     WinIconPtr iconPtr;   /* IconPtr being used as default for all
+                                   * toplevels, or NULL. */
  } ThreadSpecificData;
  static Tcl_ThreadDataKey dataKey;
  
***************
*** 269,275 ****
  				* been initialized. */
  TCL_DECLARE_MUTEX(winWmMutex)
  
- 
  /*
   * Forward declarations for procedures defined in this file:
   */
--- 331,336 ----
***************
*** 307,318 ****
  			    WPARAM wParam, LPARAM lParam));
  static void		WmWaitVisibilityProc _ANSI_ARGS_((
  			    ClientData clientData, XEvent *eventPtr));
  
  /*
   *----------------------------------------------------------------------
   *
!  * InitWm --
   *
   *	This routine creates the Wm toplevel decorative frame class.
   *
   * Results:
--- 368,635 ----
  			    WPARAM wParam, LPARAM lParam));
  static void		WmWaitVisibilityProc _ANSI_ARGS_((
  			    ClientData clientData, XEvent *eventPtr));
+ static LPICONRESOURCE   ReadIconFromICOFile _ANSI_ARGS_((
+ 			    Tcl_Interp *interp, LPCTSTR fileName));
+ static WinIconPtr       ReadIconFromFile _ANSI_ARGS_((
+ 			    Tcl_Interp *interp, char *fileName));
+ static int     		ReadICOHeader _ANSI_ARGS_((HANDLE hFile));
+ static BOOL 		AdjustIconImagePointers _ANSI_ARGS_((LPICONIMAGE lpImage));
+ static HICON 		MakeIconFromResource _ANSI_ARGS_((LPICONIMAGE lpIcon));
+ static HICON 		GetIcon _ANSI_ARGS_((WinIconPtr titlebaricon, 
+ 			    int icon_size));
+ static int 		WinSetIcon _ANSI_ARGS_((Tcl_Interp *interp, char *fileName, 
+ 			    Tk_Window tkw));
+ static void 		FreeIcon _ANSI_ARGS_((LPICONRESOURCE lpIR));
+ static void  		DecrIconRefCount _ANSI_ARGS_((WinIconPtr titlebaricon));
+ 
+ /* Used in BytesPerLine */
+ #define WIDTHBYTES(bits)      ((((bits) + 31)>>5)<<2)
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * DIBNumColors --
+  *
+  *	Calculates the number of entries in the color table, given by 
+  *	LPSTR lpbi - pointer to the CF_DIB memory block.  Used by
+  *	titlebar icon code.
+  *
+  * Results:
+  *	
+  *      WORD - Number of entries in the color table.
+  *
+  * Side effects: None.
+  *	
+  *
+  *----------------------------------------------------------------------
+  */
+ static WORD DIBNumColors( LPSTR lpbi )
+ {
+     WORD wBitCount;
+     DWORD dwClrUsed;
+ 
+     dwClrUsed = ((LPBITMAPINFOHEADER) lpbi)->biClrUsed;
+ 
+     if (dwClrUsed)
+ 	return (WORD) dwClrUsed;
+ 
+     wBitCount = ((LPBITMAPINFOHEADER) lpbi)->biBitCount;
+ 

+     switch (wBitCount)
+     {
+ 	case 1: return 2;
+ 	case 4: return 16;
+ 	case 8:	return 256;
+ 	default:return 0;
+     }
+ }
  
  /*
   *----------------------------------------------------------------------
   *
!  * PaletteSize --
!  *
!  *	Calculates the number of bytes in the color table, as given by
!  *	LPSTR lpbi - pointer to the CF_DIB memory block.  Used by
!  *	titlebar icon code.
!  *
!  * Results:
!  *	number of bytes in the color table
!  *
!  * Side effects: None.
!  *	
!  *
!  *----------------------------------------------------------------------
!  */
! static WORD PaletteSize( LPSTR lpbi )
! {
!     return ((WORD)( DIBNumColors( lpbi ) * sizeof( RGBQUAD )) );
! }
! 
! /*
!  *----------------------------------------------------------------------
!  *
!  * FindDIBits --
!  *
!  *	Locate the image bits in a CF_DIB format DIB, as given by
!  *	LPSTR lpbi - pointer to the CF_DIB memory block.  Used by
!  *	titlebar icon code.
!  *
!  * Results:
!  *	pointer to the image bits
!  *
!  * Side effects: None
!  *	
!  *
!  *----------------------------------------------------------------------
!  */
! static LPSTR FindDIBBits( LPSTR lpbi )
! {
!    return ( lpbi + *(LPDWORD)lpbi + PaletteSize( lpbi ) );
! }
! 
! /*
!  *----------------------------------------------------------------------
!  *
!  * BytesPerLine --
!  *
!  *	Calculates the number of bytes in one scan line, as given by
!  *	LPBITMAPINFOHEADER lpBMIH - pointer to the BITMAPINFOHEADER
!  *	that begins the CF_DIB block.  Used by titlebar icon code.
!  *
!  * Results:
!  *	number of bytes in one scan line (DWORD aligned)
!  *
!  * Side effects: None
!  *	
!  *
!  *----------------------------------------------------------------------
!  */
! static DWORD BytesPerLine( LPBITMAPINFOHEADER lpBMIH )
! {
!     return WIDTHBYTES(lpBMIH->biWidth * lpBMIH->biPlanes * lpBMIH->biBitCount);
! }
! 
! /*
!  *----------------------------------------------------------------------
!  *
!  * AdjustIconImagePointers --
!  *
!  *	Adjusts internal pointers in icon resource struct, as given
!  *	by LPICONIMAGE lpImage - the resource to handle.  Used by
!  *	titlebar icon code.
!  *
!  * Results:
!  *	BOOL - TRUE for success, FALSE for failure
!  *
!  * Side effects:
!  *	
!  *
!  *----------------------------------------------------------------------
!  */
! BOOL AdjustIconImagePointers( LPICONIMAGE lpImage )
! {
!     /*  Sanity check */
!     if (lpImage==NULL)
! 	return FALSE;
!     /*  BITMAPINFO is at beginning of bits */
!     lpImage->lpbi = (LPBITMAPINFO)lpImage->lpBits;
!     /*  Width - simple enough */
!     lpImage->Width = lpImage->lpbi->bmiHeader.biWidth;
!     /*  Icons are stored in funky format where height is doubled - account for it */
!     lpImage->Height = (lpImage->lpbi->bmiHeader.biHeight)/2;
!     /*  How many colors? */
!     lpImage->Colors = lpImage->lpbi->bmiHeader.biPlanes * lpImage->lpbi->bmiHeader.biBitCount;
!     /*  XOR bits follow the header and color table */
!     lpImage->lpXOR = (LPBYTE)FindDIBBits(((LPSTR)lpImage->lpbi));
!     /*  AND bits follow the XOR bits */

!     lpImage->lpAND = lpImage->lpXOR + (lpImage->Height*BytesPerLine((LPBITMAPINFOHEADER)(lpImage->lpbi)));
!     return TRUE;
! }
! 
! /*
!  *----------------------------------------------------------------------
!  *
!  * MakeIconFromResource --
!  *
!  *	
!  *
!  * Results:
!  *	
!  *
!  * Side effects:
!  *	
!  *
!  *----------------------------------------------------------------------
!  */
! static HICON MakeIconFromResource( LPICONIMAGE lpIcon ){
!     HICON hIcon ;
!     static FARPROC pfnCreateIconFromResourceEx=NULL;
!     static int initinfo=0;
!     /*  Sanity Check */
!     if (lpIcon == NULL)
! 	return NULL;
!     if (lpIcon->lpBits == NULL)
! 	return NULL;
!     if (!initinfo) {
! 	HMODULE hMod = GetModuleHandleA("USER32.DLL");
! 	initinfo=1;
! 	if(hMod){
! 	    pfnCreateIconFromResourceEx = GetProcAddress(hMod,"CreateIconFromResourceEx");
! 	}
!     }
!     /*  Let the OS do the real work :) */
!     if (pfnCreateIconFromResourceEx!=NULL) {
! 	hIcon = (HICON) (pfnCreateIconFromResourceEx)
! 	(lpIcon->lpBits, lpIcon->dwNumBytes, TRUE, 0x00030000,
! 	(*(LPBITMAPINFOHEADER)(lpIcon->lpBits)).biWidth,
! 	(*(LPBITMAPINFOHEADER)(lpIcon->lpBits)).biHeight/2, 0 );
!     } else {
! 	hIcon = NULL;
!     }
!     /*  It failed, odds are good we're on NT so try the non-Ex way */
!     if (hIcon == NULL)    {
! 	/*  We would break on NT if we try with a 16bpp image */
! 	if (lpIcon->lpbi->bmiHeader.biBitCount != 16) {
! 	    hIcon = CreateIconFromResource( lpIcon->lpBits, lpIcon->dwNumBytes, TRUE, 0x00030000 );
! 	}
!     }
!     return hIcon;
! }
! 
! /*
!  *----------------------------------------------------------------------
   *
+  * ReadICOHeader --
+  *
+  *	Reads the header from an ICO file, as specfied by hFile.
+  *
+  * Results:
+  *	UINT - Number of images in file, -1 for failure.
+  *
+  * Side effects:
+  *	Registers a new window class.
+  *
+  *----------------------------------------------------------------------
+  */
+ static int ReadICOHeader( HANDLE hFile )
+ {
+     WORD    Input;
+     DWORD	dwBytesRead;
+ 
+     /*  Read the 'reserved' WORD */
+     if (! ReadFile( hFile, &Input, sizeof( WORD ), &dwBytesRead, NULL ))
+ 	return -1;
+     /*  Did we get a WORD? */
+     if (dwBytesRead != sizeof( WORD ))
+ 	return -1;
+     /*  Was it 'reserved' ?   (ie 0) */
+     if (Input != 0)
+ 	return -1;
+     /*  Read the type WORD */
+     if (! ReadFile( hFile, &Input, sizeof( WORD ), &dwBytesRead, NULL ))
+ 	return -1;
+     /*  Did we get a WORD? */
+     if (dwBytesRead != sizeof( WORD ))
+ 	return -1;
+     /*  Was it type 1? */
+     if (Input != 1)
+ 	return -1;
+     /*  Get the count of images */
+     if (! ReadFile( hFile, &Input, sizeof( WORD ), &dwBytesRead, NULL ))
+ 	return -1;
+     /*  Did we get a WORD? */
+     if (dwBytesRead != sizeof( WORD ))
+ 	return -1;
+     /*  Return the count */
+     return (int)Input;
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * InitWindowClass --
+  *
   *	This routine creates the Wm toplevel decorative frame class.
   *

   * Results:
***************
*** 323,360 ****
   *
   *----------------------------------------------------------------------
   */
! 
! static void
! InitWm(void)
! {
      ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
!             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
      WNDCLASS * classPtr;
  
      if (! tsdPtr->initialized) {
  	tsdPtr->initialized = 1;
  	tsdPtr->firstWindow = 1;
      }
      if (! initialized) {
  	Tcl_MutexLock(&winWmMutex);
  	if (! initialized) {
  	    initialized = 1;
- 	    classPtr = &toplevelClass;
  
!     /*
!      * When threads are enabled, we cannot use CLASSDC because
!      * threads will then write into the same device context.
!      * 
!      * This is a hack; we should add a subsystem that manages
!      * device context on a per-thread basis.  See also tkWinX.c,
!      * which also initializes a WNDCLASS structure.
!      */
  
! #ifdef TCL_THREADS
  	    classPtr->style = CS_HREDRAW | CS_VREDRAW;
! #else
  	    classPtr->style = CS_HREDRAW | CS_VREDRAW | CS_CLASSDC;
! #endif
  	    classPtr->cbClsExtra = 0;
  	    classPtr->cbWndExtra = 0;
  	    classPtr->hInstance = Tk_GetHINSTANCE();
--- 640,675 ----
   *
   *----------------------------------------------------------------------
   */
! static int InitWindowClass(WinIconPtr titlebaricon) {
      ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
! 	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
      WNDCLASS * classPtr;
+     classPtr = &toplevelClass;
  
      if (! tsdPtr->initialized) {
  	tsdPtr->initialized = 1;
  	tsdPtr->firstWindow = 1;
+ 	tsdPtr->iconPtr = NULL;
      }
      if (! initialized) {
  	Tcl_MutexLock(&winWmMutex);
  	if (! initialized) {
  	    initialized = 1;
  
! 	    /*
! 	     * When threads are enabled, we cannot use CLASSDC because
! 	     * threads will then write into the same device context.
! 	     * 
! 	     * This is a hack; we should add a subsystem that manages
! 	     * device context on a per-thread basis.  See also tkWinX.c,
! 	     * which also initializes a WNDCLASS structure.
! 	     */
  
! 	#ifdef TCL_THREADS
  	    classPtr->style = CS_HREDRAW | CS_VREDRAW;
! 	#else
  	    classPtr->style = CS_HREDRAW | CS_VREDRAW | CS_CLASSDC;
! 	#endif
  	    classPtr->cbClsExtra = 0;
  	    classPtr->cbWndExtra = 0;
  	    classPtr->hInstance = Tk_GetHINSTANCE();
***************
*** 362,368 ****
  	    classPtr->lpszMenuName = NULL;
  	    classPtr->lpszClassName = TK_WIN_TOPLEVEL_CLASS_NAME;
  	    classPtr->lpfnWndProc = WmProc;
! 	    classPtr->hIcon = LoadIcon(Tk_GetHINSTANCE(), "tk");
  	    classPtr->hCursor = LoadCursor(NULL, IDC_ARROW);
  
  	    if (!RegisterClass(classPtr)) {
--- 677,695 ----
  	    classPtr->lpszMenuName = NULL;
  	    classPtr->lpszClassName = TK_WIN_TOPLEVEL_CLASS_NAME;
  	    classPtr->lpfnWndProc = WmProc;
! 	    if (titlebaricon == NULL) {
! 		classPtr->hIcon = LoadIcon(Tk_GetHINSTANCE(), "tk");
! 	    } else {
! 		classPtr->hIcon = GetIcon(titlebaricon, ICON_BIG);
! 		if (classPtr->hIcon == NULL) {
! 		    return TCL_ERROR;
! 		}

! 		/* 
! 		* Store pointer to default icon so we know when 
! 		* we need to free that information
! 		*/
! 		tsdPtr->iconPtr = titlebaricon;
! 	    }
  	    classPtr->hCursor = LoadCursor(NULL, IDC_ARROW);
  
  	    if (!RegisterClass(classPtr)) {
***************
*** 371,381 ****
--- 698,1160 ----
  	}
  	Tcl_MutexUnlock(&winWmMutex);
      }
+     return TCL_OK;
  }
  
  /*
   *----------------------------------------------------------------------
   *
+  * InitWm --
+  *
+  *	This initialises the window manager
+  *
+  * Results:
+  *	None.
+  *
+  * Side effects:
+  *	Registers a new window class.
+  *
+  *----------------------------------------------------------------------
+  */
+ static void
+ InitWm(void)
+ {
+     /* Ignore return result */
+     (void) InitWindowClass(NULL);
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * WinSetIcon --
+  *
+  *	Sets either the default toplevel titlebar icon, or the icon
+  *	for a specific toplevel (if tkw is given, then only that
+  *	window is used).
+  *
+  * Results:
+  *	A standard Tcl return code.
+  *
+  * Side effects:
+  *	One or all windows may have their icon changed.
+  *	The Tcl result may be modified.
+  *	The window-manager will be initialised if it wasn't already.
+  *	The given window will be forced into existence.
+  *
+  *----------------------------------------------------------------------
+  */
+ int
+ WinSetIcon(interp, fileName, tkw)
+     Tcl_Interp *interp;
+     char *fileName;
+     Tk_Window tkw;
+ {
+     WinIconPtr titlebaricon = NULL;
+     WmInfo *wmPtr;
+     HWND hwnd;
+     int application = 0;
+     
+     if (tkw == NULL) {
+         tkw = Tk_MainWindow(interp);
+ 	application = 1;
+     }
+     
+     if (!(Tk_IsTopLevel(tkw))) {
+ 	Tcl_AppendResult(interp, "window \"", Tk_PathName(tkw), 
+ 		"\" isn't a top-level window", (char *) NULL);
+ 	return TCL_ERROR;
+     }
+     if (Tk_WindowId(tkw) == None) {
+ 	Tk_MakeWindowExist(tkw);
+     }
+     /* 
+      * Either return NULL, or return a valid titlebaricon with its
+      * ref count already incremented.
+      */
+     titlebaricon = ReadIconFromFile(interp, fileName);
+     if (titlebaricon == NULL) {
+ 	return TCL_ERROR;
+     }
+     /* Now we must get the window's wrapper, not the window itself */
+     wmPtr = ((TkWindow*)tkw)->wmInfoPtr;
+     hwnd = wmPtr->wrapper;
+ 
+     if (application) {
+ 	if (hwnd == NULL) {
+ 	    /* 
+ 	     * I don't actually think this is ever the correct thing, unless
+ 	     * perhaps the window doesn't have a wrapper.  But I believe all
+ 	     * windows have wrappers.
+ 	     */
+ 	    hwnd = Tk_GetHWND(Tk_WindowId(tkw));
+ 	}
+ 	/* 
+ 	* If we aren't initialised, then just initialise with the user's
+ 	* icon.  Otherwise our icon choice will be ignored moments later
+ 	* when Tk finishes initialising.
+ 	*/
+ 	if (!initialized) {
+ 	    if (InitWindowClass(titlebaricon) != TCL_OK) {
+ 		Tcl_AppendResult(interp,"Unable to set icon", (char*)NULL);
+ 		goto setIconError;
+ 	    }
+ 	} else {
+ 	    ThreadSpecificData *tsdPtr;
+ 	    if (!SetClassLong(hwnd, GCL_HICONSM, (LPARAM)GetIcon(titlebaricon, ICON_SMALL))) {

+ 		/* For some reason this triggers, even though it seems to be successful */
+ 		/* This is probably related to the WNDCLASS vs WNDCLASSEX difference */
+ 		/*
+ 		* Tcl_AppendResult(interp,"Unable to set new small icon", (char*)NULL);
+ 		* return TCL_ERROR;
+ 		*/
+ 		
+ 	    }
+ 	    if (!SetClassLong(hwnd, GCL_HICON, (LPARAM)GetIcon(titlebaricon, ICON_BIG))) {
+ 		Tcl_AppendResult(interp,"Unable to set new icon", (char*)NULL);
+ 		goto setIconError;
+ 	    }
+ 	    tsdPtr = (ThreadSpecificData *) 
+ 		    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ 	    if (tsdPtr->iconPtr != NULL) {
+ 		DecrIconRefCount(tsdPtr->iconPtr);
+ 	    }
+ 	    tsdPtr->iconPtr = titlebaricon;
+ 	}
+     } else {
+ 	if (!initialized) {
+ 	    /* 
+ 	     * Need to initialise the wm otherwise we will fail on
+ 	     * code which tries to set a toplevel's icon before that
+ 	     * happens
+ 	     */
+ 	    InitWindowClass(NULL);
+ 	}
+ 	/* 
+ 	* The following code is exercised if you do
+ 	* 
+ 	*   toplevel .t ; wm titlebaricon .t foo.icr
+ 	* 
+ 	* i.e. the wm hasn't had time to properly create
+ 	* the '.t' window before you set the icon.
+ 	*/
+ 	if (hwnd == NULL) {
+ 	    /* 
+ 	     * This little snippet is copied from the 'Map' function,
+ 	     * and should probably be placed in one proper location
+ 	     */
+ 	    if (wmPtr->titleUid == NULL) {
+ 		wmPtr->titleUid = wmPtr->winPtr->nameUid;
+ 	    }
+ 	    UpdateWrapper(wmPtr->winPtr);
+ 	    wmPtr = ((TkWindow*)tkw)->wmInfoPtr;
+ 	    hwnd = wmPtr->wrapper;
+ 	    if (hwnd == NULL) {
+ 		Tcl_AppendResult(interp,"Can't set icon; window has no wrapper.", (char*)NULL);
+ 		goto setIconError;
+ 	    }
+ 	}
+ 	SendMessage(hwnd,WM_SETICON,ICON_SMALL,(LPARAM)GetIcon(titlebaricon, ICON_SMALL));
+ 	SendMessage(hwnd,WM_SETICON,ICON_BIG,(LPARAM)GetIcon(titlebaricon, ICON_BIG));
+ 	
+ 	/* Sort out new and old icon issues */
+ 	if (wmPtr->iconPtr != NULL) {
+ 	    /* Free any old icon ptr which is associated with this window */
+ 	    DecrIconRefCount(wmPtr->iconPtr);
+ 	}
+ 	/* 
+ 	* We do not need to increment the ref count for the titlebaricon, because
+ 	* it was already incremented when we retrieved it 
+ 	*/
+ 	wmPtr->iconPtr = titlebaricon;
+     }
+     return TCL_OK;
+   setIconError:
+     /* We didn't use the titlebaricon after all */
+     DecrIconRefCount(titlebaricon);
+     return TCL_ERROR;
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * ReadIconFromFile --
+  *
+  *	Read the contents of a .ico, .icr, etc. file and extract an
+  *	icon resource, if possible, otherwise NULL is returned, and
+  *	an error message will already be in the interpreter.  Note that
+  *	currently this procedure is simply a straightforward cast, but
+  *	in the future we may require more complex icon formats, and this
+  *	procedure will then need to do the manipulation.
+  *
+  * Results:
+  *	A WinIconPtr structure containing the icons in the file, with
+  *	its ref count already incremented. The calling procedure should
+  *	either place this structure inside a WmInfo structure, or it should
+  *	pass it on to DecrIconRefCount() to ensure no memory leaks occur.

+  *
+  * Side effects:
+  *	Memory is allocated for the returned structure and the icons
+  *	it contains.  If the structure is not wanted, it should be
+  *	passed to DecrIconRefCount, and in any case a valid ref count
+  *	should be ensured to avoid memory leaks.
+  *	
+  *	Currently icon resources are not shared, so the ref count
+  *	of one of these structures will always be 0 or 1.  However
+  *	all we need do is implement a hash table to map between filenames
+  *	and WinIconPtr structures and no other code will need to 
+  *	be changed.  The pseudo-code for this is implemented below
+  *	in the 'if (0)' branch.
+  *
+  *----------------------------------------------------------------------
+  */
+ static WinIconPtr 
+ ReadIconFromFile(interp, fileName) 
+     Tcl_Interp *interp;
+     char *fileName;
+ {
+     LPICONRESOURCE lpIR;
+     WinIconPtr titlebaricon;
+ 
+     if (0 /* If we already have an icon for this filename */) {
+ 	titlebaricon = NULL; /* Get the real value from a hash table */
+ 	titlebaricon->refCount++;
+     } else {
+ 	lpIR = ReadIconFromICOFile(interp,fileName);
+ 
+ 	titlebaricon = (WinIconPtr) ckalloc(sizeof(WinIconInstance));
+ 	titlebaricon->iconResource = lpIR;
+ 	titlebaricon->refCount = 1;
+     }
+     return titlebaricon;
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * DecrIconRefCount --
+  *
+  *	Reduces the reference count.
+  *
+  * Results:
+  *	None.
+  *
+  * Side effects:
+  *	If the ref count falls to zero, free the memory associated
+  *	with the icon resource structures.  In this case the pointer
+  *	passed into this function is no longer valid.
+  *
+  *----------------------------------------------------------------------
+  */
+ static void DecrIconRefCount(WinIconPtr titlebaricon) {
+     titlebaricon->refCount--;
+     
+     if (titlebaricon->refCount <= 0) {
+ 	if (titlebaricon->iconResource != NULL) {
+ 	    FreeIcon(titlebaricon->iconResource);
+ 	}
+ 	titlebaricon->iconResource = NULL;
+     }
+     ckfree((char*)titlebaricon);
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * FreeIcon --
+  *
+  *	Frees all memory associated with a previously loaded 
+  *	titlebaricon.  The titlebaricon pointer is no longer
+  *	valid once this function returns.
+  *
+  * Results:
+  *	None.
+  *
+  * Side effects:
+  *	
+  *
+  *----------------------------------------------------------------------
+  */
+ static void FreeIcon(LPICONRESOURCE lpIR) {
+     int i;
+     
+     /* Free all the bits */
+     for (i=0; i< lpIR->nNumImages; i++) {
+ 	if (lpIR->IconImages[i].lpBits != NULL) {
+ 	    ckfree((char*)lpIR->IconImages[i].lpBits);
+ 	}
+ 	if (lpIR->IconImages[i].hIcon != NULL) {
+ 	    DestroyIcon(lpIR->IconImages[i].hIcon);
+ 	}
+     }
+     ckfree ((char*)lpIR);
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * GetIcon --
+  *
+  *	Extracts an icon of a given size from an icon resource
+  *
+  * Results:
+  *	Returns the icon, if found, else NULL.
+  *

+  * Side effects:
+  *	
+  *
+  *----------------------------------------------------------------------
+  */
+ static HICON GetIcon(WinIconPtr titlebaricon, int icon_size) {
+     LPICONRESOURCE lpIR = titlebaricon->iconResource;
+     unsigned int size = (icon_size == 0 ? 16 : 32);
+     int i;
+     
+     for( i = 0; i < lpIR->nNumImages; i++ ) {
+ 	/*take the first or a 32x32 16 color icon*/
+ 	if(lpIR->IconImages[i].Height==size 
+ 	   && lpIR->IconImages[i].Width==size
+ 	   && lpIR->IconImages[i].Colors >= 4) {
+ 	    return lpIR->IconImages[i].hIcon;
+ 	}
+     }
+     return NULL;
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
+  * ReadIconFromICOFile --
+  *
+  *	Reads an Icon Resource from an ICO file, as given by 
+  *	LPCTSTR fileName - Name of the ICO file
+  *
+  * Results:
+  *	Returns an icon resource, if found, else NULL.
+  *
+  * Side effects:
+  *      May leave error messages in the Tcl interpreter.
+  *
+  *----------------------------------------------------------------------
+  */
+ LPICONRESOURCE ReadIconFromICOFile(Tcl_Interp* interp,LPCTSTR fileName){
+     LPICONRESOURCE    	lpIR , lpNew ;
+     HANDLE            	hFile;
+     int                 i;
+     DWORD            	dwBytesRead;
+     LPICONDIRENTRY    	lpIDE;
+ 
+ 
+     /*  Open the file */
+     if ((hFile = CreateFile( fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL )) == INVALID_HANDLE_VALUE)    {
+ 	Tcl_AppendResult(interp,"Error opening file \"", fileName, 
+ 	                 "\" for reading",(char*)NULL);
+ 	return NULL;
+     }
+     /*  Allocate memory for the resource structure */
+     if ((lpIR = (LPICONRESOURCE) ckalloc( sizeof(ICONRESOURCE) )) == NULL)    {
+ 	Tcl_AppendResult(interp,"Error allocating memory",(char*)NULL);
+ 	CloseHandle( hFile );
+ 	return NULL;
+     }
+     /*  Read in the header */
+     if ((lpIR->nNumImages = ReadICOHeader( hFile )) == -1)    {
+ 	Tcl_AppendResult(interp,"Error reading file header",(char*)NULL);
+ 	CloseHandle( hFile );
+ 	ckfree((char*) lpIR );
+ 	return NULL;
+     }
+     /*  Adjust the size of the struct to account for the images */
+     if ((lpNew = (LPICONRESOURCE) ckrealloc( (char*)lpIR, sizeof(ICONRESOURCE) + ((lpIR->nNumImages-1) * sizeof(ICONIMAGE)) )) == NULL)    {
+ 	Tcl_AppendResult(interp,"Error allocating memory",(char*)NULL);
+ 	CloseHandle( hFile );
+ 	ckfree( (char*)lpIR );
+ 	return NULL;
+     }
+     lpIR = lpNew;
+     /*  Store the original name */
+     lstrcpy( lpIR->szOriginalICOFileName, fileName );
+     lstrcpy( lpIR->szOriginalDLLFileName, "" );
+     /*  Allocate enough memory for the icon directory entries */
+     if ((lpIDE = (LPICONDIRENTRY) ckalloc( lpIR->nNumImages * sizeof( ICONDIRENTRY ) ) ) == NULL)     {
+ 	Tcl_AppendResult(interp,"Error allocating memory",(char*)NULL);
+ 	CloseHandle( hFile );
+ 	ckfree( (char*)lpIR );
+ 	return NULL;
+     }
+     /*  Read in the icon directory entries */
+     if (! ReadFile( hFile, lpIDE, lpIR->nNumImages * sizeof( ICONDIRENTRY ), &dwBytesRead, NULL ))    {
+ 	Tcl_AppendResult(interp,"Error reading file",(char*)NULL);

+ 	CloseHandle( hFile );
+ 	ckfree( (char*)lpIR );
+ 	return NULL;
+     }
+     if (dwBytesRead != lpIR->nNumImages * sizeof( ICONDIRENTRY ))    {
+ 	Tcl_AppendResult(interp,"Error reading file",(char*)NULL);
+ 	CloseHandle( hFile );
+ 	ckfree( (char*)lpIR );
+ 	return NULL;
+     }
+     /*  Loop through and read in each image */
+     for( i = 0; i < lpIR->nNumImages; i++ )    {
+ 	/*  Allocate memory for the resource */
+ 	if ((lpIR->IconImages[i].lpBits = (LPBYTE) ckalloc(lpIDE[i].dwBytesInRes)) == NULL)
+ 	{
+ 	    Tcl_AppendResult(interp,"Error allocating memory",(char*)NULL);
+ 	    CloseHandle( hFile );
+ 	    ckfree( (char*)lpIR );
+ 	    ckfree( (char*)lpIDE );
+ 	    return NULL;
+ 	}
+ 	lpIR->IconImages[i].dwNumBytes = lpIDE[i].dwBytesInRes;
+ 	/*  Seek to beginning of this image */
+ 	if (SetFilePointer( hFile, lpIDE[i].dwImageOffset, NULL, FILE_BEGIN ) == 0xFFFFFFFF)
+ 	{
+ 	    Tcl_AppendResult(interp,"Error seeking in file",(char*)NULL);
+ 	    CloseHandle( hFile );
+ 	    ckfree( (char*)lpIR );
+ 	    ckfree( (char*)lpIDE );
+ 	    return NULL;
+ 	}
+ 	/*  Read it in */
+ 	if (! ReadFile( hFile, lpIR->IconImages[i].lpBits, lpIDE[i].dwBytesInRes, &dwBytesRead, NULL ))
+ 	{
+ 	    Tcl_AppendResult(interp,"Error reading file",(char*)NULL);
+ 	    CloseHandle( hFile );
+ 	    ckfree( (char*)lpIR );
+ 	    ckfree( (char*)lpIDE );
+ 	    return NULL;
+ 	}
+ 	if (dwBytesRead != lpIDE[i].dwBytesInRes) 
+ 	{
+ 	    Tcl_AppendResult(interp,"Error reading file",(char*)NULL);
+ 	    CloseHandle( hFile );
+ 	    ckfree( (char*)lpIDE );
+ 	    ckfree( (char*)lpIR );
+ 	    return NULL;
+ 	}
+ 	/*  Set the internal pointers appropriately */
+ 	if (!AdjustIconImagePointers( &(lpIR->IconImages[i]))) {
+ 	    Tcl_AppendResult(interp,"Error converting to internal format",(char*)NULL);
+ 	    CloseHandle( hFile );
+ 	    ckfree( (char*)lpIDE );
+ 	    ckfree( (char*)lpIR );
+ 	    return NULL;
+ 	}
+ 	lpIR->IconImages[i].hIcon=MakeIconFromResource(&(lpIR->IconImages[i]));
+     }
+     /*  Clean up */
+     ckfree((char*)lpIDE);
+     CloseHandle(hFile);
+     if(lpIR==NULL){
+ 	Tcl_AppendResult(interp,"Reading of ",fileName," failed!",(char*)NULL);
+ 	return NULL;
+     }
+     return lpIR;
+ }
+ 
+ /*
+  *----------------------------------------------------------------------
+  *
   * GetTopLevel --
   *
   *	This function retrieves the TkWindow associated with the
***************
*** 389,395 ****
   *
   *----------------------------------------------------------------------
   */
- 
  static TkWindow *
  GetTopLevel(hwnd)
      HWND hwnd;
--- 1168,1173 ----
***************
*** 625,630 ****
--- 1403,1409 ----
      wmPtr->cmdArgv = NULL;
      wmPtr->clientMachine = NULL;
      wmPtr->flags = WM_NEVER_MAPPED;
+     wmPtr->iconPtr = NULL;
      wmPtr->nextPtr = winPtr->dispPtr->firstWmPtr;
      winPtr->dispPtr->firstWmPtr = wmPtr;
  
***************
*** 673,678 ****
--- 1452,1459 ----
      HWND child = TkWinGetHWND(winPtr->window);
      int x, y, width, height, state;
      WINDOWPLACEMENT place;
+     HICON hSmallIcon = NULL;
+     HICON hBigIcon = NULL;

      Tcl_DString titleString;
      int *childStateInfo = NULL;
      ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
***************
*** 795,800 ****
--- 1576,1586 ----
  #endif
      }
      oldWrapper = SetParent(child, wmPtr->wrapper);
+     if (oldWrapper) {
+ 	hSmallIcon = (HICON) SendMessage(oldWrapper,WM_GETICON,ICON_SMALL,(LPARAM)NULL);
+ 	hBigIcon = (HICON) SendMessage(oldWrapper,WM_GETICON,ICON_BIG,(LPARAM)NULL);
+     }
+     
      if (oldWrapper && (oldWrapper != wmPtr->wrapper) 
  	    && (oldWrapper != GetDesktopWindow())) {
  #ifdef _WIN64
***************
*** 834,840 ****
  
      wmPtr->flags &= ~WM_NEVER_MAPPED;
      SendMessage(wmPtr->wrapper, TK_ATTACHWINDOW, (WPARAM) child, 0);
! 
      /*
       * Force an initial transition from withdrawn to the real
       * initial state.	
--- 1620,1626 ----
  
      wmPtr->flags &= ~WM_NEVER_MAPPED;
      SendMessage(wmPtr->wrapper, TK_ATTACHWINDOW, (WPARAM) child, 0);
!     
      /*
       * Force an initial transition from withdrawn to the real
       * initial state.	
***************
*** 844,849 ****
--- 1630,1642 ----
      wmPtr->hints.initial_state = WithdrawnState;
      TkpWmSetState(winPtr, state);
  
+     if (hSmallIcon != NULL) {
+ 	SendMessage(wmPtr->wrapper,WM_SETICON,ICON_SMALL,(LPARAM)hSmallIcon);
+     }
+     if (hBigIcon != NULL) {
+ 	SendMessage(wmPtr->wrapper,WM_SETICON,ICON_BIG,(LPARAM)hBigIcon);
+     }
+ 
      /*
       * If we are embedded then force a mapping of the window now,
       * because we do not necessarily own the wrapper and may not
***************
*** 1158,1163 ****
--- 1951,1965 ----
  	    DestroyWindow(Tk_GetHWND(winPtr->window));
  	}
      }
+     if (wmPtr->iconPtr != NULL) {
+ 	/* 
+ 	* This may delete the icon resource data.  I believe we
+ 	* should do this after destroying the decorative frame,
+ 	* because the decorative frame is using this icon.
+ 	*/
+         DecrIconRefCount(wmPtr->iconPtr);
+     }
+     
      ckfree((char *) wmPtr);
      winPtr->wmInfoPtr = NULL;
  }
***************
*** 1674,1688 ****
  	}
      } else if ((c == 'i') && (strncmp(argv[1], "iconbitmap", length) == 0)
  	    && (length >= 5)) {
! 	Pixmap pixmap;
! 
! 	if ((argc != 3) && (argc != 4)) {
  	    Tcl_AppendResult(interp, "wrong # arguments: must be \"",
! 		    argv[0], " iconbitmap window ?bitmap?\"",
  		    (char *) NULL);
  	    return TCL_ERROR;
! 	}
! 	if (argc == 3) {
  	    if (wmPtr->hints.flags & IconPixmapHint) {
  		Tcl_SetResult(interp,
  			Tk_NameOfBitmap(winPtr->display,
--- 2476,2500 ----
  	}
      } else if ((c == 'i') && (strncmp(argv[1], "iconbitmap", length) == 0)
  	    && (length >= 5)) {
! 	/* If true, then set for all windows. */
! 	int isDefault = 0;
! 	
! 	if ((argc < 3) || (argc > 5)) {
  	    Tcl_AppendResult(interp, "wrong # arguments: must be \"",
! 		    argv[0], " iconbitmap window ?-default? ?image?\"",
  		    (char *) NULL);
  	    return TCL_ERROR;
! 	} else if (argc == 5) {
! 	    /* If we have 5 arguments, we must have a '-default' flag */
! 	    if (strcmp(argv[3],"-default")) {
! 		Tcl_AppendResult(interp, "illegal option \"", 

! 			argv[3], " must be \"-default\"", 
! 			(char *) NULL);
! 		return TCL_ERROR;
! 	    }
! 	    isDefault = 1;
! 	} else if (argc == 3) {
! 	    /* No arguments were given */
  	    if (wmPtr->hints.flags & IconPixmapHint) {
  		Tcl_SetResult(interp,
  			Tk_NameOfBitmap(winPtr->display,
***************
*** 1690,1708 ****
  	    }
  	    return TCL_OK;
  	}
! 	if (*argv[3] == '\0') {
  	    if (wmPtr->hints.icon_pixmap != None) {
  		Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_pixmap);
  	    }
  	    wmPtr->hints.flags &= ~IconPixmapHint;
  	} else {
! 	    pixmap = Tk_GetBitmap(interp, (Tk_Window) winPtr,
! 		    Tk_GetUid(argv[3]));
! 	    if (pixmap == None) {
! 		return TCL_ERROR;
  	    }
- 	    wmPtr->hints.icon_pixmap = pixmap;
- 	    wmPtr->hints.flags |= IconPixmapHint;
  	}
      } else if ((c == 'i') && (strncmp(argv[1], "iconify", length) == 0)
  	    && (length >= 5)) {
--- 2502,2546 ----
  	    }
  	    return TCL_OK;
  	}
! 	if (*argv[argc-1] == '\0') {
  	    if (wmPtr->hints.icon_pixmap != None) {
  		Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_pixmap);
  	    }
  	    wmPtr->hints.flags &= ~IconPixmapHint;
  	} else {
! 	    /* 
! 	     * In the future this block of code will use Tk's 'image'
! 	     * functionality to allow all supported image formats.
! 	     * However, this will require a change to the way icons are
! 	     * handled.  We will need to add icon<->image conversions
! 	     * routines.
! 	     *
! 	     * Until that happens we simply try to find an icon in the
! 	     * given argument, and if that fails, we use the older
! 	     * bitmap code.  We do things this way round (icon then
! 	     * bitmap), because the bitmap code actually seems to have
! 	     * no visible effect, so we want to give the icon code the
! 	     * first try at doing something.
! 	     */
! 	    
! 	    /* 
! 	     * Try to set the icon for the window.  If it is a '-default'
! 	     * icon, we must pass in NULL
! 	     */
! 	    if (WinSetIcon(interp, argv[argc-1], 
! 			   (isDefault ? NULL : (Tk_Window) winPtr)) != TCL_OK) {
! 		/* The argument wasn't a valid icon, so try with a bitmap */
! 		/* Clear the error message which was placed in the interpreter */
! 		Pixmap pixmap;
! 		Tcl_ResetResult(interp);
! 		pixmap = Tk_GetBitmap(interp, (Tk_Window) winPtr,
! 			Tk_GetUid(argv[argc-1]));
! 		if (pixmap == None) {
! 		    return TCL_ERROR;
! 		}
! 		wmPtr->hints.icon_pixmap = pixmap;
! 		wmPtr->hints.flags |= IconPixmapHint;
  	    }
  	}
      } else if ((c == 'i') && (strncmp(argv[1], "iconify", length) == 0)
  	    && (length >= 5)) {
