Changeset 6709 for trunk/src/comctl32/imagelist.c

Timestamp:

Sep 15, 2001, 11:26:26 AM (24 years ago)

Author:

sandervl

Message:

restored old version

File:

• trunk/src/comctl32/imagelist.c (modified) (108 diffs)

trunk/src/comctl32/imagelist.c

@@ -20 +20 @@
  *    - ImageList_Draw, ImageList_DrawEx and ImageList_GetIcon use
  *      ImageList_DrawIndirect. Since ImageList_DrawIndirect is still
- *      partially implemented, the functions mentioned above will be
+ *      partially implemented, the functions mentioned above will be 
  *      limited in functionality too.
  */
@@ -69 +69 @@
 
 /*************************************************************************
- * IMAGELIST_InternalExpandBitmaps [Internal]
+ * IMAGELIST_InternalExpandBitmaps [Internal] 
  *
  * Expands the bitmaps of an image list by the given number of images.
@@ -92 +92 @@
     if ((himl->cCurImage + nImageCount < himl->cMaxImage)
         && (himl->cy >= cy))
-    return;
+        return;
 
     if (cy == 0) cy = himl->cy;
@@ -116 +116 @@
 
     if (himl->hbmMask) {
-        hbmNewBitmap =
+        hbmNewBitmap = 
             CreateBitmap (nNewWidth, cy, 1, 1, NULL);
 
@@ -138 +138 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDraw [Internal]
+ * IMAGELIST_InternalDraw [Internal] 
  *
  * Draws the image in the ImageList (without the mask)
@@ -151 +151 @@
  *
  * NOTES
- *     This function is used by ImageList_DrawIndirect, when it is
+ *     This function is used by ImageList_DrawIndirect, when it is 
  *     required to draw only the Image (without the mask) to the screen.
  *
@@ -164 +164 @@
     hImageDC = CreateCompatibleDC(0);
     hOldBitmap = SelectObject(hImageDC, pimldp->himl->hbmImage);
-    BitBlt(pimldp->hdcDst,
+    BitBlt(pimldp->hdcDst, 
         pimldp->x, pimldp->y, cx, cy,
-        hImageDC,
-        pimldp->himl->cx * pimldp->i, 0,
+        hImageDC, 
+        pimldp->himl->cx * pimldp->i, 0, 
         SRCCOPY);
 
@@ -176 +176 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDrawMask [Internal]
+ * IMAGELIST_InternalDrawMask [Internal] 
  *
  * Draws the image in the ImageList with the mask
@@ -189 +189 @@
  *
  * NOTES
- *     This function is used by ImageList_DrawIndirect, when it is
+ *     This function is used by ImageList_DrawIndirect, when it is 
  *     required to draw the Image with the mask to the screen.
  *
@@ -205 +205 @@
     UINT fStyle = pimldp->fStyle & (~ILD_OVERLAYMASK);
 
-    /*
-     * We need a dc and bitmap to draw on that is
+    /* 
+     * We need a dc and bitmap to draw on that is 
      * not on the screen.
      */
@@ -221 +221 @@
     hOffScreenDC = CreateCompatibleDC( pimldp->hdcDst );
 
-    if ( hOffScreenDC )
+    if ( hOffScreenDC ) 
     {
         hOffScreenBmp = CreateCompatibleBitmap( pimldp->hdcDst, cx, cy );
 
-        if ( hOffScreenBmp )
+        if ( hOffScreenBmp ) 
             SelectObject( hOffScreenDC, hOffScreenBmp  );
         else
@@ -235 +235 @@
     hOldBitmapImage = SelectObject(hImageDC, himlLocal->hbmImage);
     hOldBitmapMask = SelectObject(hMaskDC, himlLocal->hbmMask);
-
-    /*
-     * Get a copy of the image for the masking operations.
+    
+    /* 
+     * Get a copy of the image for the masking operations. 
      * We will use the copy, and this dc for all the various
      * blitting, and then do one final blit to the screen dc.
      * This should clean up most of the flickering.
      */
-    BitBlt( hOffScreenDC, 0, 0, cx, cy, pimldp->hdcDst, pimldp->x,
+    BitBlt( hOffScreenDC, 0, 0, cx, cy, pimldp->hdcDst, pimldp->x, 
             pimldp->y, SRCCOPY);
 
-    /*
+    /* 
      * Draw the Background for the appropriate Styles
      */
-    if( bUseCustomBackground && (fStyle == ILD_NORMAL || fStyle & ILD_IMAGE
+    if( bUseCustomBackground && (fStyle == ILD_NORMAL || fStyle & ILD_IMAGE 
          || bBlendFlag) )
     {
-
+        
         hBrush = CreateSolidBrush (himlLocal->clrBk);
         hOldBrush = SelectObject (pimldp->hdcDst, hBrush);
-
+        
         PatBlt( hOffScreenDC, pimldp->x, pimldp->y, cx, cy, PATCOPY );
 
@@ -260 +260 @@
     }
 
-    /*
+    /* 
      * Draw Image Transparently over the current background
      */
-    if(fStyle == ILD_NORMAL || (fStyle & ILD_TRANSPARENT) ||
-       ((fStyle & ILD_IMAGE) && bUseCustomBackground) || bBlendFlag)
-    {   /*
+    if(fStyle == ILD_NORMAL || (fStyle & ILD_TRANSPARENT) || 
+       ((fStyle & ILD_IMAGE) && bUseCustomBackground) || bBlendFlag) 
+    {   /* 
          * To obtain a transparent look, background color should be set
-         * to white and foreground color to black when blting the
-         * monochrome mask.
+         * to white and foreground color to black when blting the 
+         * monochrome mask. 
          */
-
-        oldBkColor = SetBkColor( hOffScreenDC, RGB( 0xff, 0xff, 0xff ) );
+        
+        oldBkColor = SetBkColor( hOffScreenDC, RGB( 0xff, 0xff, 0xff ) ); 
         oldFgColor = SetTextColor( hOffScreenDC, RGB( 0, 0, 0 ) );
 
@@ -279 +279 @@
         BitBlt( hOffScreenDC, 0, 0, cx, cy, hImageDC,himlLocal->cx * pimldp->i,
                 0, SRCPAINT );
-
-    }
-
+    
+    }
+    
     /*
      * Draw the image when no Background is specified
@@ -287 +287 @@
     else if((fStyle & ILD_IMAGE) && !bUseCustomBackground)
     {
-        BitBlt( hOffScreenDC, 0, 0, cx, cy, hImageDC,
+        BitBlt( hOffScreenDC, 0, 0, cx, cy, hImageDC, 
                 himlLocal->cx * pimldp->i, 0, SRCCOPY);
     }
-    /*
+    /* 
      * Draw the mask with or without a background
      */
@@ -298 +298 @@
                 0, bUseCustomBackground ? SRCCOPY : SRCAND);
     }
-
+    
     /*
      * Blit the bitmap to the screen now.
@@ -305 +305 @@
             hOffScreenDC, 0, 0, SRCCOPY);
 
-
+    
     SelectObject(hImageDC, hOldBitmapImage);
     SelectObject(hMaskDC, hOldBitmapMask);
-
+    
 cleanup:
-
+    
     DeleteDC(hImageDC);
     DeleteDC(hMaskDC);
-
+    
     DeleteDC( hOffScreenDC );
     DeleteObject( hOffScreenBmp );
-
+    
     return;
 }
 
 /*************************************************************************
- * IMAGELIST_InternalDrawBlend [Internal]
- *
- * Draws the Blend over the current image
+ * IMAGELIST_InternalDrawBlend [Internal] 
+ *
+ * Draws the Blend over the current image 
  *
  * PARAMS
@@ -334 +334 @@
  *
  * NOTES
- *     This functions is used by ImageList_DrawIndirect, when it is
- *     required to add the blend to the current image.
- *
+ *     This functions is used by ImageList_DrawIndirect, when it is 
+ *     required to add the blend to the current image.  
+ *     
  */
 static VOID
@@ -375 +375 @@
 
         BitBlt(hBlendMaskDC,
-            0,0, cx, cy,
+            0,0, cx, cy, 
             hMaskDC,
             himlLocal->cx * pimldp->i,0,
@@ -381 +381 @@
 
         BitBlt(hBlendMaskDC,
-            0,0, cx, cy,
+            0,0, cx, cy, 
             hBlendMaskDC,
-            0,0,
+            0,0, 
             NOTSRCCOPY);
 
@@ -397 +397 @@
     hOldBrush = (HBRUSH) SelectObject (pimldp->hdcDst, hBlendColorBrush);
 
-    BitBlt (pimldp->hdcDst,
-        pimldp->x, pimldp->y, cx, cy,
-        hBlendMaskDC,
-        0, 0,
+    BitBlt (pimldp->hdcDst, 
+        pimldp->x, pimldp->y, cx, cy, 
+        hBlendMaskDC, 
+        0, 0, 
         0xB8074A); /* PSDPxax */
 
@@ -413 +413 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDrawOverlay [Internal]
- *
- * Draws the overlay image
+ * IMAGELIST_InternalDrawOverlay [Internal] 
+ *
+ * Draws the overlay image 
  *
  * PARAMS
@@ -426 +426 @@
  *
  * NOTES
- *     This functions is used by ImageList_DrawIndirect, when it is
+ *     This functions is used by ImageList_DrawIndirect, when it is 
  *     required to draw the overlay
  *
- *
- */
-static VOID
+ *     
+ */
+static VOID 
 IMAGELIST_InternalDrawOverlay(IMAGELISTDRAWPARAMS *pimldp, INT cx, INT cy)
 {
@@ -447 +447 @@
             if (pimldp->himl->hbmMask)
             {
-                hOldBitmap = (HBITMAP) SelectObject (hImageDC,
+                hOldBitmap = (HBITMAP) SelectObject (hImageDC, 
                     pimldp->himl->hbmMask);
 
-                BitBlt (pimldp->hdcDst,
+                BitBlt (pimldp->hdcDst, 
                     pimldp->x, pimldp->y, cx, cy,
                     hImageDC, pimldp->himl->cx * nOvlIdx, 0,
@@ -457 +457 @@
                 SelectObject(hImageDC, hOldBitmap);
             }
-            hOldBitmap = (HBITMAP) SelectObject (hImageDC,
+            hOldBitmap = (HBITMAP) SelectObject (hImageDC, 
                 pimldp->himl->hbmImage);
 
-            BitBlt (pimldp->hdcDst,
-                pimldp->x, pimldp->y, cx, cy,
+            BitBlt (pimldp->hdcDst, 
+                pimldp->x, pimldp->y, cx, cy, 
                 hImageDC,
                 pimldp->himl->cx * nOvlIdx, 0,
@@ -492 +492 @@
 
 INT WINAPI
-ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
+ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
 {
     HDC     hdcImage, hdcBitmap;
@@ -531 +531 @@
         hOldBitmapTemp = (HBITMAP) SelectObject(hdcTemp, hbmMask);
 
-        BitBlt (hdcMask,
+        BitBlt (hdcMask, 
             nStartX, 0, bmp.bmWidth, bmp.bmHeight,
-            hdcTemp,
-            0, 0,
+            hdcTemp, 
+            0, 0, 
             SRCCOPY);
 
@@ -542 +542 @@
         /* Remove the background from the image
         */
-        BitBlt (hdcImage,
+        BitBlt (hdcImage, 
             nStartX, 0, bmp.bmWidth, bmp.bmHeight,
-            hdcMask,
-            nStartX, 0,
+            hdcMask, 
+            nStartX, 0, 
             0x220326); /* NOTSRCAND */
 
@@ -586 +586 @@
 
 /*************************************************************************
- * ImageList_AddMasked [COMCTL32.42]
+ * ImageList_AddMasked [COMCTL32.42] 
  *
  * Adds an image or images to an image list and creates a mask from the
@@ -651 +651 @@
         GetPixel (hdcBitmap, 0, 0);
     SetBkColor (hdcBitmap, bkColor);
-    BitBlt (hdcMask,
+    BitBlt (hdcMask, 
         nMaskXOffset, 0, bmp.bmWidth, bmp.bmHeight,
-        hdcBitmap, 0, 0,
+        hdcBitmap, 0, 0, 
         SRCCOPY);
 
@@ -668 +668 @@
         This is here in case some apps rely on this bug
     */
-    BitBlt(hdcBitmap,
+    BitBlt(hdcBitmap, 
         0, 0, bmp.bmWidth, bmp.bmHeight,
-        hdcMask,
-        nMaskXOffset, 0,
+        hdcMask, 
+        nMaskXOffset, 0, 
         0x220326); /* NOTSRCAND */
     /* Copy result to the imagelist
     */
-    BitBlt (hdcImage,
+    BitBlt (hdcImage, 
         nIndex * himl->cx, 0, bmp.bmWidth, bmp.bmHeight,
-        hdcBitmap,
-        0, 0,
+        hdcBitmap, 
+        0, 0, 
         SRCCOPY);
     /* Clean up
@@ -698 +698 @@
 
 /*************************************************************************
- * ImageList_BeginDrag [COMCTL32.43]
+ * ImageList_BeginDrag [COMCTL32.43] 
  *
  * Creates a temporary image list that contains one image. It will be used
@@ -716 +716 @@
 BOOL WINAPI
 ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack,
-                 INT dxHotspot, INT dyHotspot)
+                     INT dxHotspot, INT dyHotspot)
 {
     HDC hdcSrc, hdcDst;
@@ -723 +723 @@
 
     if (himlTrack == NULL)
-    return FALSE;
+        return FALSE;
 
     if (himlInternalDrag)
@@ -729 +729 @@
 
     himlInternalDrag =
-    ImageList_Create (himlTrack->cx, himlTrack->cy,
-              himlTrack->flags, 1, 1);
+        ImageList_Create (himlTrack->cx, himlTrack->cy,
+                          himlTrack->flags, 1, 1);
     if (himlInternalDrag == NULL) {
         ERR("Error creating drag image list!\n");
@@ -764 +764 @@
 
 /*************************************************************************
- * ImageList_Copy [COMCTL32.44]
- *
- *  Copies an image of the source image list to an image of the
+ * ImageList_Copy [COMCTL32.44] 
+ *
+ *  Copies an image of the source image list to an image of the 
  *  destination image list. Images can be copied or swapped.
  *
@@ -787 +787 @@
 
 BOOL WINAPI
-ImageList_Copy (HIMAGELIST himlDst, INT iDst,   HIMAGELIST himlSrc,
-        INT iSrc, INT uFlags)
-{
-    HDC hdcSrc, hdcDst;
+ImageList_Copy (HIMAGELIST himlDst, INT iDst,   HIMAGELIST himlSrc,
+                INT iSrc, INT uFlags)
+{
+    HDC hdcSrc, hdcDst;    
 
     TRACE("iDst=%d  iSrc=%d\n", iDst, iSrc);
 
     if ((himlSrc == NULL) || (himlDst == NULL))
-    return FALSE;
+        return FALSE;
     if ((iDst < 0) || (iDst >= himlDst->cCurImage))
-    return FALSE;
+        return FALSE;
     if ((iSrc < 0) || (iSrc >= himlSrc->cCurImage))
-    return FALSE;
+        return FALSE;
 
     hdcSrc = CreateCompatibleDC (0);
@@ -815 +815 @@
                                        himlSrc->uBitsPixel, NULL);
         hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
-                      1, NULL);
+                                      1, NULL);
 
         /* copy (and stretch) destination to temporary bitmaps.(save) */
@@ -908 +908 @@
 HIMAGELIST WINAPI
 ImageList_Create (INT cx, INT cy, UINT flags,
-          INT cInitial, INT cGrow)
+                  INT cInitial, INT cGrow)
 {
     HIMAGELIST himl;
@@ -914 +914 @@
     INT      nCount;
     HBITMAP  hbmTemp;
-    static WORD aBitBlend25[] =
+    static WORD aBitBlend25[] = 
         {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
 
@@ -948 +948 @@
     if (himl->cMaxImage > 0) {
         himl->hbmImage =
-      CreateBitmap (himl->cx * himl->cMaxImage, himl->cy,
+          CreateBitmap (himl->cx * himl->cMaxImage, himl->cy,
                         1, himl->uBitsPixel, NULL);
-    if (himl->hbmImage == 0) {
-        ERR("Error creating image bitmap!\n");
-        return NULL;
-    }
+        if (himl->hbmImage == 0) {
+            ERR("Error creating image bitmap!\n");
+            return NULL;
+        }
     }
     else
         himl->hbmImage = 0;
-
+    
     if ( (himl->cMaxImage > 0) && (himl->flags & ILC_MASK)) {
         himl->hbmMask = CreateBitmap (himl->cx * himl->cMaxImage, himl->cy,
-                    1, 1, NULL);
+                                        1, 1, NULL);
         if (himl->hbmMask == 0) {
             ERR("Error creating mask bitmap!\n");
@@ -986 +986 @@
 
 /*************************************************************************
- * ImageList_Destroy [COMCTL32.46]
+ * ImageList_Destroy [COMCTL32.46] 
  *
  * Destroys an image list.
@@ -1000 +1000 @@
 BOOL WINAPI
 ImageList_Destroy (HIMAGELIST himl)
-{
+{ 
     if (!himl)
-    return FALSE;
+        return FALSE;
 
     /* delete image bitmaps */
@@ -1015 +1015 @@
     if (himl->hbrBlend50)
         DeleteObject (himl->hbrBlend50);
-
+        
     COMCTL32_Free (himl);
 
@@ -1023 +1023 @@
 
 /*************************************************************************
- * ImageList_DragEnter [COMCTL32.47]
+ * ImageList_DragEnter [COMCTL32.47] 
  *
  * Locks window update and displays the drag image at the given position.
@@ -1045 +1045 @@
 {
     if (himlInternalDrag == NULL)
-    return FALSE;
+        return FALSE;
 
     if (hwndLock)
-    hwndInternalDrag = hwndLock;
+        hwndInternalDrag = hwndLock;
     else
-    hwndInternalDrag = GetDesktopWindow ();
+        hwndInternalDrag = GetDesktopWindow ();
 
     xInternalPos = x;
@@ -1057 +1057 @@
     hdcBackBuffer = CreateCompatibleDC (0);
     hbmBackBuffer = CreateCompatibleBitmap (hdcBackBuffer,
-        himlInternalDrag->cx, himlInternalDrag->cy);
+                himlInternalDrag->cx, himlInternalDrag->cy);
 
     ImageList_DragShowNolock (TRUE);
@@ -1066 +1066 @@
 
 /*************************************************************************
- * ImageList_DragLeave [COMCTL32.48]
+ * ImageList_DragLeave [COMCTL32.48] 
  *
  * Unlocks window update and hides the drag image.
@@ -1082 +1082 @@
 {
     if (hwndLock)
-    hwndInternalDrag = hwndLock;
+        hwndInternalDrag = hwndLock;
     else
-    hwndInternalDrag = GetDesktopWindow ();
+        hwndInternalDrag = GetDesktopWindow ();
 
     ImageList_DragShowNolock (FALSE);
@@ -1096 +1096 @@
 
 /*************************************************************************
- * ImageList_DragMove [COMCTL32.49]
+ * ImageList_DragMove [COMCTL32.49] 
  *
  * Moves the drag image.
@@ -1128 +1128 @@
 
 /*************************************************************************
- * ImageList_DragShowNolock [COMCTL32.50]
+ * ImageList_DragShowNolock [COMCTL32.50] 
  *
  * Shows or hides the drag image.
@@ -1152 +1152 @@
 
     hdcDrag = GetDCEx (hwndInternalDrag, 0,
-             DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
+                         DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
 
     if (bShow) {
-    /* show drag image */
-
-    /* save background */
-
-    /* draw drag image */
+        /* show drag image */
+
+        /* save background */
+
+        /* draw drag image */
 
     }
     else {
-    /* hide drag image */
-
-    /* restore background */
+        /* hide drag image */
+
+        /* restore background */
 
     }
@@ -1199 +1199 @@
 BOOL WINAPI
 ImageList_Draw (HIMAGELIST himl, INT i, HDC hdc,
-        INT x, INT y, UINT fStyle)
+                INT x, INT y, UINT fStyle)
 {
     IMAGELISTDRAWPARAMS imldp;
@@ -1252 +1252 @@
 BOOL WINAPI
 ImageList_DrawEx (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y,
-          INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg,
-          UINT fStyle)
+                  INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg,
+                  UINT fStyle)
 {
     IMAGELISTDRAWPARAMS imldp;
@@ -1277 +1277 @@
 
 /*************************************************************************
- * ImageList_DrawIndirect [COMCTL32.53]
+ * ImageList_DrawIndirect [COMCTL32.53] 
  *
  * Draws an image using ...
@@ -1292 +1292 @@
 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
 {
-    INT      cx, cy;
-    /*
+    INT      cx, cy;    
+    /* 
         Do some Error Checking
     */
@@ -1303 +1303 @@
         return FALSE;
     if ((pimldp->i < 0) || (pimldp->i >= pimldp->himl->cCurImage)) {
-    ERR("%d not within range (max %d)\n",pimldp->i,pimldp->himl->cCurImage-1);
+        ERR("%d not within range (max %d)\n",pimldp->i,pimldp->himl->cCurImage-1);
         return FALSE;
     }
@@ -1322 +1322 @@
         IMAGELIST_InternalDraw(pimldp, cx, cy);
     }
-    /*
+    /* 
         Apply the blend if needed to the Image
     */
@@ -1387 +1387 @@
         DeleteDC (hdcSrc);
 
-    himlDst->cCurImage = himlSrc->cCurImage;
-    himlDst->cMaxImage = himlSrc->cMaxImage;
+        himlDst->cCurImage = himlSrc->cCurImage;
+        himlDst->cMaxImage = himlSrc->cMaxImage;
     }
     return himlDst;
@@ -1447 +1447 @@
 {
     if (himl == NULL)
-    return CLR_NONE;
+        return CLR_NONE;
 
     return himl->clrBk;
@@ -1483 +1483 @@
 
 /*************************************************************************
- * ImageList_GetIcon [COMCTL32.59]
+ * ImageList_GetIcon [COMCTL32.59] 
  *
  * Creates an icon from a masked image of an image list.
@@ -1506 +1506 @@
 
     if ((himl == NULL) || (i < 0) || (i >= himl->cCurImage)) {
-    FIXME("(%p,%d,%x), params out of range!\n",himl,i,fStyle);
-    return 0;
+        FIXME("(%p,%d,%x), params out of range!\n",himl,i,fStyle);
+        return 0;
    }
 
@@ -1519 +1519 @@
     hOldDstBitmap = (HBITMAP)SelectObject (hdcDst, ii.hbmMask);
     if (himl->hbmMask) {
-    SelectObject (hdcSrc, himl->hbmMask);
-    BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
-          hdcSrc, i * himl->cx, 0, SRCCOPY);
+        SelectObject (hdcSrc, himl->hbmMask);
+        BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
+                  hdcSrc, i * himl->cx, 0, SRCCOPY);
     }
     else
-    PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
+        PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
 
     /* draw image*/
@@ -1531 +1531 @@
     SelectObject (hdcDst, ii.hbmColor);
     BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
-          hdcSrc, i * himl->cx, 0, SRCCOPY);
+              hdcSrc, i * himl->cx, 0, SRCCOPY);
 
     /*
      * CreateIconIndirect requires us to deselect the bitmaps from
-     * the DCs before calling
+     * the DCs before calling 
      */
     SelectObject(hdcSrc, hOldSrcBitmap);
     SelectObject(hdcDst, hOldDstBitmap);
 
-    hIcon = CreateIconIndirect (&ii);
+    hIcon = CreateIconIndirect (&ii);    
 
     DeleteDC (hdcSrc);
@@ -1573 +1573 @@
 {
     if (himl == NULL)
-    return FALSE;
+        return FALSE;
     if ((himl->cx <= 0) || (himl->cy <= 0))
-    return FALSE;
+        return FALSE;
 
     if (cx)
-    *cx = himl->cx;
+        *cx = himl->cx;
     if (cy)
-    *cy = himl->cy;
+        *cy = himl->cy;
 
     return TRUE;
@@ -1603 +1603 @@
 {
     if (himl == NULL)
-    return 0;
+        return 0;
 
     return himl->cCurImage;
@@ -1628 +1628 @@
 {
     if ((himl == NULL) || (pImageInfo == NULL))
-    return FALSE;
+        return FALSE;
     if ((i < 0) || (i >= himl->cCurImage))
-    return FALSE;
+        return FALSE;
 
     pImageInfo->hbmImage = himl->hbmImage;
     pImageInfo->hbmMask  = himl->hbmMask;
-
+    
     pImageInfo->rcImage.top    = 0;
     pImageInfo->rcImage.bottom = himl->cy;
     pImageInfo->rcImage.left   = i * himl->cx;
     pImageInfo->rcImage.right  = (i+1) * himl->cx;
-
+    
     return TRUE;
 }
@@ -1645 +1645 @@
 
 /*************************************************************************
- * ImageList_GetImageRect [COMCTL32.63]
+ * ImageList_GetImageRect [COMCTL32.63] 
  *
  * Retrieves the rectangle of the specified image in an image list.
@@ -1666 +1666 @@
 {
     if ((himl == NULL) || (lpRect == NULL))
-    return FALSE;
+        return FALSE;
     if ((i < 0) || (i >= himl->cCurImage))
-    return FALSE;
+        return FALSE;
 
     lpRect->left   = i * himl->cx;
@@ -1704 +1704 @@
 HIMAGELIST WINAPI
 ImageList_LoadImageA (HINSTANCE hi, LPCSTR lpbmp, INT cx, INT cGrow,
-            COLORREF clrMask, UINT uType, UINT uFlags)
+                        COLORREF clrMask, UINT uType, UINT uFlags)
 {
     HIMAGELIST himl = NULL;
@@ -1744 +1744 @@
         GetIconInfo (handle, &ii);
         GetObjectA (ii.hbmColor, sizeof(BITMAP), (LPVOID)&bmp);
-        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
+        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight, 
                                  ILC_MASK | ILC_COLOR, 1, cGrow);
         ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
@@ -1752 +1752 @@
 
     DeleteObject (handle);
-
+    
     return himl;
 }
@@ -1781 +1781 @@
 HIMAGELIST WINAPI
 ImageList_LoadImageW (HINSTANCE hi, LPCWSTR lpbmp, INT cx, INT cGrow,
-            COLORREF clrMask, UINT uType,   UINT uFlags)
+                        COLORREF clrMask, UINT uType,   UINT uFlags)
 {
     HIMAGELIST himl = NULL;
@@ -1808 +1808 @@
         GetIconInfo (handle, &ii);
         GetObjectA (ii.hbmMask, sizeof(BITMAP), (LPVOID)&bmp);
-        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
+        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight, 
                                  ILC_MASK | ILC_COLOR, 1, cGrow);
         ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
@@ -1816 +1816 @@
 
     DeleteObject (handle);
-
+    
     return himl;
 }
@@ -1822 +1822 @@
 
 /*************************************************************************
- * ImageList_Merge [COMCTL32.67]
+ * ImageList_Merge [COMCTL32.67] 
  *
  * Creates a new image list that contains a merged image from the specified
@@ -1842 +1842 @@
 HIMAGELIST WINAPI
 ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2,
-         INT dx, INT dy)
+                 INT dx, INT dy)
 {
     HIMAGELIST himlDst = NULL;
@@ -1851 +1851 @@
 
     if ((himl1 == NULL) || (himl2 == NULL))
-    return NULL;
+        return NULL;
 
     /* check indices */
@@ -1903 +1903 @@
         nX1 = i1 * himl1->cx;
         nX2 = i2 * himl2->cx;
-
+        
         /* copy image */
         SelectObject (hdcSrcImage, himl1->hbmImage);
         SelectObject (hdcDstImage, himlDst->hbmImage);
-        BitBlt (hdcDstImage, 0, 0, cxDst, cyDst,
+        BitBlt (hdcDstImage, 0, 0, cxDst, cyDst, 
                   hdcSrcImage, 0, 0, BLACKNESS);
-        BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy,
+        BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy, 
                   hdcSrcImage, nX1, 0, SRCCOPY);
 
         SelectObject (hdcSrcImage, himl2->hbmMask);
-        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
+        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy, 
                   hdcSrcImage, nX2, 0, SRCAND);
 
         SelectObject (hdcSrcImage, himl2->hbmImage);
-        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
+        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy, 
                   hdcSrcImage, nX2, 0, SRCPAINT);
 
@@ -1923 +1923 @@
         SelectObject (hdcSrcImage, himl1->hbmMask);
         SelectObject (hdcDstImage, himlDst->hbmMask);
-        BitBlt (hdcDstImage, 0, 0, cxDst, cyDst,
+        BitBlt (hdcDstImage, 0, 0, cxDst, cyDst, 
                   hdcSrcImage, 0, 0, WHITENESS);
-        BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy,
+        BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy, 
                   hdcSrcImage, nX1, 0, SRCCOPY);
 
         SelectObject (hdcSrcImage, himl2->hbmMask);
-        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
+        BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy, 
                   hdcSrcImage, nX2, 0, SRCAND);
 
@@ -1935 +1935 @@
         DeleteDC (hdcDstImage);
     }
-
+   
     return himlDst;
 }
@@ -1945 +1945 @@
     int bitspixel = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
     if (bitspixel>8)
-    return TRUE;
+        return TRUE;
     if (bitspixel<=4)
-    return FALSE;
+        return FALSE;
     return GetDeviceCaps(hdc,CAPS1) & C1_DIBENGINE;
 }
@@ -1954 +1954 @@
 /* helper for ImageList_Read, see comments below */
 static HBITMAP _read_bitmap(LPSTREAM pstm,int ilcFlag,int cx,int cy) {
-    HDC         xdc = 0;
-    BITMAPFILEHEADER    bmfh;
-    BITMAPINFOHEADER    bmih;
-    int         bitsperpixel,palspace,longsperline,width,height;
-    LPBITMAPINFOHEADER  bmihc = NULL;
-    int         result = 0;
-    HBITMAP     hbitmap = 0;
-    LPBYTE      bits = NULL,nbits = NULL;
-    int         nbytesperline,bytesperline;
-
-    if (!SUCCEEDED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL)) ||
-        (bmfh.bfType != (('M'<<8)|'B'))                 ||
-        !SUCCEEDED(IStream_Read ( pstm, &bmih, sizeof(bmih), NULL)) ||
-        (bmih.biSize != sizeof(bmih))
+    HDC                 xdc = 0;
+    BITMAPFILEHEADER    bmfh;
+    BITMAPINFOHEADER    bmih;
+    int                 bitsperpixel,palspace,longsperline,width,height;
+    LPBITMAPINFOHEADER  bmihc = NULL;
+    int                 result = 0;
+    HBITMAP             hbitmap = 0;
+    LPBYTE              bits = NULL,nbits = NULL;
+    int                 nbytesperline,bytesperline;
+
+    if (!SUCCEEDED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL))     ||
+        (bmfh.bfType != (('M'<<8)|'B'))                                 ||
+        !SUCCEEDED(IStream_Read ( pstm, &bmih, sizeof(bmih), NULL))     ||
+        (bmih.biSize != sizeof(bmih))
     )
-    return 0;
+        return 0;
 
     bitsperpixel = bmih.biPlanes * bmih.biBitCount;
     if (bitsperpixel<=8)
-        palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
+        palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
     else
-        palspace = 0;
+        palspace = 0;
     width = bmih.biWidth;
     height = bmih.biHeight;
     bmihc = (LPBITMAPINFOHEADER)LocalAlloc(LMEM_ZEROINIT,sizeof(bmih)+palspace);
     memcpy(bmihc,&bmih,sizeof(bmih));
-    longsperline    = ((width*bitsperpixel+31)&~0x1f)>>5;
-    bmihc->biSizeImage  = (longsperline*height)<<2;
+    longsperline        = ((width*bitsperpixel+31)&~0x1f)>>5;
+    bmihc->biSizeImage  = (longsperline*height)<<2;
 
     /* read the palette right after the end of the bitmapinfoheader */
     if (palspace)
-    if (!SUCCEEDED(IStream_Read ( pstm, bmihc+1, palspace, NULL)))
-        goto ret1;
+        if (!SUCCEEDED(IStream_Read ( pstm, bmihc+1, palspace, NULL)))
+            goto ret1;
 
     xdc = GetDC(0);
 #if 0 /* Magic for NxM -> 1x(N*M) not implemented for DIB Sections */
     if ((bitsperpixel>1) &&
-    ((ilcFlag!=ILC_COLORDDB) && (!ilcFlag || may_use_dibsection(xdc)))
+        ((ilcFlag!=ILC_COLORDDB) && (!ilcFlag || may_use_dibsection(xdc)))
      ) {
-    hbitmap = CreateDIBSection(xdc,(BITMAPINFO*)bmihc,0,(LPVOID*)&bits,0,0);
-    if (!hbitmap)
-        goto ret1;
-    if (!SUCCEEDED(IStream_Read( pstm, bits, bmihc->biSizeImage, NULL)))
-        goto ret1;
-    result = 1;
+        hbitmap = CreateDIBSection(xdc,(BITMAPINFO*)bmihc,0,(LPVOID*)&bits,0,0);
+        if (!hbitmap)
+            goto ret1;
+        if (!SUCCEEDED(IStream_Read( pstm, bits, bmihc->biSizeImage, NULL)))
+            goto ret1;
+        result = 1;
     } else
 #endif
     {
-    int i,nwidth,nheight;
-
-    nwidth  = width*(height/cy);
-    nheight = cy;
-
-    if (bitsperpixel==1)
-        hbitmap = CreateBitmap(nwidth,nheight,1,1,NULL);
-    else
-        hbitmap = CreateCompatibleBitmap(xdc,nwidth,nheight);
-
-    /* Might be a bit excessive memory use here */
-    bits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
-    nbits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
-    if (!SUCCEEDED(IStream_Read ( pstm, bits, bmihc->biSizeImage, NULL)))
-        goto ret1;
-
-    /* Copy the NxM bitmap into a 1x(N*M) bitmap we need, linewise */
-    /* Do not forget that windows bitmaps are bottom->top */
-    bytesperline    = longsperline*4;
-    nbytesperline   = (height/cy)*bytesperline;
-    for (i=0;i<height;i++) {
-        memcpy(
-        nbits+((height-1-i)%cy)*nbytesperline+(i/cy)*bytesperline,
-        bits+bytesperline*(height-1-i),
-        bytesperline
-        );
-    }
-    bmihc->biWidth  = nwidth;
-    bmihc->biHeight = nheight;
-    if (!SetDIBits(xdc,hbitmap,0,nheight,nbits,(BITMAPINFO*)bmihc,0))
-        goto ret1;
-    LocalFree((HLOCAL)nbits);
-    LocalFree((HLOCAL)bits);
-    result = 1;
+        int i,nwidth,nheight;
+
+        nwidth  = width*(height/cy);
+        nheight = cy;
+
+        if (bitsperpixel==1)
+            hbitmap = CreateBitmap(nwidth,nheight,1,1,NULL);
+        else
+            hbitmap = CreateCompatibleBitmap(xdc,nwidth,nheight);
+
+        /* Might be a bit excessive memory use here */
+        bits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
+        nbits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
+        if (!SUCCEEDED(IStream_Read ( pstm, bits, bmihc->biSizeImage, NULL)))
+                goto ret1;
+
+        /* Copy the NxM bitmap into a 1x(N*M) bitmap we need, linewise */
+        /* Do not forget that windows bitmaps are bottom->top */
+        bytesperline    = longsperline*4;
+        nbytesperline   = (height/cy)*bytesperline;
+        for (i=0;i<height;i++) {
+            memcpy(
+                nbits+((height-1-i)%cy)*nbytesperline+(i/cy)*bytesperline,
+                bits+bytesperline*(height-1-i),
+                bytesperline
+            );
+        }
+        bmihc->biWidth  = nwidth;
+        bmihc->biHeight = nheight;
+        if (!SetDIBits(xdc,hbitmap,0,nheight,nbits,(BITMAPINFO*)bmihc,0))
+                goto ret1;
+        LocalFree((HLOCAL)nbits);
+        LocalFree((HLOCAL)bits);
+        result = 1;
     }
 ret1:
-    if (xdc)    ReleaseDC(0,xdc);
-    if (bmihc)  LocalFree((HLOCAL)bmihc);
+    if (xdc)    ReleaseDC(0,xdc);
+    if (bmihc)  LocalFree((HLOCAL)bmihc);
     if (!result) {
-    if (hbitmap) {
-        DeleteObject(hbitmap);
-        hbitmap = 0;
-    }
+        if (hbitmap) {
+            DeleteObject(hbitmap);
+            hbitmap = 0;
+        }
     }
     return hbitmap;
@@ -2062 +2062 @@
  *
  * The format is like this:
- *  ILHEAD          ilheadstruct;
+ *      ILHEAD                  ilheadstruct;
  *
  * for the color image part:
- *  BITMAPFILEHEADER    bmfh;
- *  BITMAPINFOHEADER    bmih;
+ *      BITMAPFILEHEADER        bmfh; 
+ *      BITMAPINFOHEADER        bmih;
  * only if it has a palette:
- *  RGBQUAD     rgbs[nr_of_paletted_colors];
- *
- *  BYTE            colorbits[imagesize];
+ *      RGBQUAD         rgbs[nr_of_paletted_colors]; 
+ *
+ *      BYTE                    colorbits[imagesize];
  *
  * the following only if the ILC_MASK bit is set in ILHEAD.ilFlags:
- *  BITMAPFILEHEADER    bmfh_mask;
- *  BITMAPINFOHEADER    bmih_mask;
+ *      BITMAPFILEHEADER        bmfh_mask;
+ *      BITMAPINFOHEADER        bmih_mask;
  * only if it has a palette (it usually does not):
- *  RGBQUAD     rgbs[nr_of_paletted_colors];
- *
- *  BYTE            maskbits[imagesize];
+ *      RGBQUAD         rgbs[nr_of_paletted_colors]; 
+ *
+ *      BYTE                    maskbits[imagesize];
  *
  * CAVEAT: Those images are within a NxM bitmap, not the 1xN we expect.
@@ -2085 +2085 @@
 HIMAGELIST WINAPI ImageList_Read (LPSTREAM pstm)
 {
-    ILHEAD  ilHead;
-    HIMAGELIST  himl;
-    HBITMAP hbmColor=0,hbmMask=0;
-    int     i;
+    ILHEAD      ilHead;
+    HIMAGELIST  himl;
+    HBITMAP     hbmColor=0,hbmMask=0;
+    int         i;
 
     if (!SUCCEEDED(IStream_Read (pstm, &ilHead, sizeof(ILHEAD), NULL)))
-        return NULL;
+        return NULL;
     if (ilHead.usMagic != (('L' << 8) | 'I'))
-    return NULL;
+        return NULL;
     if (ilHead.usVersion != 0x101) /* probably version? */
-    return NULL;
+        return NULL;
 
 #if 0
-    FIXME(" ilHead.cCurImage = %d\n",ilHead.cCurImage);
-    FIXME(" ilHead.cMaxImage = %d\n",ilHead.cMaxImage);
-    FIXME(" ilHead.cGrow = %d\n",ilHead.cGrow);
-    FIXME(" ilHead.cx = %d\n",ilHead.cx);
-    FIXME(" ilHead.cy = %d\n",ilHead.cy);
-    FIXME(" ilHead.flags = %x\n",ilHead.flags);
-    FIXME(" ilHead.ovls[0] = %d\n",ilHead.ovls[0]);
-    FIXME(" ilHead.ovls[1] = %d\n",ilHead.ovls[1]);
-    FIXME(" ilHead.ovls[2] = %d\n",ilHead.ovls[2]);
-    FIXME(" ilHead.ovls[3] = %d\n",ilHead.ovls[3]);
+    FIXME("     ilHead.cCurImage = %d\n",ilHead.cCurImage);
+    FIXME("     ilHead.cMaxImage = %d\n",ilHead.cMaxImage);
+    FIXME("     ilHead.cGrow = %d\n",ilHead.cGrow);
+    FIXME("     ilHead.cx = %d\n",ilHead.cx);
+    FIXME("     ilHead.cy = %d\n",ilHead.cy);
+    FIXME("     ilHead.flags = %x\n",ilHead.flags);
+    FIXME("     ilHead.ovls[0] = %d\n",ilHead.ovls[0]);
+    FIXME("     ilHead.ovls[1] = %d\n",ilHead.ovls[1]);
+    FIXME("     ilHead.ovls[2] = %d\n",ilHead.ovls[2]);
+    FIXME("     ilHead.ovls[3] = %d\n",ilHead.ovls[3]);
 #endif
 
     hbmColor = _read_bitmap(pstm,ilHead.flags & ~ILC_MASK,ilHead.cx,ilHead.cy);
     if (!hbmColor)
-    return NULL;
+        return NULL;
     if (ilHead.flags & ILC_MASK) {
-    hbmMask = _read_bitmap(pstm,0,ilHead.cx,ilHead.cy);
-    if (!hbmMask) {
-        DeleteObject(hbmColor);
-        return NULL;
-    }
+        hbmMask = _read_bitmap(pstm,0,ilHead.cx,ilHead.cy);
+        if (!hbmMask) {
+            DeleteObject(hbmColor);
+            return NULL;
+        }
     }
 
     himl = ImageList_Create (
-            ilHead.cx,
-            ilHead.cy,
-            ilHead.flags,
-            1,      /* initial */
-            ilHead.cGrow
+                    ilHead.cx,
+                    ilHead.cy,
+                    ilHead.flags,
+                    1,          /* initial */
+                    ilHead.cGrow
     );
     if (!himl) {
-    DeleteObject(hbmColor);
-    DeleteObject(hbmMask);
-    return NULL;
+        DeleteObject(hbmColor);
+        DeleteObject(hbmMask);
+        return NULL;
     }
     himl->hbmImage = hbmColor;
@@ -2140 +2140 @@
     ImageList_SetBkColor(himl,ilHead.bkcolor);
     for (i=0;i<4;i++)
-        ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
+        ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
     return himl;
 }
@@ -2168 +2168 @@
         return FALSE;
     }
-
+    
     if ((i < -1) || (i >= himl->cCurImage)) {
         ERR("index out of range! %d\n", i);
@@ -2211 +2211 @@
         TRACE(" - Max. number of images: %d / %d (Old/New)\n",
                  himl->cMaxImage, himl->cCurImage + himl->cGrow - 1);
-
+        
         hbmNewImage =
             CreateBitmap (cxNew, himl->cy, 1, himl->uBitsPixel, NULL);
@@ -2226 +2226 @@
         if (i > 0) {
             TRACE("Pre image copy: Copy %d images\n", i);
-
+       
             SelectObject (hdcSrc, himl->hbmImage);
             SelectObject (hdcDst, hbmNewImage);
@@ -2277 +2277 @@
 
 /*************************************************************************
- * ImageList_Replace [COMCTL32.70]
+ * ImageList_Replace [COMCTL32.70] 
  *
  * Replaces an image in an image list with a new image.
@@ -2294 +2294 @@
 BOOL WINAPI
 ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage,
-           HBITMAP hbmMask)
+                   HBITMAP hbmMask)
 {
     HDC hdcImageList, hdcImage;
@@ -2303 +2303 @@
         return FALSE;
     }
-
+    
     if ((i >= himl->cMaxImage) || (i < 0)) {
         ERR("Invalid image index!\n");
@@ -2333 +2333 @@
         */
         SelectObject (hdcImageList, himl->hbmImage);
-        StretchBlt (hdcImageList,
+        StretchBlt (hdcImageList, 
             i*himl->cx, 0, himl->cx, himl->cy,
-            hdcImage,
-            0, 0, bmp.bmWidth, bmp.bmHeight,
+            hdcImage, 
+            0, 0, bmp.bmWidth, bmp.bmHeight, 
             0x220326); /* NOTSRCAND */
     }
@@ -2375 +2375 @@
 
     if (himl == NULL)
-    return -1;
+        return -1;
     if ((i >= himl->cMaxImage) || (i < -1))
-    return -1;
+        return -1;
 
     hBestFitIcon = CopyImage(
-        hIcon, IMAGE_ICON,
-        himl->cx, himl->cy,
+        hIcon, IMAGE_ICON, 
+        himl->cx, himl->cy, 
         LR_COPYFROMRESOURCE);
 
     GetIconInfo (hBestFitIcon, &ii);
     if (ii.hbmMask == 0)
-    ERR("no mask!\n");
+        ERR("no mask!\n");
     if (ii.hbmColor == 0)
-    ERR("no color!\n");
+        ERR("no color!\n");
     GetObjectA (ii.hbmMask, sizeof(BITMAP), (LPVOID)&bmp);
 
@@ -2404 +2404 @@
     TRACE("hdcImageList=0x%x!\n", hdcImageList);
     if (hdcImageList == 0)
-    ERR("invalid hdcImageList!\n");
+        ERR("invalid hdcImageList!\n");
 
     hdcImage = CreateCompatibleDC (0);
     TRACE("hdcImage=0x%x!\n", hdcImage);
     if (hdcImage == 0)
-    ERR("invalid hdcImage!\n");
+        ERR("invalid hdcImage!\n");
 
     hbmOldDst = SelectObject (hdcImageList, himl->hbmImage);
@@ -2429 +2429 @@
 
     if(hBestFitIcon)
-    DestroyIcon(hBestFitIcon);
+        DestroyIcon(hBestFitIcon);
     if (hdcImageList)
-    DeleteDC (hdcImageList);
+        DeleteDC (hdcImageList);
     if (hdcImage)
-    DeleteDC (hdcImage);
+        DeleteDC (hdcImage);
     if (ii.hbmColor)
-    DeleteObject (ii.hbmColor);
+        DeleteObject (ii.hbmColor);
     if (ii.hbmMask)
-    DeleteObject (ii.hbmMask);
+        DeleteObject (ii.hbmMask);
 
     return nIndex;
@@ -2444 +2444 @@
 
 /*************************************************************************
- * ImageList_SetBkColor [COMCTL32.76]
+ * ImageList_SetBkColor [COMCTL32.76] 
  *
  * Sets the background color of an image list.
@@ -2463 +2463 @@
 
     if (himl == NULL)
-    return CLR_NONE;
+        return CLR_NONE;
 
     clrOldBk = himl->clrBk;
@@ -2492 +2492 @@
 BOOL WINAPI
 ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag,
-                  INT dxHotspot, INT dyHotspot)
+                              INT dxHotspot, INT dyHotspot)
 {
     HIMAGELIST himlTemp;
@@ -2499 +2499 @@
 
     if (himlInternalDrag == NULL)
-    return FALSE;
+        return FALSE;
 
     TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
-       dxHotspot, dyHotspot, nInternalDragHotspotX, nInternalDragHotspotY);
+           dxHotspot, dyHotspot, nInternalDragHotspotX, nInternalDragHotspotY);
 
     himlTemp = ImageList_Merge (himlInternalDrag, 0, himlDrag, iDrag,
-                dxHotspot, dyHotspot);
+                                dxHotspot, dyHotspot);
 
     ImageList_Destroy (himlInternalDrag);
@@ -2518 +2518 @@
 
 /*************************************************************************
- * ImageList_SetFilter [COMCTL32.78]
+ * ImageList_SetFilter [COMCTL32.78] 
  *
  * Sets a filter (or does something completely different)!!???
@@ -2540 +2540 @@
 {
     FIXME("(%p 0x%x 0x%lx):empty stub!\n",
-       himl, i, dwFilter);
+           himl, i, dwFilter);
 
     return FALSE;
@@ -2567 +2567 @@
 
     if (!himl)
-    return FALSE;
+        return FALSE;
 
     /* remove all images */
@@ -2617 +2617 @@
 
     if (!himl)
-    return FALSE;
+        return FALSE;
     if (himl->cCurImage >= iImageCount)
-    return FALSE;
+        return FALSE;
     if (himl->cMaxImage > iImageCount)
-    return TRUE;
+        return TRUE;
 
     nNewCount = iImageCount + himl->cGrow;
@@ -2636 +2636 @@
         SelectObject (hdcBitmap, hbmNewBitmap);
 
-    /* copy images */
+        /* copy images */
         BitBlt (hdcBitmap, 0, 0, nCopyCount * himl->cx, himl->cy,
                   hdcImageList, 0, 0, SRCCOPY);
 #if 0
-    /* delete 'empty' image space */
-    SetBkColor (hdcBitmap, RGB(255, 255, 255));
-    SetTextColor (hdcBitmap, RGB(0, 0, 0));
-    PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0,
-          (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
+        /* delete 'empty' image space */
+        SetBkColor (hdcBitmap, RGB(255, 255, 255));
+        SetTextColor (hdcBitmap, RGB(0, 0, 0));
+        PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0, 
+                  (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
 #endif
-    DeleteObject (himl->hbmImage);
-    himl->hbmImage = hbmNewBitmap;
+        DeleteObject (himl->hbmImage);
+        himl->hbmImage = hbmNewBitmap;
     }
     else
-    ERR("Could not create new image bitmap !\n");
+        ERR("Could not create new image bitmap !\n");
 
     if (himl->hbmMask)
@@ -2661 +2661 @@
             SelectObject (hdcBitmap, hbmNewBitmap);
 
-        /* copy images */
+            /* copy images */
             BitBlt (hdcBitmap, 0, 0, nCopyCount * himl->cx, himl->cy,
                       hdcImageList, 0, 0, SRCCOPY);
 #if 0
-        /* delete 'empty' image space */
-        SetBkColor (hdcBitmap, RGB(255, 255, 255));
-        SetTextColor (hdcBitmap, RGB(0, 0, 0));
-            PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0,
-              (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
+            /* delete 'empty' image space */
+            SetBkColor (hdcBitmap, RGB(255, 255, 255));
+            SetTextColor (hdcBitmap, RGB(0, 0, 0));
+            PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0, 
+                      (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
 #endif
             DeleteObject (himl->hbmMask);
@@ -2709 +2709 @@
 {
     if (!himl)
-    return FALSE;
+        return FALSE;
     if ((iOverlay < 1) || (iOverlay > MAX_OVERLAYIMAGE))
-    return FALSE;
+        return FALSE;
     if ((iImage!=-1) && ((iImage < 0) || (iImage > himl->cCurImage)))
-    return FALSE;
+        return FALSE;
     himl->nOvlIdx[iOverlay - 1] = iImage;
     return TRUE;
@@ -2744 +2744 @@
 {
     if (!himl)
+        return FALSE;
+
+    FIXME("empty stub!\n");
+
     return FALSE;
-
-    FIXME("empty stub!\n");
-
-    return FALSE;
-}
-
+}
+